https://www.jova.tv/sites/all/themes/jovatv/video-js/video.js?sz50wi

1/**
2 * @license
3 * Video.js 5.10.5 <http://videojs.com/>
4 * Copyright Brightcove, Inc. <https://www.brightcove.com/>
5 * Available under Apache License Version 2.0
6 * <https://github.com/videojs/video.js/blob/master/LICENSE>
7 *
8 * Includes vtt.js <https://github.com/mozilla/vtt.js>
9 * Available under Apache License Version 2.0
10 * <https://github.com/mozilla/vtt.js/blob/master/LICENSE>
11 */
12
13(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.videojs = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
14(function (global){
15var topLevel = typeof global !== 'undefined' ? global :
16    typeof window !== 'undefined' ? window : {}
17var minDoc = _dereq_('min-document');
18
19if (typeof document !== 'undefined') {
20    module.exports = document;
21} else {
22    var doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'];
23
24    if (!doccy) {
25        doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDoc;
26    }
27
28    module.exports = doccy;
29}
30
31}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
32//# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9nbG9iYWwvZG9jdW1lbnQuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBIiwiZmlsZSI6ImdlbmVyYXRlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgdG9wTGV2ZWwgPSB0eXBlb2YgZ2xvYmFsICE9PSAndW5kZWZpbmVkJyA/IGdsb2JhbCA6XG4gICAgdHlwZW9mIHdpbmRvdyAhPT0gJ3VuZGVmaW5lZCcgPyB3aW5kb3cgOiB7fVxudmFyIG1pbkRvYyA9IHJlcXVpcmUoJ21pbi1kb2N1bWVudCcpO1xuXG5pZiAodHlwZW9mIGRvY3VtZW50ICE9PSAndW5kZWZpbmVkJykge1xuICAgIG1vZHVsZS5leHBvcnRzID0gZG9jdW1lbnQ7XG59IGVsc2Uge1xuICAgIHZhciBkb2NjeSA9IHRvcExldmVsWydfX0dMT0JBTF9ET0NVTUVOVF9DQUNIRUA0J107XG5cbiAgICBpZiAoIWRvY2N5KSB7XG4gICAgICAgIGRvY2N5ID0gdG9wTGV2ZWxbJ19fR0xPQkFMX0RPQ1VNRU5UX0NBQ0hFQDQnXSA9IG1pbkRvYztcbiAgICB9XG5cbiAgICBtb2R1bGUuZXhwb3J0cyA9IGRvY2N5O1xufVxuIl19
33},{"min-document":3}],2:[function(_dereq_,module,exports){
34(function (global){
35if (typeof window !== "undefined") {
36    module.exports = window;
37} else if (typeof global !== "undefined") {
38    module.exports = global;
39} else if (typeof self !== "undefined"){
40    module.exports = self;
41} else {
42    module.exports = {};
43}
44
45}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
46//# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9nbG9iYWwvd2luZG93LmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQSIsImZpbGUiOiJnZW5lcmF0ZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlc0NvbnRlbnQiOlsiaWYgKHR5cGVvZiB3aW5kb3cgIT09IFwidW5kZWZpbmVkXCIpIHtcbiAgICBtb2R1bGUuZXhwb3J0cyA9IHdpbmRvdztcbn0gZWxzZSBpZiAodHlwZW9mIGdsb2JhbCAhPT0gXCJ1bmRlZmluZWRcIikge1xuICAgIG1vZHVsZS5leHBvcnRzID0gZ2xvYmFsO1xufSBlbHNlIGlmICh0eXBlb2Ygc2VsZiAhPT0gXCJ1bmRlZmluZWRcIil7XG4gICAgbW9kdWxlLmV4cG9ydHMgPSBzZWxmO1xufSBlbHNlIHtcbiAgICBtb2R1bGUuZXhwb3J0cyA9IHt9O1xufVxuIl19
47},{}],3:[function(_dereq_,module,exports){
48
49},{}],4:[function(_dereq_,module,exports){
50var getNative = _dereq_('../internal/getNative');
51
52/* Native method references for those with the same name as other `lodash` methods. */
53var nativeNow = getNative(Date, 'now');
54
55/**
56 * Gets the number of milliseconds that have elapsed since the Unix epoch
57 * (1 January 1970 00:00:00 UTC).
58 *
59 * @static
60 * @memberOf _
61 * @category Date
62 * @example
63 *
64 * _.defer(function(stamp) {
65 *   console.log(_.now() - stamp);
66 * }, _.now());
67 * // => logs the number of milliseconds it took for the deferred function to be invoked
68 */
69var now = nativeNow || function() {
70  return new Date().getTime();
71};
72
73module.exports = now;
74
75},{"../internal/getNative":20}],5:[function(_dereq_,module,exports){
76var isObject = _dereq_('../lang/isObject'),
77    now = _dereq_('../date/now');
78
79/** Used as the `TypeError` message for "Functions" methods. */

80var FUNC_ERROR_TEXT = 'Expected a function';
81
82/* Native method references for those with the same name as other `lodash` methods. */
83var nativeMax = Math.max;
84
85/**
86 * Creates a debounced function that delays invoking `func` until after `wait`
87 * milliseconds have elapsed since the last time the debounced function was
88 * invoked. The debounced function comes with a `cancel` method to cancel
89 * delayed invocations. Provide an options object to indicate that `func`
90 * should be invoked on the leading and/or trailing edge of the `wait` timeout.
91 * Subsequent calls to the debounced function return the result of the last
92 * `func` invocation.
93 *
94 * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
95 * on the trailing edge of the timeout only if the the debounced function is
96 * invoked more than once during the `wait` timeout.
97 *
98 * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
99 * for details over the differences between `_.debounce` and `_.throttle`.
100 *
101 * @static
102 * @memberOf _
103 * @category Function
104 * @param {Function} func The function to debounce.
105 * @param {number} [wait=0] The number of milliseconds to delay.
106 * @param {Object} [options] The options object.
107 * @param {boolean} [options.leading=false] Specify invoking on the leading
108 *  edge of the timeout.
109 * @param {number} [options.maxWait] The maximum time `func` is allowed to be
110 *  delayed before it's invoked.
111 * @param {boolean} [options.trailing=true] Specify invoking on the trailing
112 *  edge of the timeout.
113 * @returns {Function} Returns the new debounced function.
114 * @example
115 *
116 * // avoid costly calculations while the window size is in flux
117 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
118 *
119 * // invoke `sendMail` when the click event is fired, debouncing subsequent calls
120 * jQuery('#postbox').on('click', _.debounce(sendMail, 300, {
121 *   'leading': true,
122 *   'trailing': false
123 * }));
124 *
125 * // ensure `batchLog` is invoked once after 1 second of debounced calls
126 * var source = new EventSource('/stream');
127 * jQuery(source).on('message', _.debounce(batchLog, 250, {
128 *   'maxWait': 1000
129 * }));
130 *
131 * // cancel a debounced call
132 * var todoChanges = _.debounce(batchLog, 1000);
133 * Object.observe(models.todo, todoChanges);
134 *
135 * Object.observe(models, function(changes) {
136 *   if (_.find(changes, { 'user': 'todo', 'type': 'delete'})) {
137 *     todoChanges.cancel();
138 *   }
139 * }, ['delete']);
140 *
141 * // ...at some point `models.todo` is changed
142 * models.todo.completed = true;
143 *
144 * // ...before 1 second has passed `models.todo` is deleted
145 * // which cancels the debounced `todoChanges` call
146 * delete models.todo;
147 */
148function debounce(func, wait, options) {
149  var args,
150      maxTimeoutId,
151      result,
152      stamp,
153      thisArg,
154      timeoutId,
155      trailingCall,
156      lastCalled = 0,
157      maxWait = false,
158      trailing = true;
159
160  if (typeof func != 'function') {
161    throw new TypeError(FUNC_ERROR_TEXT);
162  }
163  wait = wait < 0 ? 0 : (+wait || 0);
164  if (options === true) {
165    var leading = true;
166    trailing = false;
167  } else if (isObject(options)) {
168    leading = !!options.leading;
169    maxWait = 'maxWait' in options && nativeMax(+options.maxWait || 0, wait);
170    trailing = 'trailing' in options ? !!options.trailing : trailing;
171  }
172
173  function cancel() {
174    if (timeoutId) {
175      clearTimeout(timeoutId);
176    }
177    if (maxTimeoutId) {
178      clearTimeout(maxTimeoutId);
179    }
180    lastCalled = 0;
181    maxTimeoutId = timeoutId = trailingCall = undefined;
182  }
183
184  function complete(isCalled, id) {
185    if (id) {
186      clearTimeout(id);
187    }
188    maxTimeoutId = timeoutId = trailingCall = undefined;
189    if (isCalled) {
190      lastCalled = now();
191      result = func.apply(thisArg, args);
192      if (!timeoutId && !maxTimeoutId) {
193        args = thisArg = undefined;
194      }
195    }
196  }
197
198  function delayed() {
199    var remaining = wait - (now() - stamp);
200    if (remaining <= 0 || remaining > wait) {
201      complete(trailingCall, maxTimeoutId);
202    } else {
203      timeoutId = setTimeout(delayed, remaining);
204    }
205  }
206
207  function maxDelayed() {
208    complete(trailing, timeoutId);
209  }
210
211  function debounced() {
212    args = arguments;
213    stamp = now();
214    thisArg = this;
215    trailingCall = trailing && (timeoutId || !leading);
216
217    if (maxWait === false) {
218      var leadingCall = leading && !timeoutId;
219    } else {
220      if (!maxTimeoutId && !leading) {
221        lastCalled = stamp;
222      }
223      var remaining = maxWait - (stamp - lastCalled),
224          isCalled = remaining <= 0 || remaining > maxWait;
225
226      if (isCalled) {
227        if (maxTimeoutId) {
228          maxTimeoutId = clearTimeout(maxTimeoutId);
229        }
230        lastCalled = stamp;
231        result = func.apply(thisArg, args);
232      }
233      else if (!maxTimeoutId) {
234        maxTimeoutId = setTimeout(maxDelayed, remaining);
235      }
236    }
237    if (isCalled && timeoutId) {
238      timeoutId = clearTimeout(timeoutId);
239    }
240    else if (!timeoutId && wait !== maxWait) {
241      timeoutId = setTimeout(delayed, wait);
242    }
243    if (leadingCall) {
244      isCalled = true;
245      result = func.apply(thisArg, args);
246    }
247    if (isCalled && !timeoutId && !maxTimeoutId) {
248      args = thisArg = undefined;
249    }
250    return result;
251  }
252  debounced.cancel = cancel;
253  return debounced;
254}
255
256module.exports = debounce;
257
258},{"../date/now":4,"../lang/isObject":33}],6:[function(_dereq_,module,exports){
259/** Used as the `TypeError` message for "Functions" methods. */
260var FUNC_ERROR_TEXT = 'Expected a function';
261
262/* Native method references for those with the same name as other `lodash` methods. */
263var nativeMax = Math.max;
264
265/**
266 * Creates a function that invokes `func` with the `this` binding of the
267 * created function and arguments from `start` and beyond provided as an array.
268 *
269 * **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/Web/JavaScript/Reference/Functions/rest_parameters).
270 *
271 * @static
272 * @memberOf _
273 * @category Function
274 * @param {Function} func The function to apply a rest parameter to.
275 * @param {number} [start=func.length-1] The start position of the rest parameter.
276 * @returns {Function} Returns the new function.
277 * @example
278 *
279 * var say = _.restParam(function(what, names) {
280 *   return what + ' ' + _.initial(names).join(', ') +
281 *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);
282 * });
283 *
284 * say('hello', 'fred', 'barney', 'pebbles');
285 * // => 'hello fred, barney, & pebbles'
286 */
287function restParam(func, start) {
288  if (typeof func != 'function') {
289    throw new TypeError(FUNC_ERROR_TEXT);
290  }
291  start = nativeMax(start === undefined ? (func.length - 1) : (+start || 0), 0);
292  return function() {
293    var args = arguments,
294        index = -1,
295        length = nativeMax(args.length - start, 0),
296        rest = Array(length);
297
298    while (++index < length) {
299      rest[index] = args[start + index];
300    }
301    switch (start) {
302      case 0: return func.call(this, rest);
303      case 1: return func.call(this, args[0], rest);
304      case 2: return func.call(this, args[0], args[1], rest);
305    }
306    var otherArgs = Array(start + 1);
307    index = -1;
308    while (++index < start) {
309      otherArgs[index] = args[index];
310    }
311    otherArgs[start] = rest;
312    return func.apply(this, otherArgs);
313  };
314}
315
316module.exports = restParam;
317
318},{}],7:[function(_dereq_,module,exports){
319var debounce = _dereq_('./debounce'),
320    isObject = _dereq_('../lang/isObject');
321
322/** Used as the `TypeError` message for "Functions" methods. */
323var FUNC_ERROR_TEXT = 'Expected a function';
324
325/**
326 * Creates a throttled function that only invokes `func` at most once per
327 * every `wait` milliseconds. The throttled function comes with a `cancel`
328 * method to cancel delayed invocations. Provide an options object to indicate
329 * that `func` should be invoked on the leading and/or trailing edge of the
330 * `wait` timeout. Subsequent calls to the throttled function return the
331 * result of the last `func` call.
332 *
333 * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
334 * on the trailing edge of the timeout only if the the throttled function is
335 * invoked more than once during the `wait` timeout.
336 *
337 * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
338 * for details over the differences between `_.throttle` and `_.debounce`.
339 *
340 * @static
341 * @memberOf _
342 * @category Function
343 * @param {Function} func The function to throttle.
344 * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
345 * @param {Object} [options] The options object.
346 * @param {boolean} [options.leading=true] Specify invoking on the leading
347 *  edge of the timeout.
348 * @param {boolean} [options.trailing=true] Specify invoking on the trailing
349 *  edge of the timeout.
350 * @returns {Function} Returns the new throttled function.
351 * @example
352 *
353 * // avoid excessively updating the position while scrolling
354 * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
355 *
356 * // invoke `renewToken` when the click event is fired, but not more than once every 5 minutes
357 * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {
358 *   'trailing': false
359 * }));
360 *
361 * // cancel a trailing throttled call
362 * jQuery(window).on('popstate', throttled.cancel);
363 */
364function throttle(func, wait, options) {
365  var leading = true,
366      trailing = true;
367
368  if (typeof func != 'function') {
369    throw new TypeError(FUNC_ERROR_TEXT);
370  }
371  if (options === false) {
372    leading = false;
373  } else if (isObject(options)) {
374    leading = 'leading' in options ? !!options.leading : leading;
375    trailing = 'trailing' in options ? !!options.trailing : trailing;
376  }
377  return debounce(func, wait, { 'leading': leading, 'maxWait': +wait, 'trailing': trailing });
378}
379
380module.exports = throttle;
381
382},{"../lang/isObject":33,"./debounce":5}],8:[function(_dereq_,module,exports){
383/**
384 * Copies the values of `source` to `array`.
385 *
386 * @private
387 * @param {Array} source The array to copy values from.
388 * @param {Array} [array=[]] The array to copy values to.
389 * @returns {Array} Returns `array`.
390 */
391function arrayCopy(source, array) {
392  var index = -1,
393      length = source.length;
394
395  array || (array = Array(length));
396  while (++index < length) {
397    array[index] = source[index];
398  }
399  return array;
400}
401
402module.exports = arrayCopy;
403
404},{}],9:[function(_dereq_,module,exports){
405/**
406 * A specialized version of `_.forEach` for arrays without support for callback
407 * shorthands and `this` binding.
408 *
409 * @private
410 * @param {Array} array The array to iterate over.
411 * @param {Function} iteratee The function invoked per iteration.
412 * @returns {Array} Returns `array`.
413 */
414function arrayEach(array, iteratee) {
415  var index = -1,
416      length = array.length;
417
418  while (++index < length) {
419    if (iteratee(array[index], index, array) === false) {
420      break;
421    }
422  }
423  return array;
424}
425
426module.exports = arrayEach;
427
428},{}],10:[function(_dereq_,module,exports){
429/**
430 * Copies properties of `source` to `object`.
431 *
432 * @private
433 * @param {Object} source The object to copy properties from.
434 * @param {Array} props The property names to copy.
435 * @param {Object} [object={}] The object to copy properties to.
436 * @returns {Object} Returns `object`.
437 */
438function baseCopy(source, props, object) {
439  object || (object = {});
440
441  var index = -1,
442      length = props.length;
443
444  while (++index < length) {
445    var key = props[index];
446    object[key] = source[key];
447  }
448  return object;
449}
450
451module.exports = baseCopy;
452
453},{}],11:[function(_dereq_,module,exports){
454var createBaseFor = _dereq_('./createBaseFor');
455
456/**
457 * The base implementation of `baseForIn` and `baseForOwn` which iterates
458 * over `object` properties returned by `keysFunc` invoking `iteratee` for
459 * each property. Iteratee functions may exit iteration early by explicitly
460 * returning `false`.
461 *
462 * @private
463 * @param {Object} object The object to iterate over.
464 * @param {Function} iteratee The function invoked per iteration.
465 * @param {Function} keysFunc The function to get the keys of `object`.
466 * @returns {Object} Returns `object`.
467 */
468var baseFor = createBaseFor();
469
470module.exports = baseFor;
471
472},{"./createBaseFor":18}],12:[function(_dereq_,module,exports){
473var baseFor = _dereq_('./baseFor'),
474    keysIn = _dereq_('../object/keysIn');
475
476/**
477 * The base implementation of `_.forIn` without support for callback
478 * shorthands and `this` binding.
479 *
480 * @private
481 * @param {Object} object The object to iterate over.
482 * @param {Function} iteratee The function invoked per iteration.
483 * @returns {Object} Returns `object`.
484 */
485function baseForIn(object, iteratee) {
486  return baseFor(object, iteratee, keysIn);
487}
488
489module.exports = baseForIn;
490
491},{"../object/keysIn":39,"./baseFor":11}],13:[function(_dereq_,module,exports){
492var arrayEach = _dereq_('./arrayEach'),
493    baseMergeDeep = _dereq_('./baseMergeDeep'),
494    isArray = _dereq_('../lang/isArray'),
495    isArrayLike = _dereq_('./isArrayLike'),
496    isObject = _dereq_('../lang/isObject'),
497    isObjectLike = _dereq_('./isObjectLike'),
498    isTypedArray = _dereq_('../lang/isTypedArray'),
499    keys = _dereq_('../object/keys');
500
501/**
502 * The base implementation of `_.merge` without support for argument juggling,
503 * multiple sources, and `this` binding `customizer` functions.
504 *
505 * @private
506 * @param {Object} object The destination object.
507 * @param {Object} source The source object.
508 * @param {Function} [customizer] The function to customize merged values.
509 * @param {Array} [stackA=[]] Tracks traversed source objects.
510 * @param {Array} [stackB=[]] Associates values with source counterparts.
511 * @returns {Object} Returns `object`.
512 */
513function baseMerge(object, source, customizer, stackA, stackB) {
514  if (!isObject(object)) {
515    return object;
516  }
517  var isSrcArr = isArrayLike(source) && (isArray(source) || isTypedArray(source)),
518      props = isSrcArr ? undefined : keys(source);
519
520  arrayEach(props || source, function(srcValue, key) {
521    if (props) {
522      key = srcValue;
523      srcValue = source[key];
524    }
525    if (isObjectLike(srcValue)) {
526      stackA || (stackA = []);
527      stackB || (stackB = []);
528      baseMergeDeep(object, source, key, baseMerge, customizer, stackA, stackB);
529    }
530    else {
531      var value = object[key],
532          result = customizer ? customizer(value, srcValue, key, object, source) : undefined,
533          isCommon = result === undefined;
534
535      if (isCommon) {
536        result = srcValue;
537      }
538      if ((result !== undefined || (isSrcArr && !(key in object))) &&
539          (isCommon || (result === result ? (result !== value) : (value === value)))) {
540        object[key] = result;
541      }
542    }
543  });
544  return object;
545}
546
547module.exports = baseMerge;
548
549},{"../lang/isArray":30,"../lang/isObject":33,"../lang/isTypedArray":36,"../object/keys":38,"./arrayEach":9,"./baseMergeDeep":14,"./isArrayLike":21,"./isObjectLike":26}],14:[function(_dereq_,module,exports){
550var arrayCopy = _dereq_('./arrayCopy'),
551    isArguments = _dereq_('../lang/isArguments'),
552    isArray = _dereq_('../lang/isArray'),
553    isArrayLike = _dereq_('./isArrayLike'),
554    isPlainObject = _dereq_('../lang/isPlainObject'),
555    isTypedArray = _dereq_('../lang/isTypedArray'),
556    toPlainObject = _dereq_('../lang/toPlainObject');
557
558/**
559 * A specialized version of `baseMerge` for arrays and objects which performs
560 * deep merges and tracks traversed objects enabling objects with circular
561 * references to be merged.
562 *
563 * @private
564 * @param {Object} object The destination object.
565 * @param {Object} source The source object.
566 * @param {string} key The key of the value to merge.
567 * @param {Function} mergeFunc The function to merge values.
568 * @param {Function} [customizer] The function to customize merged values.
569 * @param {Array} [stackA=[]] Tracks traversed source objects.
570 * @param {Array} [stackB=[]] Associates values with source counterparts.
571 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
572 */
573function baseMergeDeep(object, source, key, mergeFunc, customizer, stackA, stackB) {
574  var length = stackA.length,
575      srcValue = source[key];
576
577  while (length--) {
578    if (stackA[length] == srcValue) {
579      object[key] = stackB[length];
580      return;
581    }
582  }
583  var value = object[key],
584      result = customizer ? customizer(value, srcValue, key, object, source) : undefined,
585      isCommon = result === undefined;
586
587  if (isCommon) {
588    result = srcValue;
589    if (isArrayLike(srcValue) && (isArray(srcValue) || isTypedArray(srcValue))) {
590      result = isArray(value)
591        ? value
592        : (isArrayLike(value) ? arrayCopy(value) : []);
593    }
594    else if (isPlainObject(srcValue) || isArguments(srcValue)) {
595      result = isArguments(value)
596        ? toPlainObject(value)
597        : (isPlainObject(value) ? value : {});
598    }
599    else {
600      isCommon = false;

601    }
602  }
603  // Add the source value to the stack of traversed objects and associate
604  // it with its merged value.
605  stackA.push(srcValue);
606  stackB.push(result);
607
608  if (isCommon) {
609    // Recursively merge objects and arrays (susceptible to call stack limits).
610    object[key] = mergeFunc(result, srcValue, customizer, stackA, stackB);
611  } else if (result === result ? (result !== value) : (value === value)) {
612    object[key] = result;
613  }
614}
615
616module.exports = baseMergeDeep;
617
618},{"../lang/isArguments":29,"../lang/isArray":30,"../lang/isPlainObject":34,"../lang/isTypedArray":36,"../lang/toPlainObject":37,"./arrayCopy":8,"./isArrayLike":21}],15:[function(_dereq_,module,exports){
619var toObject = _dereq_('./toObject');
620
621/**
622 * The base implementation of `_.property` without support for deep paths.
623 *
624 * @private
625 * @param {string} key The key of the property to get.
626 * @returns {Function} Returns the new function.
627 */
628function baseProperty(key) {
629  return function(object) {
630    return object == null ? undefined : toObject(object)[key];
631  };
632}
633
634module.exports = baseProperty;
635
636},{"./toObject":28}],16:[function(_dereq_,module,exports){
637var identity = _dereq_('../utility/identity');
638
639/**
640 * A specialized version of `baseCallback` which only supports `this` binding
641 * and specifying the number of arguments to provide to `func`.
642 *
643 * @private
644 * @param {Function} func The function to bind.
645 * @param {*} thisArg The `this` binding of `func`.
646 * @param {number} [argCount] The number of arguments to provide to `func`.
647 * @returns {Function} Returns the callback.
648 */
649function bindCallback(func, thisArg, argCount) {
650  if (typeof func != 'function') {
651    return identity;
652  }
653  if (thisArg === undefined) {
654    return func;
655  }
656  switch (argCount) {
657    case 1: return function(value) {
658      return func.call(thisArg, value);
659    };
660    case 3: return function(value, index, collection) {
661      return func.call(thisArg, value, index, collection);
662    };
663    case 4: return function(accumulator, value, index, collection) {
664      return func.call(thisArg, accumulator, value, index, collection);
665    };
666    case 5: return function(value, other, key, object, source) {
667      return func.call(thisArg, value, other, key, object, source);
668    };
669  }
670  return function() {
671    return func.apply(thisArg, arguments);
672  };
673}
674
675module.exports = bindCallback;
676
677},{"../utility/identity":42}],17:[function(_dereq_,module,exports){
678var bindCallback = _dereq_('./bindCallback'),
679    isIterateeCall = _dereq_('./isIterateeCall'),
680    restParam = _dereq_('../function/restParam');
681
682/**
683 * Creates a `_.assign`, `_.defaults`, or `_.merge` function.
684 *
685 * @private
686 * @param {Function} assigner The function to assign values.
687 * @returns {Function} Returns the new assigner function.
688 */
689function createAssigner(assigner) {
690  return restParam(function(object, sources) {
691    var index = -1,
692        length = object == null ? 0 : sources.length,
693        customizer = length > 2 ? sources[length - 2] : undefined,
694        guard = length > 2 ? sources[2] : undefined,
695        thisArg = length > 1 ? sources[length - 1] : undefined;
696
697    if (typeof customizer == 'function') {
698      customizer = bindCallback(customizer, thisArg, 5);
699      length -= 2;
700    } else {
701      customizer = typeof thisArg == 'function' ? thisArg : undefined;
702      length -= (customizer ? 1 : 0);
703    }
704    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
705      customizer = length < 3 ? undefined : customizer;
706      length = 1;
707    }
708    while (++index < length) {
709      var source = sources[index];
710      if (source) {
711        assigner(object, source, customizer);
712      }
713    }
714    return object;
715  });
716}
717
718module.exports = createAssigner;
719
720},{"../function/restParam":6,"./bindCallback":16,"./isIterateeCall":24}],18:[function(_dereq_,module,exports){
721var toObject = _dereq_('./toObject');
722
723/**
724 * Creates a base function for `_.forIn` or `_.forInRight`.
725 *
726 * @private
727 * @param {boolean} [fromRight] Specify iterating from right to left.
728 * @returns {Function} Returns the new base function.
729 */
730function createBaseFor(fromRight) {
731  return function(object, iteratee, keysFunc) {
732    var iterable = toObject(object),
733        props = keysFunc(object),
734        length = props.length,
735        index = fromRight ? length : -1;
736
737    while ((fromRight ? index-- : ++index < length)) {
738      var key = props[index];
739      if (iteratee(iterable[key], key, iterable) === false) {
740        break;
741      }
742    }
743    return object;
744  };
745}
746
747module.exports = createBaseFor;
748
749},{"./toObject":28}],19:[function(_dereq_,module,exports){
750var baseProperty = _dereq_('./baseProperty');
751
752/**
753 * Gets the "length" property value of `object`.
754 *
755 * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
756 * that affects Safari on at least iOS 8.1-8.3 ARM64.
757 *
758 * @private
759 * @param {Object} object The object to query.
760 * @returns {*} Returns the "length" value.
761 */
762var getLength = baseProperty('length');
763
764module.exports = getLength;
765
766},{"./baseProperty":15}],20:[function(_dereq_,module,exports){
767var isNative = _dereq_('../lang/isNative');
768
769/**
770 * Gets the native function at `key` of `object`.
771 *
772 * @private
773 * @param {Object} object The object to query.
774 * @param {string} key The key of the method to get.
775 * @returns {*} Returns the function if it's native, else `undefined`.
776 */
777function getNative(object, key) {
778  var value = object == null ? undefined : object[key];
779  return isNative(value) ? value : undefined;
780}
781
782module.exports = getNative;
783
784},{"../lang/isNative":32}],21:[function(_dereq_,module,exports){
785var getLength = _dereq_('./getLength'),
786    isLength = _dereq_('./isLength');
787
788/**
789 * Checks if `value` is array-like.
790 *
791 * @private
792 * @param {*} value The value to check.
793 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
794 */
795function isArrayLike(value) {
796  return value != null && isLength(getLength(value));
797}
798
799module.exports = isArrayLike;
800
801},{"./getLength":19,"./isLength":25}],22:[function(_dereq_,module,exports){
802/**
803 * Checks if `value` is a host object in IE < 9.
804 *
805 * @private
806 * @param {*} value The value to check.
807 * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
808 */
809var isHostObject = (function() {
810  try {
811    Object({ 'toString': 0 } + '');
812  } catch(e) {
813    return function() { return false; };
814  }
815  return function(value) {
816    // IE < 9 presents many host objects as `Object` objects that can coerce
817    // to strings despite having improperly defined `toString` methods.
818    return typeof value.toString != 'function' && typeof (value + '') == 'string';
819  };
820}());
821
822module.exports = isHostObject;
823
824},{}],23:[function(_dereq_,module,exports){
825/** Used to detect unsigned integer values. */
826var reIsUint = /^\d+$/;
827
828/**
829 * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
830 * of an array-like value.
831 */
832var MAX_SAFE_INTEGER = 9007199254740991;
833
834/**
835 * Checks if `value` is a valid array-like index.
836 *
837 * @private
838 * @param {*} value The value to check.
839 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
840 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
841 */
842function isIndex(value, length) {
843  value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;
844  length = length == null ? MAX_SAFE_INTEGER : length;
845  return value > -1 && value % 1 == 0 && value < length;
846}
847
848module.exports = isIndex;
849
850},{}],24:[function(_dereq_,module,exports){
851var isArrayLike = _dereq_('./isArrayLike'),
852    isIndex = _dereq_('./isIndex'),
853    isObject = _dereq_('../lang/isObject');
854
855/**
856 * Checks if the provided arguments are from an iteratee call.
857 *
858 * @private
859 * @param {*} value The potential iteratee value argument.
860 * @param {*} index The potential iteratee index or key argument.
861 * @param {*} object The potential iteratee object argument.
862 * @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.
863 */
864function isIterateeCall(value, index, object) {
865  if (!isObject(object)) {
866    return false;

867  }
868  var type = typeof index;
869  if (type == 'number'
870      ? (isArrayLike(object) && isIndex(index, object.length))
871      : (type == 'string' && index in object)) {
872    var other = object[index];
873    return value === value ? (value === other) : (other !== other);
874  }
875  return false;
876}
877
878module.exports = isIterateeCall;
879
880},{"../lang/isObject":33,"./isArrayLike":21,"./isIndex":23}],25:[function(_dereq_,module,exports){
881/**
882 * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
883 * of an array-like value.
884 */
885var MAX_SAFE_INTEGER = 9007199254740991;
886
887/**
888 * Checks if `value` is a valid array-like length.
889 *
890 * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
891 *
892 * @private
893 * @param {*} value The value to check.
894 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
895 */
896function isLength(value) {
897  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
898}
899
900module.exports = isLength;
901
902},{}],26:[function(_dereq_,module,exports){
903/**
904 * Checks if `value` is object-like.
905 *
906 * @private
907 * @param {*} value The value to check.
908 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
909 */
910function isObjectLike(value) {
911  return !!value && typeof value == 'object';
912}
913
914module.exports = isObjectLike;
915
916},{}],27:[function(_dereq_,module,exports){
917var isArguments = _dereq_('../lang/isArguments'),
918    isArray = _dereq_('../lang/isArray'),
919    isIndex = _dereq_('./isIndex'),
920    isLength = _dereq_('./isLength'),
921    isString = _dereq_('../lang/isString'),
922    keysIn = _dereq_('../object/keysIn');
923
924/** Used for native method references. */
925var objectProto = Object.prototype;
926
927/** Used to check objects for own properties. */
928var hasOwnProperty = objectProto.hasOwnProperty;
929
930/**
931 * A fallback implementation of `Object.keys` which creates an array of the
932 * own enumerable property names of `object`.
933 *
934 * @private
935 * @param {Object} object The object to query.
936 * @returns {Array} Returns the array of property names.
937 */
938function shimKeys(object) {
939  var props = keysIn(object),
940      propsLength = props.length,
941      length = propsLength && object.length;
942
943  var allowIndexes = !!length && isLength(length) &&
944    (isArray(object) || isArguments(object) || isString(object));
945
946  var index = -1,
947      result = [];
948
949  while (++index < propsLength) {
950    var key = props[index];
951    if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {
952      result.push(key);
953    }
954  }
955  return result;
956}
957
958module.exports = shimKeys;
959
960},{"../lang/isArguments":29,"../lang/isArray":30,"../lang/isString":35,"../object/keysIn":39,"./isIndex":23,"./isLength":25}],28:[function(_dereq_,module,exports){
961var isObject = _dereq_('../lang/isObject'),
962    isString = _dereq_('../lang/isString'),
963    support = _dereq_('../support');
964
965/**
966 * Converts `value` to an object if it's not one.
967 *
968 * @private
969 * @param {*} value The value to process.
970 * @returns {Object} Returns the object.
971 */
972function toObject(value) {
973  if (support.unindexedChars && isString(value)) {
974    var index = -1,
975        length = value.length,
976        result = Object(value);
977
978    while (++index < length) {
979      result[index] = value.charAt(index);
980    }
981    return result;
982  }
983  return isObject(value) ? value : Object(value);
984}
985
986module.exports = toObject;
987
988},{"../lang/isObject":33,"../lang/isString":35,"../support":41}],29:[function(_dereq_,module,exports){
989var isArrayLike = _dereq_('../internal/isArrayLike'),
990    isObjectLike = _dereq_('../internal/isObjectLike');
991
992/** Used for native method references. */
993var objectProto = Object.prototype;
994
995/** Used to check objects for own properties. */
996var hasOwnProperty = objectProto.hasOwnProperty;
997
998/** Native method references. */
999var propertyIsEnumerable = objectProto.propertyIsEnumerable;
1000
1001/**
1002 * Checks if `value` is classified as an `arguments` object.
1003 *
1004 * @static
1005 * @memberOf _
1006 * @category Lang
1007 * @param {*} value The value to check.
1008 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
1009 * @example
1010 *
1011 * _.isArguments(function() { return arguments; }());
1012 * // => true
1013 *
1014 * _.isArguments([1, 2, 3]);
1015 * // => false
1016 */
1017function isArguments(value) {
1018  return isObjectLike(value) && isArrayLike(value) &&
1019    hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
1020}
1021
1022module.exports = isArguments;
1023
1024},{"../internal/isArrayLike":21,"../internal/isObjectLike":26}],30:[function(_dereq_,module,exports){
1025var getNative = _dereq_('../internal/getNative'),
1026    isLength = _dereq_('../internal/isLength'),
1027    isObjectLike = _dereq_('../internal/isObjectLike');
1028
1029/** `Object#toString` result references. */
1030var arrayTag = '[object Array]';
1031
1032/** Used for native method references. */
1033var objectProto = Object.prototype;
1034
1035/**
1036 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
1037 * of values.
1038 */
1039var objToString = objectProto.toString;
1040
1041/* Native method references for those with the same name as other `lodash` methods. */
1042var nativeIsArray = getNative(Array, 'isArray');
1043
1044/**
1045 * Checks if `value` is classified as an `Array` object.
1046 *
1047 * @static
1048 * @memberOf _
1049 * @category Lang
1050 * @param {*} value The value to check.
1051 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
1052 * @example
1053 *
1054 * _.isArray([1, 2, 3]);
1055 * // => true
1056 *
1057 * _.isArray(function() { return arguments; }());
1058 * // => false
1059 */
1060var isArray = nativeIsArray || function(value) {
1061  return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;
1062};
1063
1064module.exports = isArray;
1065
1066},{"../internal/getNative":20,"../internal/isLength":25,"../internal/isObjectLike":26}],31:[function(_dereq_,module,exports){
1067var isObject = _dereq_('./isObject');
1068
1069/** `Object#toString` result references. */
1070var funcTag = '[object Function]';
1071
1072/** Used for native method references. */
1073var objectProto = Object.prototype;
1074
1075/**
1076 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
1077 * of values.
1078 */
1079var objToString = objectProto.toString;
1080
1081/**
1082 * Checks if `value` is classified as a `Function` object.
1083 *
1084 * @static
1085 * @memberOf _
1086 * @category Lang
1087 * @param {*} value The value to check.
1088 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
1089 * @example
1090 *
1091 * _.isFunction(_);
1092 * // => true
1093 *
1094 * _.isFunction(/abc/);
1095 * // => false
1096 */
1097function isFunction(value) {

1098  // The use of `Object#toString` avoids issues with the `typeof` operator
1099  // in older versions of Chrome and Safari which return 'function' for regexes
1100  // and Safari 8 which returns 'object' for typed array constructors.
1101  return isObject(value) && objToString.call(value) == funcTag;
1102}
1103
1104module.exports = isFunction;
1105
1106},{"./isObject":33}],32:[function(_dereq_,module,exports){
1107var isFunction = _dereq_('./isFunction'),
1108    isHostObject = _dereq_('../internal/isHostObject'),
1109    isObjectLike = _dereq_('../internal/isObjectLike');
1110
1111/** Used to detect host constructors (Safari > 5). */
1112var reIsHostCtor = /^\[object .+?Constructor\]$/;
1113
1114/** Used for native method references. */
1115var objectProto = Object.prototype;
1116
1117/** Used to resolve the decompiled source of functions. */
1118var fnToString = Function.prototype.toString;
1119
1120/** Used to check objects for own properties. */
1121var hasOwnProperty = objectProto.hasOwnProperty;
1122
1123/** Used to detect if a method is native. */
1124var reIsNative = RegExp('^' +
1125  fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
1126  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
1127);
1128
1129/**
1130 * Checks if `value` is a native function.
1131 *
1132 * @static
1133 * @memberOf _
1134 * @category Lang
1135 * @param {*} value The value to check.
1136 * @returns {boolean} Returns `true` if `value` is a native function, else `false`.
1137 * @example
1138 *
1139 * _.isNative(Array.prototype.push);
1140 * // => true
1141 *
1142 * _.isNative(_);
1143 * // => false
1144 */
1145function isNative(value) {
1146  if (value == null) {
1147    return false;
1148  }
1149  if (isFunction(value)) {
1150    return reIsNative.test(fnToString.call(value));
1151  }
1152  return isObjectLike(value) && (isHostObject(value) ? reIsNative : reIsHostCtor).test(value);
1153}
1154
1155module.exports = isNative;
1156
1157},{"../internal/isHostObject":22,"../internal/isObjectLike":26,"./isFunction":31}],33:[function(_dereq_,module,exports){
1158/**
1159 * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
1160 * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
1161 *
1162 * @static
1163 * @memberOf _
1164 * @category Lang
1165 * @param {*} value The value to check.
1166 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
1167 * @example
1168 *
1169 * _.isObject({});
1170 * // => true
1171 *
1172 * _.isObject([1, 2, 3]);
1173 * // => true
1174 *
1175 * _.isObject(1);
1176 * // => false
1177 */
1178function isObject(value) {
1179  // Avoid a V8 JIT bug in Chrome 19-20.
1180  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
1181  var type = typeof value;
1182  return !!value && (type == 'object' || type == 'function');
1183}
1184
1185module.exports = isObject;
1186
1187},{}],34:[function(_dereq_,module,exports){
1188var baseForIn = _dereq_('../internal/baseForIn'),
1189    isArguments = _dereq_('./isArguments'),
1190    isHostObject = _dereq_('../internal/isHostObject'),
1191    isObjectLike = _dereq_('../internal/isObjectLike'),
1192    support = _dereq_('../support');
1193
1194/** `Object#toString` result references. */
1195var objectTag = '[object Object]';
1196
1197/** Used for native method references. */
1198var objectProto = Object.prototype;
1199
1200/** Used to check objects for own properties. */
1201var hasOwnProperty = objectProto.hasOwnProperty;
1202
1203/**
1204 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
1205 * of values.
1206 */
1207var objToString = objectProto.toString;
1208
1209/**
1210 * Checks if `value` is a plain object, that is, an object created by the
1211 * `Object` constructor or one with a `[[Prototype]]` of `null`.
1212 *
1213 * **Note:** This method assumes objects created by the `Object` constructor
1214 * have no inherited enumerable properties.
1215 *
1216 * @static
1217 * @memberOf _
1218 * @category Lang
1219 * @param {*} value The value to check.
1220 * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
1221 * @example
1222 *
1223 * function Foo() {
1224 *   this.a = 1;
1225 * }
1226 *
1227 * _.isPlainObject(new Foo);
1228 * // => false
1229 *
1230 * _.isPlainObject([1, 2, 3]);
1231 * // => false
1232 *
1233 * _.isPlainObject({ 'x': 0, 'y': 0 });
1234 * // => true
1235 *
1236 * _.isPlainObject(Object.create(null));
1237 * // => true
1238 */
1239function isPlainObject(value) {
1240  var Ctor;
1241
1242  // Exit early for non `Object` objects.
1243  if (!(isObjectLike(value) && objToString.call(value) == objectTag && !isHostObject(value) && !isArguments(value)) ||
1244      (!hasOwnProperty.call(value, 'constructor') && (Ctor = value.constructor, typeof Ctor == 'function' && !(Ctor instanceof Ctor)))) {
1245    return false;
1246  }
1247  // IE < 9 iterates inherited properties before own properties. If the first
1248  // iterated property is an object's own property then there are no inherited
1249  // enumerable properties.
1250  var result;
1251  if (support.ownLast) {
1252    baseForIn(value, function(subValue, key, object) {
1253      result = hasOwnProperty.call(object, key);
1254      return false;
1255    });
1256    return result !== false;
1257  }
1258  // In most environments an object's own properties are iterated before
1259  // its inherited properties. If the last iterated property is an object's
1260  // own property then there are no inherited enumerable properties.
1261  baseForIn(value, function(subValue, key) {
1262    result = key;
1263  });
1264  return result === undefined || hasOwnProperty.call(value, result);
1265}
1266
1267module.exports = isPlainObject;
1268
1269},{"../internal/baseForIn":12,"../internal/isHostObject":22,"../internal/isObjectLike":26,"../support":41,"./isArguments":29}],35:[function(_dereq_,module,exports){
1270var isObjectLike = _dereq_('../internal/isObjectLike');
1271
1272/** `Object#toString` result references. */
1273var stringTag = '[object String]';
1274
1275/** Used for native method references. */
1276var objectProto = Object.prototype;
1277
1278/**
1279 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
1280 * of values.
1281 */
1282var objToString = objectProto.toString;
1283
1284/**
1285 * Checks if `value` is classified as a `String` primitive or object.
1286 *
1287 * @static
1288 * @memberOf _
1289 * @category Lang
1290 * @param {*} value The value to check.
1291 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
1292 * @example
1293 *
1294 * _.isString('abc');
1295 * // => true
1296 *
1297 * _.isString(1);
1298 * // => false
1299 */
1300function isString(value) {
1301  return typeof value == 'string' || (isObjectLike(value) && objToString.call(value) == stringTag);
1302}
1303
1304module.exports = isString;
1305
1306},{"../internal/isObjectLike":26}],36:[function(_dereq_,module,exports){
1307var isLength = _dereq_('../internal/isLength'),
1308    isObjectLike = _dereq_('../internal/isObjectLike');
1309
1310/** `Object#toString` result references. */
1311var argsTag = '[object Arguments]',
1312    arrayTag = '[object Array]',
1313    boolTag = '[object Boolean]',
1314    dateTag = '[object Date]',
1315    errorTag = '[object Error]',
1316    funcTag = '[object Function]',
1317    mapTag = '[object Map]',
1318    numberTag = '[object Number]',
1319    objectTag = '[object Object]',
1320    regexpTag = '[object RegExp]',
1321    setTag = '[object Set]',
1322    stringTag = '[object String]',
1323    weakMapTag = '[object WeakMap]';
1324
1325var arrayBufferTag = '[object ArrayBuffer]',
1326    float32Tag = '[object Float32Array]',
1327    float64Tag = '[object Float64Array]',
1328    int8Tag = '[object Int8Array]',
1329    int16Tag = '[object Int16Array]',
1330    int32Tag = '[object Int32Array]',
1331    uint8Tag = '[object Uint8Array]',
1332    uint8ClampedTag = '[object Uint8ClampedArray]',
1333    uint16Tag = '[object Uint16Array]',
1334    uint32Tag = '[object Uint32Array]';
1335
1336/** Used to identify `toStringTag` values of typed arrays. */
1337var typedArrayTags = {};
1338typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
1339typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
1340typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
1341typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
1342typedArrayTags[uint32Tag] = true;
1343typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
1344typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
1345typedArrayTags[dateTag] = typedArrayTags[errorTag] =
1346typedArrayTags[funcTag] = typedArrayTags[mapTag] =
1347typedArrayTags[numberTag] = typedArrayTags[objectTag] =
1348typedArrayTags[regexpTag] = typedArrayTags[setTag] =
1349typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
1350
1351/** Used for native method references. */
1352var objectProto = Object.prototype;
1353
1354/**
1355 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
1356 * of values.
1357 */
1358var objToString = objectProto.toString;
1359
1360/**
1361 * Checks if `value` is classified as a typed array.

1362 *
1363 * @static
1364 * @memberOf _
1365 * @category Lang
1366 * @param {*} value The value to check.
1367 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
1368 * @example
1369 *
1370 * _.isTypedArray(new Uint8Array);
1371 * // => true
1372 *
1373 * _.isTypedArray([]);
1374 * // => false
1375 */
1376function isTypedArray(value) {
1377  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];
1378}
1379
1380module.exports = isTypedArray;
1381
1382},{"../internal/isLength":25,"../internal/isObjectLike":26}],37:[function(_dereq_,module,exports){
1383var baseCopy = _dereq_('../internal/baseCopy'),
1384    keysIn = _dereq_('../object/keysIn');
1385
1386/**
1387 * Converts `value` to a plain object flattening inherited enumerable
1388 * properties of `value` to own properties of the plain object.
1389 *
1390 * @static
1391 * @memberOf _
1392 * @category Lang
1393 * @param {*} value The value to convert.
1394 * @returns {Object} Returns the converted plain object.
1395 * @example
1396 *
1397 * function Foo() {
1398 *   this.b = 2;
1399 * }
1400 *
1401 * Foo.prototype.c = 3;
1402 *
1403 * _.assign({ 'a': 1 }, new Foo);
1404 * // => { 'a': 1, 'b': 2 }
1405 *
1406 * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
1407 * // => { 'a': 1, 'b': 2, 'c': 3 }
1408 */
1409function toPlainObject(value) {
1410  return baseCopy(value, keysIn(value));
1411}
1412
1413module.exports = toPlainObject;
1414
1415},{"../internal/baseCopy":10,"../object/keysIn":39}],38:[function(_dereq_,module,exports){
1416var getNative = _dereq_('../internal/getNative'),
1417    isArrayLike = _dereq_('../internal/isArrayLike'),
1418    isObject = _dereq_('../lang/isObject'),
1419    shimKeys = _dereq_('../internal/shimKeys'),
1420    support = _dereq_('../support');
1421
1422/* Native method references for those with the same name as other `lodash` methods. */
1423var nativeKeys = getNative(Object, 'keys');
1424
1425/**
1426 * Creates an array of the own enumerable property names of `object`.
1427 *
1428 * **Note:** Non-object values are coerced to objects. See the
1429 * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)
1430 * for more details.
1431 *
1432 * @static
1433 * @memberOf _
1434 * @category Object
1435 * @param {Object} object The object to query.
1436 * @returns {Array} Returns the array of property names.
1437 * @example
1438 *
1439 * function Foo() {
1440 *   this.a = 1;
1441 *   this.b = 2;
1442 * }
1443 *
1444 * Foo.prototype.c = 3;
1445 *
1446 * _.keys(new Foo);
1447 * // => ['a', 'b'] (iteration order is not guaranteed)
1448 *
1449 * _.keys('hi');
1450 * // => ['0', '1']
1451 */
1452var keys = !nativeKeys ? shimKeys : function(object) {
1453  var Ctor = object == null ? undefined : object.constructor;
1454  if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
1455      (typeof object == 'function' ? support.enumPrototypes : isArrayLike(object))) {
1456    return shimKeys(object);
1457  }
1458  return isObject(object) ? nativeKeys(object) : [];
1459};
1460
1461module.exports = keys;
1462
1463},{"../internal/getNative":20,"../internal/isArrayLike":21,"../internal/shimKeys":27,"../lang/isObject":33,"../support":41}],39:[function(_dereq_,module,exports){
1464var arrayEach = _dereq_('../internal/arrayEach'),
1465    isArguments = _dereq_('../lang/isArguments'),
1466    isArray = _dereq_('../lang/isArray'),
1467    isFunction = _dereq_('../lang/isFunction'),
1468    isIndex = _dereq_('../internal/isIndex'),
1469    isLength = _dereq_('../internal/isLength'),
1470    isObject = _dereq_('../lang/isObject'),
1471    isString = _dereq_('../lang/isString'),
1472    support = _dereq_('../support');
1473
1474/** `Object#toString` result references. */
1475var arrayTag = '[object Array]',
1476    boolTag = '[object Boolean]',
1477    dateTag = '[object Date]',
1478    errorTag = '[object Error]',
1479    funcTag = '[object Function]',
1480    numberTag = '[object Number]',
1481    objectTag = '[object Object]',
1482    regexpTag = '[object RegExp]',
1483    stringTag = '[object String]';
1484
1485/** Used to fix the JScript `[[DontEnum]]` bug. */
1486var shadowProps = [
1487  'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
1488  'toLocaleString', 'toString', 'valueOf'
1489];
1490
1491/** Used for native method references. */
1492var errorProto = Error.prototype,
1493    objectProto = Object.prototype,
1494    stringProto = String.prototype;
1495
1496/** Used to check objects for own properties. */
1497var hasOwnProperty = objectProto.hasOwnProperty;
1498
1499/**
1500 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
1501 * of values.
1502 */
1503var objToString = objectProto.toString;
1504
1505/** Used to avoid iterating over non-enumerable properties in IE < 9. */
1506var nonEnumProps = {};
1507nonEnumProps[arrayTag] = nonEnumProps[dateTag] = nonEnumProps[numberTag] = { 'constructor': true, 'toLocaleStr

1507ing': true, 'toString': true, 'valueOf': true };
1508nonEnumProps[boolTag] = nonEnumProps[stringTag] = { 'constructor': true, 'toString': true, 'valueOf': true };
1509nonEnumProps[errorTag] = nonEnumProps[funcTag] = nonEnumProps[regexpTag] = { 'constructor': true, 'toString': true };
1510nonEnumProps[objectTag] = { 'constructor': true };
1511
1512arrayEach(shadowProps, function(key) {
1513  for (var tag in nonEnumProps) {
1514    if (hasOwnProperty.call(nonEnumProps, tag)) {
1515      var props = nonEnumProps[tag];
1516      props[key] = hasOwnProperty.call(props, key);
1517    }
1518  }
1519});
1520
1521/**
1522 * Creates an array of the own and inherited enumerable property names of `object`.
1523 *
1524 * **Note:** Non-object values are coerced to objects.
1525 *
1526 * @static
1527 * @memberOf _
1528 * @category Object
1529 * @param {Object} object The object to query.
1530 * @returns {Array} Returns the array of property names.
1531 * @example
1532 *
1533 * function Foo() {
1534 *   this.a = 1;
1535 *   this.b = 2;
1536 * }
1537 *
1538 * Foo.prototype.c = 3;
1539 *
1540 * _.keysIn(new Foo);
1541 * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
1542 */
1543function keysIn(object) {
1544  if (object == null) {
1545    return [];
1546  }
1547  if (!isObject(object)) {
1548    object = Object(object);
1549  }
1550  var length = object.length;
1551
1552  length = (length && isLength(length) &&
1553    (isArray(object) || isArguments(object) || isString(object)) && length) || 0;
1554
1555  var Ctor = object.constructor,
1556      index = -1,
1557      proto = (isFunction(Ctor) && Ctor.prototype) || objectProto,
1558      isProto = proto === object,
1559      result = Array(length),
1560      skipIndexes = length > 0,
1561      skipErrorProps = support.enumErrorProps && (object === errorProto || object instanceof Error),
1562      skipProto = support.enumPrototypes && isFunction(object);
1563
1564  while (++index < length) {
1565    result[index] = (index + '');
1566  }
1567  // lodash skips the `constructor` property when it infers it's iterating
1568  // over a `prototype` object because IE < 9 can't set the `[[Enumerable]]`
1569  // attribute of an existing property and the `constructor` property of a
1570  // prototype defaults to non-enumerable.
1571  for (var key in object) {
1572    if (!(skipProto && key == 'prototype') &&
1573        !(skipErrorProps && (key == 'message' || key == 'name')) &&
1574        !(skipIndexes && isIndex(key, length)) &&
1575        !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
1576      result.push(key);
1577    }
1578  }
1579  if (support.nonEnumShadows && object !== objectProto) {
1580    var tag = object === stringProto ? stringTag : (object === errorProto ? errorTag : objToString.call(object)),
1581        nonEnums = nonEnumProps[tag] || nonEnumProps[objectTag];
1582
1583    if (tag == objectTag) {
1584      proto = objectProto;
1585    }
1586    length = shadowProps.length;
1587    while (length--) {
1588      key = shadowProps[length];
1589      var nonEnum = nonEnums[key];
1590      if (!(isProto && nonEnum) &&
1591          (nonEnum ? hasOwnProperty.call(object, key) : object[key] !== proto[key])) {
1592        result.push(key);
1593      }
1594    }
1595  }
1596  return result;
1597}
1598
1599module.exports = keysIn;
1600
1601},{"../internal/arrayEach":9,"../internal/isIndex":23,"../internal/isLength":25,"../lang/isArguments":29,"../lang/isArray":30,"../lang/isFunction":31,"../lang/isObject":33,"../lang/isString":35,"../support":41}],40:[function(_dereq_,module,exports){
1602var baseMerge = _dereq_('../internal/baseMerge'),
1603    createAssigner = _dereq_('../internal/createAssigner');
1604
1605/**
1606 * Recursively merges own enumerable properties of the source object(s), that
1607 * don't resolve to `undefined` into the destination object. Subsequent sources
1608 * overwrite property assignments of previous sources. If `customizer` is
1609 * provided it's invoked to produce the merged values of the destination and
1610 * source properties. If `customizer` returns `undefined` merging is handled
1611 * by the method instead. The `customizer` is bound to `thisArg` and invoked
1612 * with five arguments: (objectValue, sourceValue, key, object, source).
1613 *
1614 * @static
1615 * @memberOf _
1616 * @category Object
1617 * @param {Object} object The destination object.
1618 * @param {...Object} [sources] The source objects.
1619 * @param {Function} [customizer] The function to customize assigned values.
1620 * @param {*} [thisArg] The `this` binding of `customizer`.
1621 * @returns {Object} Returns `object`.
1622 * @example
1623 *
1624 * var users = {
1625 *   'data': [{ 'user': 'barney' }, { 'user': 'fred' }]
1626 * };
1627 *
1628 * var ages = {
1629 *   'data': [{ 'age': 36 }, { 'age': 40 }]
1630 * };
1631 *
1632 * _.merge(users, ages);
1633 * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }
1634 *
1635 * // using a customizer callback
1636 * var object = {
1637 *   'fruits': ['apple'],
1638 *   'vegetables': ['beet']
1639 * };
1640 *
1641 * var other = {
1642 *   'fruits': ['banana'],
1643 *   'vegetables': ['carrot']
1644 * };
1645 *
1646 * _.merge(object, other, function(a, b) {
1647 *   if (_.isArray(a)) {
1648 *     return a.concat(b);
1649 *   }
1650 * });
1651 * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] }
1652 */
1653var merge = createAssigner(baseMerge);
1654
1655module.exports = merge;
1656
1657},{"../internal/baseMerge":13,"../internal/createAssigner":17}],41:[function(_dereq_,module,exports){
1658/** Used for native method references. */
1659var arrayProto = Array.prototype,
1660    errorProto = Error.prototype,
1661    objectProto = Object.prototype;
1662

1663/** Native method references. */
1664var propertyIsEnumerable = objectProto.propertyIsEnumerable,
1665    splice = arrayProto.splice;
1666
1667/**
1668 * An object environment feature flags.
1669 *
1670 * @static
1671 * @memberOf _
1672 * @type Object
1673 */
1674var support = {};
1675
1676(function(x) {
1677  var Ctor = function() { this.x = x; },
1678      object = { '0': x, 'length': x },
1679      props = [];
1680
1681  Ctor.prototype = { 'valueOf': x, 'y': x };
1682  for (var key in new Ctor) { props.push(key); }
1683
1684  /**
1685   * Detect if `name` or `message` properties of `Error.prototype` are
1686   * enumerable by default (IE < 9, Safari < 5.1).
1687   *
1688   * @memberOf _.support
1689   * @type boolean
1690   */
1691  support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') ||
1692    propertyIsEnumerable.call(errorProto, 'name');
1693
1694  /**
1695   * Detect if `prototype` properties are enumerable by default.
1696   *
1697   * Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1
1698   * (if the prototype or a property on the prototype has been set)
1699   * incorrectly set the `[[Enumerable]]` value of a function's `prototype`
1700   * property to `true`.
1701   *
1702   * @memberOf _.support
1703   * @type boolean
1704   */
1705  support.enumPrototypes = propertyIsEnumerable.call(Ctor, 'prototype');
1706
1707  /**
1708   * Detect if properties shadowing those on `Object.prototype` are non-enumerable.
1709   *
1710   * In IE < 9 an object's own properties, shadowing non-enumerable ones,
1711   * are made non-enumerable as well (a.k.a the JScript `[[DontEnum]]` bug).
1712   *
1713   * @memberOf _.support
1714   * @type boolean
1715   */
1716  support.nonEnumShadows = !/valueOf/.test(props);
1717
1718  /**
1719   * Detect if own properties are iterated after inherited properties (IE < 9).
1720   *
1721   * @memberOf _.support
1722   * @type boolean
1723   */
1724  support.ownLast = props[0] != 'x';
1725
1726  /**
1727   * Detect if `Array#shift` and `Array#splice` augment array-like objects
1728   * correctly.
1729   *
1730   * Firefox < 10, compatibility modes of IE 8, and IE < 9 have buggy Array
1731   * `shift()` and `splice()` functions that fail to remove the last element,
1732   * `value[0]`, of array-like objects even though the "length" property is
1733   * set to `0`. The `shift()` method is buggy in compatibility modes of IE 8,
1734   * while `splice()` is buggy regardless of mode in IE < 9.
1735   *
1736   * @memberOf _.support
1737   * @type boolean
1738   */
1739  support.spliceObjects = (splice.call(object, 0, 1), !object[0]);
1740
1741  /**
1742   * Detect lack of support for accessing string characters by index.
1743   *
1744   * IE < 8 can't access characters by index. IE 8 can only access characters
1745   * by index on string literals, not string objects.
1746   *
1747   * @memberOf _.support
1748   * @type boolean
1749   */
1750  support.unindexedChars = ('x'[0] + Object('x')[0]) != 'xx';
1751}(1, 0));
1752
1753module.exports = support;
1754
1755},{}],42:[function(_dereq_,module,exports){
1756/**
1757 * This method returns the first argument provided to it.
1758 *
1759 * @static
1760 * @memberOf _
1761 * @category Utility
1762 * @param {*} value Any value.
1763 * @returns {*} Returns `value`.
1764 * @example
1765 *
1766 * var object = { 'user': 'fred' };
1767 *
1768 * _.identity(object) === object;
1769 * // => true
1770 */
1771function identity(value) {
1772  return value;
1773}
1774
1775module.exports = identity;
1776
1777},{}],43:[function(_dereq_,module,exports){
1778'use strict';
1779
1780var keys = _dereq_('object-keys');
1781
1782module.exports = function hasSymbols() {
1783	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
1784	if (typeof Symbol.iterator === 'symbol') { return true; }
1785
1786	var obj = {};
1787	var sym = Symbol('test');
1788	if (typeof sym === 'string') { return false; }
1789
1790	// temp disabled per https://github.com/ljharb/object.assign/issues/17
1791	// if (sym instanceof Symbol) { return false; }
1792	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
1793	// if (!(Object(sym) instanceof Symbol)) { return false; }
1794
1795	var symVal = 42;
1796	obj[sym] = symVal;
1797	for (sym in obj) { return false; }
1798	if (keys(obj).length !== 0) { return false; }
1799	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
1800
1801	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
1802
1803	var syms = Object.getOwnPropertySymbols(obj);
1804	if (syms.length !== 1 || syms[0] !== sym) { return false; }
1805
1806	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
1807
1808	if (typeof Object.getOwnPropertyDescriptor === 'function') {
1809		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
1810		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
1811	}
1812
1813	return true;
1814};
1815
1816},{"object-keys":50}],44:[function(_dereq_,module,exports){
1817'use strict';
1818
1819// modified from https://github.com/es-shims/es6-shim
1820var keys = _dereq_('object-keys');
1821var bind = _dereq_('function-bind');
1822var canBeObject = function (obj) {
1823	return typeof obj !== 'undefined' && obj !== null;
1824};
1825var hasSymbols = _dereq_('./hasSymbols')();
1826var toObject = Object;
1827var push = bind.call(Function.call, Array.prototype.push);
1828var propIsEnumerable = bind.call(Function.call, Object.prototype.propertyIsEnumerable);
1829
1830module.exports = function assign(target, source1) {
1831	if (!canBeObject(target)) { throw new TypeError('target must be an object'); }
1832	var objTarget = toObject(target);
1833	var s, source, i, props, syms, value, key;
1834	for (s = 1; s < arguments.length; ++s) {
1835		source = toObject(arguments[s]);
1836		props = keys(source);
1837		if (hasSymbols && Object.getOwnPropertySymbols) {
1838			syms = Object.getOwnPropertySymbols(source);
1839			for (i = 0; i < syms.length; ++i) {
1840				key = syms[i];
1841				if (propIsEnumerable(source, key)) {
1842					push(props, key);
1843				}
1844			}
1845		}
1846		for (i = 0; i < props.length; ++i) {
1847			key = props[i];
1848			value = source[key];
1849			if (propIsEnumerable(source, key)) {
1850				objTarget[key] = value;
1851			}
1852		}
1853	}
1854	return objTarget;
1855};
1856
1857},{"./hasSymbols":43,"function-bind":49,"object-keys":50}],45:[function(_dereq_,module,exports){
1858'use strict';
1859
1860var defineProperties = _dereq_('define-properties');
1861
1862var implementation = _dereq_('./implementation');
1863var getPolyfill = _dereq_('./polyfill');
1864var shim = _dereq_('./shim');
1865
1866defineProperties(implementation, {
1867	implementation: implementation,
1868	getPolyfill: getPolyfill,
1869	shim: shim
1870});
1871
1872module.exports = implementation;
1873
1874},{"./implementation":44,"./polyfill":52,"./shim":53,"define-properties":46}],46:[function(_dereq_,module,exports){
1875'use strict';
1876
1877var keys = _dereq_('object-keys');
1878var foreach = _dereq_('foreach');
1879var hasSymbols = typeof Symbol === 'function' && typeof Symbol() === 'symbol';
1880
1881var toStr = Object.prototype.toString;
1882
1883var isFunction = function (fn) {
1884	return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
1885};
1886
1887var arePropertyDescriptorsSupported = function () {
1888	var obj = {};
1889	try {
1890		Object.defineProperty(obj, 'x', { enumerable: false, value: obj });
1891        /* eslint-disable no-unused-vars, no-restricted-syntax */
1892        for (var _ in obj) { return false; }
1893        /* eslint-enable no-unused-vars, no-restricted-syntax */
1894		return obj.x === obj;
1895	} catch (e) { /* this is IE 8. */
1896		return false;

1897	}
1898};
1899var supportsDescriptors = Object.defineProperty && arePropertyDescriptorsSupported();
1900
1901var defineProperty = function (object, name, value, predicate) {
1902	if (name in object && (!isFunction(predicate) || !predicate())) {
1903		return;
1904	}
1905	if (supportsDescriptors) {
1906		Object.defineProperty(object, name, {
1907			configurable: true,
1908			enumerable: false,
1909			value: value,
1910			writable: true
1911		});
1912	} else {
1913		object[name] = value;
1914	}
1915};
1916
1917var defineProperties = function (object, map) {
1918	var predicates = arguments.length > 2 ? arguments[2] : {};
1919	var props = keys(map);
1920	if (hasSymbols) {
1921		props = props.concat(Object.getOwnPropertySymbols(map));
1922	}
1923	foreach(props, function (name) {
1924		defineProperty(object, name, map[name], predicates[name]);
1925	});
1926};
1927
1928defineProperties.supportsDescriptors = !!supportsDescriptors;
1929
1930module.exports = defineProperties;
1931
1932},{"foreach":47,"object-keys":50}],47:[function(_dereq_,module,exports){
1933
1934var hasOwn = Object.prototype.hasOwnProperty;
1935var toString = Object.prototype.toString;
1936
1937module.exports = function forEach (obj, fn, ctx) {
1938    if (toString.call(fn) !== '[object Function]') {
1939        throw new TypeError('iterator must be a function');
1940    }
1941    var l = obj.length;
1942    if (l === +l) {
1943        for (var i = 0; i < l; i++) {
1944            fn.call(ctx, obj[i], i, obj);
1945        }
1946    } else {
1947        for (var k in obj) {
1948            if (hasOwn.call(obj, k)) {
1949                fn.call(ctx, obj[k], k, obj);
1950            }
1951        }
1952    }
1953};
1954
1955
1956},{}],48:[function(_dereq_,module,exports){
1957var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
1958var slice = Array.prototype.slice;
1959var toStr = Object.prototype.toString;
1960var funcType = '[object Function]';
1961
1962module.exports = function bind(that) {
1963    var target = this;
1964    if (typeof target !== 'function' || toStr.call(target) !== funcType) {
1965        throw new TypeError(ERROR_MESSAGE + target);
1966    }
1967    var args = slice.call(arguments, 1);
1968
1969    var bound;
1970    var binder = function () {
1971        if (this instanceof bound) {
1972            var result = target.apply(
1973                this,
1974                args.concat(slice.call(arguments))
1975            );
1976            if (Object(result) === result) {
1977                return result;
1978            }
1979            return this;
1980        } else {
1981            return target.apply(
1982                that,
1983                args.concat(slice.call(arguments))
1984            );
1985        }
1986    };
1987
1988    var boundLength = Math.max(0, target.length - args.length);
1989    var boundArgs = [];
1990    for (var i = 0; i < boundLength; i++) {
1991        boundArgs.push('$' + i);
1992    }
1993
1994    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
1995
1996    if (target.prototype) {
1997        var Empty = function Empty() {};
1998        Empty.prototype = target.prototype;
1999        bound.prototype = new Empty();
2000        Empty.prototype = null;
2001    }
2002
2003    return bound;
2004};
2005
2006},{}],49:[function(_dereq_,module,exports){
2007var implementation = _dereq_('./implementation');
2008
2009module.exports = Function.prototype.bind || implementation;
2010
2011},{"./implementation":48}],50:[function(_dereq_,module,exports){
2012'use strict';
2013
2014// modified from https://github.com/es-shims/es5-shim
2015var has = Object.prototype.hasOwnProperty;
2016var toStr = Object.prototype.toString;
2017var slice = Array.prototype.slice;
2018var isArgs = _dereq_('./isArguments');
2019var hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString');
2020var hasProtoEnumBug = function () {}.propertyIsEnumerable('prototype');
2021var dontEnums = [
2022	'toString',
2023	'toLocaleString',
2024	'valueOf',
2025	'hasOwnProperty',
2026	'isPrototypeOf',
2027	'propertyIsEnumerable',
2028	'constructor'
2029];
2030var equalsConstructorPrototype = function (o) {
2031	var ctor = o.constructor;
2032	return ctor && ctor.prototype === o;
2033};
2034var blacklistedKeys = {
2035	$console: true,
2036	$frame: true,
2037	$frameElement: true,
2038	$frames: true,
2039	$parent: true,
2040	$self: true,
2041	$webkitIndexedDB: true,
2042	$webkitStorageInfo: true,
2043	$window: true
2044};
2045var hasAutomationEqualityBug = (function () {
2046	/* global window */
2047	if (typeof window === 'undefined') { return false; }
2048	for (var k in window) {
2049		try {
2050			if (!blacklistedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
2051				try {
2052					equalsConstructorPrototype(window[k]);
2053				} catch (e) {
2054					return true;
2055				}
2056			}
2057		} catch (e) {
2058			return true;
2059		}
2060	}
2061	return false;

2062}());
2063var equalsConstructorPrototypeIfNotBuggy = function (o) {
2064	/* global window */
2065	if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
2066		return equalsConstructorPrototype(o);
2067	}
2068	try {
2069		return equalsConstructorPrototype(o);
2070	} catch (e) {
2071		return false;
2072	}
2073};
2074
2075var keysShim = function keys(object) {
2076	var isObject = object !== null && typeof object === 'object';
2077	var isFunction = toStr.call(object) === '[object Function]';
2078	var isArguments = isArgs(object);
2079	var isString = isObject && toStr.call(object) === '[object String]';
2080	var theKeys = [];
2081
2082	if (!isObject && !isFunction && !isArguments) {
2083		throw new TypeError('Object.keys called on a non-object');
2084	}
2085
2086	var skipProto = hasProtoEnumBug && isFunction;
2087	if (isString && object.length > 0 && !has.call(object, 0)) {
2088		for (var i = 0; i < object.length; ++i) {
2089			theKeys.push(String(i));
2090		}
2091	}
2092
2093	if (isArguments && object.length > 0) {
2094		for (var j = 0; j < object.length; ++j) {
2095			theKeys.push(String(j));
2096		}
2097	} else {
2098		for (var name in object) {
2099			if (!(skipProto && name === 'prototype') && has.call(object, name)) {
2100				theKeys.push(String(name));
2101			}
2102		}
2103	}
2104
2105	if (hasDontEnumBug) {
2106		var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
2107
2108		for (var k = 0; k < dontEnums.length; ++k) {
2109			if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
2110				theKeys.push(dontEnums[k]);
2111			}
2112		}
2113	}
2114	return theKeys;
2115};
2116
2117keysShim.shim = function shimObjectKeys() {
2118	if (Object.keys) {
2119		var keysWorksWithArguments = (function () {
2120			// Safari 5.0 bug
2121			return (Object.keys(arguments) || '').length === 2;
2122		}(1, 2));
2123		if (!keysWorksWithArguments) {
2124			var originalKeys = Object.keys;
2125			Object.keys = function keys(object) {
2126				if (isArgs(object)) {
2127					return originalKeys(slice.call(object));
2128				} else {
2129					return originalKeys(object);
2130				}
2131			};
2132		}
2133	} else {
2134		Object.keys = keysShim;
2135	}
2136	return Object.keys || keysShim;
2137};
2138
2139module.exports = keysShim;
2140
2141},{"./isArguments":51}],51:[function(_dereq_,module,exports){
2142'use strict';
2143
2144var toStr = Object.prototype.toString;
2145
2146module.exports = function isArguments(value) {
2147	var str = toStr.call(value);
2148	var isArgs = str === '[object Arguments]';
2149	if (!isArgs) {
2150		isArgs = str !== '[object Array]' &&
2151			value !== null &&
2152			typeof value === 'object' &&
2153			typeof value.length === 'number' &&
2154			value.length >= 0 &&
2155			toStr.call(value.callee) === '[object Function]';
2156	}
2157	return isArgs;
2158};
2159
2160},{}],52:[function(_dereq_,module,exports){
2161'use strict';
2162
2163var implementation = _dereq_('./implementation');
2164
2165var lacksProperEnumerationOrder = function () {
2166	if (!Object.assign) {
2167		return false;
2168	}
2169	// v8, specifically in node 4.x, has a bug with incorrect property enumeration order
2170	// note: this does not detect the bug unless there's 20 characters
2171	var str = 'abcdefghijklmnopqrst';
2172	var letters = str.split('');
2173	var map = {};
2174	for (var i = 0; i < letters.length; ++i) {
2175		map[letters[i]] = letters[i];
2176	}
2177	var obj = Object.assign({}, map);
2178	var actual = '';
2179	for (var k in obj) {
2180		actual += k;
2181	}
2182	return str !== actual;
2183};
2184
2185var assignHasPendingExceptions = function () {
2186	if (!Object.assign || !Object.preventExtensions) {
2187		return false;
2188	}
2189	// Firefox 37 still has "pending exception" logic in its Object.assign implementation,
2190	// which is 72% slower than our shim, and Firefox 40's native implementation.
2191	var thrower = Object.preventExtensions({ 1: 2 });
2192	try {
2193		Object.assign(thrower, 'xy');
2194	} catch (e) {
2195		return thrower[1] === 'y';
2196	}
2197};
2198
2199module.exports = function getPolyfill() {
2200	if (!Object.assign) {
2201		return implementation;
2202	}
2203	if (lacksProperEnumerationOrder()) {
2204		return implementation;
2205	}
2206	if (assignHasPendingExceptions()) {
2207		return implementation;
2208	}
2209	return Object.assign;
2210};
2211
2212},{"./implementation":44}],53:[function(_dereq_,module,exports){
2213'use strict';
2214
2215var define = _dereq_('define-properties');
2216var getPolyfill = _dereq_('./polyfill');
2217
2218module.exports = function shimAssign() {
2219	var polyfill = getPolyfill();
2220	define(
2221		Object,
2222		{ assign: polyfill },
2223		{ assign: function () { return Object.assign !== polyfill; } }
2224	);
2225	return polyfill;
2226};
2227
2228},{"./polyfill":52,"define-properties":46}],54:[function(_dereq_,module,exports){
2229module.exports = SafeParseTuple
2230
2231function SafeParseTuple(obj, reviver) {
2232    var json
2233    var error = null
2234
2235    try {
2236        json = JSON.parse(obj, reviver)
2237    } catch (err) {
2238        error = err
2239    }
2240
2241    return [error, json]
2242}
2243
2244},{}],55:[function(_dereq_,module,exports){
2245function clean (s) {
2246  return s.replace(/\n\r?\s*/g, '')
2247}
2248
2249
2250module.exports = function tsml (sa) {
2251  var s = ''
2252    , i = 0
2253
2254  for (; i < arguments.length; i++)
2255    s += clean(sa[i]) + (arguments[i + 1] || '')
2256
2257  return s
2258}
2259},{}],56:[function(_dereq_,module,exports){
2260"use strict";
2261var window = _dereq_("global/window")
2262var once = _dereq_("once")
2263var isFunction = _dereq_("is-function")
2264var parseHeaders = _dereq_("parse-headers")
2265var xtend = _dereq_("xtend")
2266
2267module.exports = createXHR
2268createXHR.XMLHttpRequest = window.XMLHttpRequest || noop
2269createXHR.XDomainRequest = "withCredentials" in (new createXHR.XMLHttpRequest()) ? createXHR.XMLHttpRequest : window.XDomainRequest
2270
2271forEachArray(["get", "put", "post", "patch", "head", "delete"], function(method) {
2272    createXHR[method === "delete" ? "del" : method] = function(uri, options, callback) {
2273        options = initParams(uri, options, callback)
2274        options.method = method.toUpperCase()
2275        return _createXHR(options)
2276    }
2277})
2278
2279function forEachArray(array, iterator) {
2280    for (var i = 0; i < array.length; i++) {
2281        iterator(array[i])
2282    }
2283}
2284
2285function isEmpty(obj){
2286    for(var i in obj){
2287        if(obj.hasOwnProperty(i)) return false
2288    }
2289    return true
2290}
2291
2292function initParams(uri, options, callback) {
2293    var params = uri
2294
2295    if (isFunction(options)) {
2296        callback = options
2297        if (typeof uri === "string") {
2298            params = {uri:uri}
2299        }
2300    } else {
2301        params = xtend(options, {uri: uri})
2302    }
2303
2304    params.callback = callback
2305    return params
2306}
2307
2308function createXHR(uri, options, callback) {
2309    options = initParams(uri, options, callback)
2310    return _createXHR(options)
2311}
2312
2313function _createXHR(options) {
2314    var callback = options.callback
2315    if(typeof callback === "undefined"){
2316        throw new Error("callback argument missing")
2317    }
2318    callback = once(callback)
2319
2320    function readystatechange() {
2321        if (xhr.readyState === 4) {
2322            loadFunc()
2323        }
2324    }
2325
2326    function getBody() {
2327        // Chrome with requestType=blob throws errors arround when even testing access to responseText
2328        var body = undefined
2329
2330        if (xhr.response) {
2331            body = xhr.response
2332        } else if (xhr.responseType === "text" || !xhr.responseType) {
2333            body = xhr.responseText || xhr.responseXML
2334        }
2335
2336        if (isJson) {
2337            try {
2338                body = JSON.parse(body)
2339            } catch (e) {}
2340        }
2341
2342        return body
2343    }
2344
2345    var failureResponse = {
2346                body: undefined,
2347                headers: {},
2348                statusCode: 0,
2349                method: method,

2350                url: uri,
2351                rawRequest: xhr
2352            }
2353
2354    function errorFunc(evt) {
2355        clearTimeout(timeoutTimer)
2356        if(!(evt instanceof Error)){
2357            evt = new Error("" + (evt || "Unknown XMLHttpRequest Error") )
2358        }
2359        evt.statusCode = 0
2360        callback(evt, failureResponse)
2361    }
2362
2363    // will load the data & process the response in a special response object
2364    function loadFunc() {
2365        if (aborted) return
2366        var status
2367        clearTimeout(timeoutTimer)
2368        if(options.useXDR && xhr.status===undefined) {
2369            //IE8 CORS GET successful response doesn't have a status field, but body is fine
2370            status = 200
2371        } else {
2372            status = (xhr.status === 1223 ? 204 : xhr.status)
2373        }
2374        var response = failureResponse
2375        var err = null
2376
2377        if (status !== 0){
2378            response = {
2379                body: getBody(),
2380                statusCode: status,
2381                method: method,
2382                headers: {},
2383                url: uri,
2384                rawRequest: xhr
2385            }
2386            if(xhr.getAllResponseHeaders){ //remember xhr can in fact be XDR for CORS in IE
2387                response.headers = parseHeaders(xhr.getAllResponseHeaders())
2388            }
2389        } else {
2390            err = new Error("Internal XMLHttpRequest Error")
2391        }
2392        callback(err, response, response.body)
2393
2394    }
2395
2396    var xhr = options.xhr || null
2397
2398    if (!xhr) {
2399        if (options.cors || options.useXDR) {
2400            xhr = new createXHR.XDomainRequest()
2401        }else{
2402            xhr = new createXHR.XMLHttpRequest()
2403        }
2404    }
2405
2406    var key
2407    var aborted
2408    var uri = xhr.url = options.uri || options.url
2409    var method = xhr.method = options.method || "GET"
2410    var body = options.body || options.data || null
2411    var headers = xhr.headers = options.headers || {}
2412    var sync = !!options.sync
2413    var isJson = false
2414    var timeoutTimer
2415
2416    if ("json" in options) {
2417        isJson = true
2418        headers["accept"] || headers["Accept"] || (headers["Accept"] = "application/json") //Don't override existing accept header declared by user
2419        if (method !== "GET" && method !== "HEAD") {
2420            headers["content-type"] || headers["Content-Type"] || (headers["Content-Type"] = "application/json") //Don't override existing accept header declared by user
2421            body = JSON.stringify(options.json)
2422        }
2423    }
2424
2425    xhr.onreadystatechange = readystatechange
2426    xhr.onload = loadFunc
2427    xhr.onerror = errorFunc
2428    // IE9 must have onprogress be set to a unique function.
2429    xhr.onprogress = function () {
2430        // IE must die
2431    }
2432    xhr.ontimeout = errorFunc
2433    xhr.open(method, uri, !sync, options.username, options.password)
2434    //has to be after open
2435    if(!sync) {
2436        xhr.withCredentials = !!options.withCredentials
2437    }
2438    // Cannot set timeout with sync request
2439    // not setting timeout on the xhr object, because of old webkits etc. not handling that correctly
2440    // both npm's request and jquery 1.x use this kind of timeout, so this is being consistent
2441    if (!sync && options.timeout > 0 ) {
2442        timeoutTimer = setTimeout(function(){
2443            aborted=true//IE9 may still call readystatechange
2444            xhr.abort("timeout")
2445            var e = new Error("XMLHttpRequest timeout")
2446            e.code = "ETIMEDOUT"
2447            errorFunc(e)
2448        }, options.timeout )
2449    }
2450
2451    if (xhr.setRequestHeader) {
2452        for(key in headers){
2453            if(headers.hasOwnProperty(key)){
2454                xhr.setRequestHeader(key, headers[key])
2455            }
2456        }
2457    } else if (options.headers && !isEmpty(options.headers)) {
2458        throw new Error("Headers cannot be set on an XDomainRequest object")
2459    }
2460
2461    if ("responseType" in options) {
2462        xhr.responseType = options.responseType
2463    }
2464
2465    if ("beforeSend" in options &&
2466        typeof options.beforeSend === "function"
2467    ) {
2468        options.beforeSend(xhr)
2469    }
2470
2471    xhr.send(body)
2472
2473    return xhr
2474
2475
2476}
2477
2478function noop() {}
2479
2480},{"global/window":2,"is-function":57,"once":58,"parse-headers":61,"xtend":62}],57:[function(_dereq_,module,exports){
2481module.exports = isFunction
2482
2483var toString = Object.prototype.toString
2484
2485function isFunction (fn) {
2486  var string = toString.call(fn)
2487  return string === '[object Function]' ||
2488    (typeof fn === 'function' && string !== '[object RegExp]') ||
2489    (typeof window !== 'undefined' &&
2490     // IE8 and below
2491     (fn === window.setTimeout ||
2492      fn === window.alert ||
2493      fn === window.confirm ||
2494      fn === window.prompt))
2495};
2496
2497},{}],58:[function(_dereq_,module,exports){
2498module.exports = once
2499
2500once.proto = once(function () {
2501  Object.defineProperty(Function.prototype, 'once', {
2502    value: function () {
2503      return once(this)
2504    },
2505    configurable: true
2506  })
2507})
2508
2509function once (fn) {
2510  var called = false
2511  return function () {
2512    if (called) return
2513    called = true
2514    return fn.apply(this, arguments)
2515  }
2516}
2517
2518},{}],59:[function(_dereq_,module,exports){
2519var isFunction = _dereq_('is-function')
2520
2521module.exports = forEach
2522
2523var toString = Object.prototype.toString
2524var hasOwnProperty = Object.prototype.hasOwnProperty
2525
2526function forEach(list, iterator, context) {
2527    if (!isFunction(iterator)) {
2528        throw new TypeError('iterator must be a function')
2529    }
2530
2531    if (arguments.length < 3) {
2532        context = this
2533    }
2534    
2535    if (toString.call(list) === '[object Array]')

2536        forEachArray(list, iterator, context)
2537    else if (typeof list === 'string')
2538        forEachString(list, iterator, context)
2539    else
2540        forEachObject(list, iterator, context)
2541}
2542
2543function forEachArray(array, iterator, context) {
2544    for (var i = 0, len = array.length; i < len; i++) {
2545        if (hasOwnProperty.call(array, i)) {
2546            iterator.call(context, array[i], i, array)
2547        }
2548    }
2549}
2550
2551function forEachString(string, iterator, context) {
2552    for (var i = 0, len = string.length; i < len; i++) {
2553        // no such thing as a sparse string.
2554        iterator.call(context, string.charAt(i), i, string)
2555    }
2556}
2557
2558function forEachObject(object, iterator, context) {
2559    for (var k in object) {
2560        if (hasOwnProperty.call(object, k)) {
2561            iterator.call(context, object[k], k, object)
2562        }
2563    }
2564}
2565
2566},{"is-function":57}],60:[function(_dereq_,module,exports){
2567
2568exports = module.exports = trim;
2569
2570function trim(str){
2571  return str.replace(/^\s*|\s*$/g, '');
2572}
2573
2574exports.left = function(str){
2575  return str.replace(/^\s*/, '');
2576};
2577
2578exports.right = function(str){
2579  return str.replace(/\s*$/, '');
2580};
2581
2582},{}],61:[function(_dereq_,module,exports){
2583var trim = _dereq_('trim')
2584  , forEach = _dereq_('for-each')
2585  , isArray = function(arg) {
2586      return Object.prototype.toString.call(arg) === '[object Array]';
2587    }
2588
2589module.exports = function (headers) {
2590  if (!headers)
2591    return {}
2592
2593  var result = {}
2594
2595  forEach(
2596      trim(headers).split('\n')
2597    , function (row) {
2598        var index = row.indexOf(':')
2599          , key = trim(row.slice(0, index)).toLowerCase()
2600          , value = trim(row.slice(index + 1))
2601
2602        if (typeof(result[key]) === 'undefined') {
2603          result[key] = value
2604        } else if (isArray(result[key])) {
2605          result[key].push(value)
2606        } else {
2607          result[key] = [ result[key], value ]
2608        }
2609      }
2610  )
2611
2612  return result
2613}
2614},{"for-each":59,"trim":60}],62:[function(_dereq_,module,exports){
2615module.exports = extend
2616
2617var hasOwnProperty = Object.prototype.hasOwnProperty;
2618
2619function extend() {
2620    var target = {}
2621
2622    for (var i = 0; i < arguments.length; i++) {
2623        var source = arguments[i]
2624
2625        for (var key in source) {
2626            if (hasOwnProperty.call(source, key)) {
2627                target[key] = source[key]
2628            }
2629        }
2630    }
2631
2632    return target
2633}
2634
2635},{}],63:[function(_dereq_,module,exports){
2636/**
2637 * @file big-play-button.js
2638 */
2639'use strict';
2640
2641exports.__esModule = true;
2642
2643function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
2644
2645function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
2646
2647function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
2648
2649var _buttonJs = _dereq_('./button.js');
2650
2651var _buttonJs2 = _interopRequireDefault(_buttonJs);
2652
2653var _componentJs = _dereq_('./component.js');
2654
2655var _componentJs2 = _interopRequireDefault(_componentJs);
2656
2657/**
2658 * Initial play button. Shows before the video has played. The hiding of the
2659 * big play button is done via CSS and player states.
2660 *
2661 * @param {Object} player  Main Player
2662 * @param {Object=} options Object of option names and values
2663 * @extends Button
2664 * @class BigPlayButton
2665 */
2666
2667var BigPlayButton = (function (_Button) {
2668  _inherits(BigPlayButton, _Button);
2669
2670  function BigPlayButton(player, options) {
2671    _classCallCheck(this, BigPlayButton);
2672
2673    _Button.call(this, player, options);
2674  }
2675
2676  /**
2677   * Allow sub components to stack CSS class names
2678   *
2679   * @return {String} The constructed class name
2680   * @method buildCSSClass
2681   */
2682
2683  BigPlayButton.prototype.buildCSSClass = function buildCSSClass() {
2684    return 'vjs-big-play-button';
2685  };
2686
2687  /**
2688   * Handles click for play
2689   *
2690   * @method handleClick
2691   */
2692
2693  BigPlayButton.prototype.handleClick = function handleClick() {
2694    this.player_.play();
2695  };
2696
2697  return BigPlayButton;
2698})(_buttonJs2['default']);
2699
2700BigPlayButton.prototype.controlText_ = 'Play Video';
2701
2702_componentJs2['default'].registerComponent('BigPlayButton', BigPlayButton);
2703exports['default'] = BigPlayButton;
2704module.exports = exports['default'];
2705
2706},{"./button.js":64,"./component.js":67}],64:[function(_dereq_,module,exports){
2707/**
2708 * @file button.js
2709 */
2710'use strict';
2711
2712exports.__esModule = true;
2713
2714function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
2715
2716function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
2717
2718function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
2719
2720function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { c