https://www.yorn.net/etc.clientlibs/digital-commons/clientlibs/clientlib-site.min.js

408 *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
409 *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
410 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
411 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
412 * OF THE POSSIBILITY OF SUCH DAMAGE. 
413 *
414*/
415
416// t: current time, b: begInnIng value, c: change In value, d: duration
417jQuery.easing['jswing'] = jQuery.easing['swing'];
418
419jQuery.extend( jQuery.easing,
420{
421	def: 'easeOutQuad',
422	swing: function (x, t, b, c, d) {
423		//alert(jQuery.easing.default);
424		return jQuery.easing[jQuery.easing.def](x, t, b, c, d);
425	},
426	easeInQuad: function (x, t, b, c, d) {
427		return c*(t/=d)*t + b;
428	},
429	easeOutQuad: function (x, t, b, c, d) {
430		return -c *(t/=d)*(t-2) + b;
431	},
432	easeInOutQuad: function (x, t, b, c, d) {
433		if ((t/=d/2) < 1) return c/2*t*t + b;
434		return -c/2 * ((--t)*(t-2) - 1) + b;
435	},
436	easeInCubic: function (x, t, b, c, d) {
437		return c*(t/=d)*t*t + b;
438	},
439	easeOutCubic: function (x, t, b, c, d) {
440		return c*((t=t/d-1)*t*t + 1) + b;
441	},
442	easeInOutCubic: function (x, t, b, c, d) {
443		if ((t/=d/2) < 1) return c/2*t*t*t + b;
444		return c/2*((t-=2)*t*t + 2) + b;
445	},
446	easeInQuart: function (x, t, b, c, d) {
447		return c*(t/=d)*t*t*t + b;
448	},
449	easeOutQuart: function (x, t, b, c, d) {
450		return -c * ((t=t/d-1)*t*t*t - 1) + b;
451	},
452	easeInOutQuart: function (x, t, b, c, d) {
453		if ((t/=d/2) < 1) return c/2*t*t*t*t + b;
454		return -c/2 * ((t-=2)*t*t*t - 2) + b;
455	},
456	easeInQuint: function (x, t, b, c, d) {
457		return c*(t/=d)*t*t*t*t + b;
458	},
459	easeOutQuint: function (x, t, b, c, d) {
460		return c*((t=t/d-1)*t*t*t*t + 1) + b;
461	},
462	easeInOutQuint: function (x, t, b, c, d) {
463		if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b;
464		return c/2*((t-=2)*t*t*t*t + 2) + b;
465	},
466	easeInSine: function (x, t, b, c, d) {
467		return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
468	},
469	easeOutSine: function (x, t, b, c, d) {
470		return c * Math.sin(t/d * (Math.PI/2)) + b;
471	},
472	easeInOutSine: function (x, t, b, c, d) {
473		return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
474	},
475	easeInExpo: function (x, t, b, c, d) {
476		return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b;
477	},
478	easeOutExpo: function (x, t, b, c, d) {
479		return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
480	},
481	easeInOutExpo: function (x, t, b, c, d) {
482		if (t==0) return b;
483		if (t==d) return b+c;
484		if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b;
485		return c/2 * (-Math.pow(2, -10 * --t) + 2) + b;
486	},
487	easeInCirc: function (x, t, b, c, d) {
488		return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
489	},
490	easeOutCirc: function (x, t, b, c, d) {
491		return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
492	},
493	easeInOutCirc: function (x, t, b, c, d) {
494		if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
495		return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
496	},
497	easeInElastic: function (x, t, b, c, d) {
498		var s=1.70158;var p=0;var a=c;
499		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
500		if (a < Math.abs(c)) { a=c; var s=p/4; }
501		else var s = p/(2*Math.PI) * Math.asin (c/a);
502		return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
503	},
504	easeOutElastic: function (x, t, b, c, d) {
505		var s=1.70158;var p=0;var a=c;
506		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
507		if (a < Math.abs(c)) { a=c; var s=p/4; }
508		else var s = p/(2*Math.PI) * Math.asin (c/a);
509		return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
510	},
511	easeInOutElastic: function (x, t, b, c, d) {
512		var s=1.70158;var p=0;var a=c;
513		if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) p=d*(.3*1.5);
514		if (a < Math.abs(c)) { a=c; var s=p/4; }
515		else var s = p/(2*Math.PI) * Math.asin (c/a);
516		if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
517		return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b;
518	},
519	easeInBack: function (x, t, b, c, d, s) {
520		if (s == undefined) s = 1.70158;
521		return c*(t/=d)*t*((s+1)*t - s) + b;
522	},
523	easeOutBack: function (x, t, b, c, d, s) {
524		if (s == undefined) s = 1.70158;
525		return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
526	},
527	easeInOutBack: function (x, t, b, c, d, s) {
528		if (s == undefined) s = 1.70158; 
529		if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
530		return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
531	},
532	easeInBounce: function (x, t, b, c, d) {
533		return c - jQuery.easing.easeOutBounce (x, d-t, 0, c, d) + b;
534	},
535	easeOutBounce: function (x, t, b, c, d) {
536		if ((t/=d) < (1/2.75)) {
537			return c*(7.5625*t*t) + b;
538		} else if (t < (2/2.75)) {
539			return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
540		} else if (t < (2.5/2.75)) {
541			return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
542		} else {
543			return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
544		}
545	},
546	easeInOutBounce: function (x, t, b, c, d) {
547		if (t < d/2) return jQuery.easing.easeInBounce (x, t*2, 0, c, d) * .5 + b;
548		return jQuery.easing.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b;
549	}
550});
551
552/*
553 *

615,module,exports){
616(function (global){
617/**
618 * Copyright (c) 2014, Facebook, Inc.
619 * All rights reserved.
620 *
621 * This source code is licensed under the BSD-style license found in the
622 * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
623 * additional grant of patent rights can be found in the PATENTS file in
624 * the same directory.
625 */
626
627!(function(global) {
628  "use strict";
629
630  var Op = Object.prototype;
631  var hasOwn = Op.hasOwnProperty;
632  var undefined; // More compressible than void 0.
633  var $Symbol = typeof Symbol === "function" ? Symbol : {};
634  var iteratorSymbol = $Symbol.iterator || "@@iterator";
635  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
636  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
637
638  var inModule = typeof module === "object";
639  var runtime = global.regeneratorRuntime;
640  if (runtime) {
641    if (inModule) {
642      // If regeneratorRuntime is defined globally and we're in a module,
643      // make the exports object identical to regeneratorRuntime.
644      module.exports = runtime;
645    }
646    // Don't bother evaluating the rest of this file if the runtime was
647    // already defined globally.
648    return;
649  }
650
651  // Define the runtime globally (as expected by generated code) as either
652  // module.exports (if we're in a module) or a new, empty object.
653  runtime = global.regeneratorRuntime = inModule ? module.exports : {};
654
655  function wrap(innerFn, outerFn, self, tryLocsList) {
656    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
657    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
658    var generator = Object.create(protoGenerator.prototype);
659    var context = new Context(tryLocsList || []);
660
661    // The ._invoke method unifies the implementations of the .next,
662    // .throw, and .return methods.
663    generator._invoke = makeInvokeMethod(innerFn, self, context);
664
665    return generator;
666  }
667  runtime.wrap = wrap;
668
669  // Try/catch helper to minimize deoptimizations. Returns a completion
670  // record like context.tryEntries[i].completion. This interface could
671  // have been (and was previously) designed to take a closure to be
672  // invoked without arguments, but in all the cases we care about we
673  // already have an existing method we want to call, so there's no need
674  // to create a new function object. We can even get away with assuming
675  // the method takes exactly one argument, since that happens to be true
676  // in every case, so we don't have to touch the arguments object. The
677  // only additional allocation required is the completion record, which
678  // has a stable shape and so hopefully should be cheap to allocate.
679  function tryCatch(fn, obj, arg) {
680    try {
681      return { type: "normal", arg: fn.call(obj, arg) };
682    } catch (err) {
683      return { type: "throw", arg: err };
684    }
685  }
686
687  var GenStateSuspendedStart = "suspendedStart";
688  var GenStateSuspendedYield = "suspendedYield";
689  var GenStateExecuting = "executing";
690  var GenStateCompleted = "completed";
691
692  // Returning this object from the innerFn has the same effect as
693  // breaking out of the dispatch switch statement.
694  var ContinueSentinel = {};
695
696  // Dummy constructor functions that we use as the .constructor and
697  // .constructor.prototype properties for functions that return Generator
698  // objects. For full spec compliance, you may wish to configure your
699  // minifier not to mangle the names of these two functions.
700  function Generator() {}
701  function GeneratorFunction() {}
702  function GeneratorFunctionPrototype() {}
703
704  // This is a polyfill for %IteratorPrototype% for environments that
705  // don't natively support it.
706  var IteratorPrototype = {};
707  IteratorPrototype[iteratorSymbol] = function () {
708    return this;
709  };
710
711  var getProto = Object.getPrototypeOf;
712  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
713  if (NativeIteratorPrototype &&
714      NativeIteratorPrototype !== Op &&
715      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
716    // This environment has a native %IteratorPrototype%; use it instead
717    // of the polyfill.
718    IteratorPrototype = NativeIteratorPrototype;
719  }
720
721  var Gp = GeneratorFunctionPrototype.prototype =
722    Generator.prototype = Object.create(IteratorPrototype);
723  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
724  GeneratorFunctionPrototype.constructor = GeneratorFunction;
725  GeneratorFunctionPrototype[toStringTagSymbol] =
726    GeneratorFunction.displayName = "GeneratorFunction";
727
728  // Helper for defining the .next, .throw, and .return methods of the
729  // Iterator interface in terms of a single ._invoke method.
730  function defineIteratorMethods(prototype) {
731    ["next", "throw", "return"].forEach(function(method) {
732      prototype[method] = function(arg) {
733        return this._invoke(method, arg);
734      };
735    });
736  }
737
738  runtime.isGeneratorFunction = function(genFun) {
739    var ctor = typeof genFun === "function" && genFun.constructor;
740    return ctor
741      ? ctor === GeneratorFunction ||
742        // For the native GeneratorFunction constructor, the best we can
743        // do is to check its .name property.
744        (ctor.displayName || ctor.name) === "GeneratorFunction"
745      : false;
746  };
747
748  runtime.mark = function(genFun) {
749    if (Object.setPrototypeOf) {
750      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
751    } else {
752      genFun.__proto__ = GeneratorFunctionPrototype;
753      if (!(toStringTagSymbol in genFun)) {
754        genFun[toStringTagSymbol] = "GeneratorFunction";
755      }
756    }
757    genFun.prototype = Object.create(Gp);
758    return genFun;
759  };
760
761  // Within the body of any async function, `await x` is transformed to
762  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
763  // `hasOwn.call(value, "__await")` to determine if the yielded value is
764  // meant to be awaited.
765  runtime.awrap = function(arg) {
766    return { __await: arg };
767  };
768
769  function AsyncIterator(generator) {
770    function invoke(method, arg, resolve, reject) {
771      var record = tryCatch(generator[method], generator, arg);
772      if (record.type === "throw") {
773        reject(record.arg);
774      } else {
775        var result = record.arg;
776        var value = result.value;
777        if (value &&
778            typeof value === "object" &&
779            hasOwn.call(value, "__await")) {
780          return Promise.resolve(value.__await).then(function(value) {
781            invoke("next", value, resolve, reject);
782          }, function(err) {
783            invoke("throw", err, resolve, reject);
784          });
785        }
786
787        return Promise.resolve(value).then(function(unwrapped) {
788          // When a yielded Promise is resolved, its final value becomes
789          // the .value of the Promise<{value,done}> result for the
790          // current iteration. If the Promise is rejected, however, the
791          // result for this iteration will be rejected with the same
792          // reason. Note that rejections of yielded Promises are not
793          // thrown back into the generator function, as is the case
794          // when an awaited Promise is rejected. This difference in
795          // behavior between yield and await is important, because it
796          // allows the consumer to decide what to do with the yielded
797          // rejection (swallow it and continue, manually .throw it back
798          // into the generator, abandon iteration, whatever). With
799          // await, by contrast, there is no opportunity to examine the
800          // rejection reason outside the generator function, so the
801          // only option is to throw it from the await expression, and
802          // let the generator function handle the exception.
803          result.value = unwrapped;
804          resolve(result);
805        }, reject);
806      }
807    }
808
809    if (typeof global.process === "object" && global.process.domain) {
810      invoke = global.process.domain.bind(invoke);
811    }
812
813    var previousPromise;
814
815    function enqueue(method, arg) {
816      function callInvokeWithMethodAndArg() {
817        return new Promise(function(resolve, reject) {
818          invoke(method, arg, resolve, reject);
819        });
820      }
821
822      return previousPromise =
823        // If enqueue has been called before, then we want to wait until
824        // all previous Promises have been resolved before calling invoke,
825        // so that results are always delivered in the correct order. If
826        // enqueue has not been called before, then it is important to
827        // call invoke immediately, without waiting on a callback to fire,
828        // so that the async generator function has the opportunity to do
829        // any necessary setup in a predictable way. This predictability
830        // is why the Promise constructor synchronously invokes its
831        // executor callback, and why async functions synchronously
832        // execute code before the first await. Since we implement simple
833        // async functions in terms of async generators, it is especially
834        // important to get this right, even though it requires care.
835        previousPromise ? previousPromise.then(
836          callInvokeWithMethodAndArg,
837          // Avoid propagating failures to Promises returned by later
838          // invocations of the iterator.
839          callInvokeWithMethodAndArg
840        ) : callInvokeWithMethodAndArg();
841    }
842
843    // Define the unified helper method that is used to implement .next,
844    // .throw, and .return (see defineIteratorMethods).
845    this._invoke = enqueue;
846  }
847
848  defineIteratorMethods(AsyncIterator.prototype);
849  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
850    return this;
851  };
852  runtime.AsyncIterator = AsyncIterator;
853
854  // Note that simple async functions are implemented on top of
855  // AsyncIterator objects; they just return a Promise for the value of
856  // the final result produced by the iterator.
857  runtime.async = function(innerFn, outerFn, self, tryLocsList) {
858    var iter = new AsyncIterator(
859      wrap(innerFn, outerFn, self, tryLocsList)
860    );
861
862    return runtime.isGeneratorFunction(outerFn)
863      ? iter // If outerFn is a generator, return the full iterator.
864      : iter.next().then(function(result) {
865          return result.done ? result.value : iter.next();
866        });
867  };
868
869  function makeInvokeMethod(innerFn, self, context) {
870    var state = GenStateSuspendedStart;
871
872    return function invoke(method, arg) {
873      if (state === GenStateExecuting) {
874        throw new Error("Generator is already running");
875      }
876
877      if (state === GenStateCompleted) {
878        if (method === "throw") {
879          throw arg;
880        }
881
882        // Be forgiving, per 25.3.3.3.3 of the spec:
883        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
884        return doneResult();
885      }
886
887      context.method = method;
888      context.arg = arg;
889
890      while (true) {
891        var delegate = context.delegate;
892        if (delegate) {
893          var delegateResult = maybeInvokeDelegate(delegate, context);
894          if (delegateResult) {
895            if (delegateResult === ContinueSentinel) continue;
896            return delegateResult;
897          }
898        }
899
900        if (context.method === "next") {
901          // Setting context._sent for legacy support of Babel's
902          // function.sent implementation.
903          context.sent = context._sent = context.arg;
904
905        } else if (context.method === "throw") {
906          if (state === GenStateSuspendedStart) {
907            state = GenStateCompleted;
908            throw context.arg;
909          }
910
911          context.dispatchException(context.arg);
912
913        } else if (context.method === "return") {
914          context.abrupt("return", context.arg);
915        }
916
917        state = GenStateExecuting;
918
919        var record = tryCatch(innerFn, self, context);
920        if (record.type === "normal") {
921          // If an exception is thrown from innerFn, we leave state ===
922          // GenStateExecuting and loop back for another invocation.
923          state = context.done
924            ? GenStateCompleted
925            : GenStateSuspendedYield;
926
927          if (record.arg === ContinueSentinel) {
928            continue;
929          }
930
931          return {
932            value: record.arg,
933            done: context.done
934          };
935
936        } else if (record.type === "throw") {
937          state = GenStateCompleted;
938          // Dispatch the exception by looping back around to the
939          // context.dispatchException(context.arg) call above.
940          context.method = "throw";
941          context.arg = record.arg;
942        }
943      }
944    };
945  }
946
947  // Call delegate.iterator[context.method](context.arg) and handle the
948  // result, either by returning a { value, done } result from the
949  // delegate iterator, or by modifying context.method and context.arg,
950  // setting context.delegate to null, and returning the ContinueSentinel.
951  function maybeInvokeDelegate(delegate, context) {
952    var method = delegate.iterator[context.method];
953    if (method === undefined) {
954      // A .throw or .return when the delegate iterator has no .throw
955      // method always terminates the yield* loop.
956      context.delegate = null;
957
958      if (context.method === "throw") {
959        if (delegate.iterator.return) {
960          // If the delegate iterator has a return method, give it a
961          // chance to clean up.
962          context.method = "return";
963          context.arg = undefined;
964          maybeInvokeDelegate(delegate, context);
965
966          if (context.method === "throw") {
967            // If maybeInvokeDelegate(context) changed context.method from
968            // "return" to "throw", let that override the TypeError below.

969            return ContinueSentinel;
970          }
971        }
972
973        context.method = "throw";
974        context.arg = new TypeError(
975          "The iterator does not provide a 'throw' method");
976      }
977
978      return ContinueSentinel;
979    }
980
981    var record = tryCatch(method, delegate.iterator, context.arg);
982
983    if (record.type === "throw") {
984      context.method = "throw";
985      context.arg = record.arg;
986      context.delegate = null;
987      return ContinueSentinel;
988    }
989
990    var info = record.arg;
991
992    if (! info) {
993      context.method = "throw";
994      context.arg = new TypeError("iterator result is not an object");
995      context.delegate = null;
996      return ContinueSentinel;
997    }
998
999    if (info.done) {
1000      // Assign the result of the finished delegate to the temporary
1001      // variable specified by delegate.resultName (see delegateYield).
1002      context[delegate.resultName] = info.value;
1003
1004      // Resume execution at the desired location (see delegateYield).
1005      context.next = delegate.nextLoc;
1006
1007      // If context.method was "throw" but the delegate handled the
1008      // exception, let the outer generator proceed normally. If
1009      // context.method was "next", forget context.arg since it has been
1010      // "consumed" by the delegate iterator. If context.method was
1011      // "return", allow the original .return call to continue in the
1012      // outer generator.
1013      if (context.method !== "return") {
1014        context.method = "next";
1015        context.arg = undefined;
1016      }
1017
1018    } else {
1019      // Re-yield the result returned by the delegate method.
1020      return info;
1021    }
1022
1023    // The delegate iterator is finished, so forget it and continue with
1024    // the outer generator.
1025    context.delegate = null;
1026    return ContinueSentinel;
1027  }
1028
1029  // Define Generator.prototype.{next,throw,return} in terms of the
1030  // unified ._invoke helper method.
1031  defineIteratorMethods(Gp);
1032
1033  Gp[toStringTagSymbol] = "Generator";
1034
1035  // A Generator should always return itself as the iterator object when the
1036  // @@iterator function is called on it. Some browsers' implementations of the
1037  // iterator prototype chain incorrectly implement this, causing the Generator
1038  // object to not be returned from this call. This ensures that doesn't happen.
1039  // See https://github.com/facebook/regenerator/issues/274 for more details.
1040  Gp[iteratorSymbol] = function() {
1041    return this;
1042  };
1043
1044  Gp.toString = function() {
1045    return "[object Generator]";
1046  };
1047
1048  function pushTryEntry(locs) {
1049    var entry = { tryLoc: locs[0] };
1050
1051    if (1 in locs) {
1052      entry.catchLoc = locs[1];
1053    }
1054
1055    if (2 in locs) {
1056      entry.finallyLoc = locs[2];
1057      entry.afterLoc = locs[3];
1058    }
1059
1060    this.tryEntries.push(entry);
1061  }
1062
1063  function resetTryEntry(entry) {
1064    var record = entry.completion || {};
1065    record.type = "normal";
1066    delete record.arg;
1067    entry.completion = record;
1068  }
1069
1070  function Context(tryLocsList) {
1071    // The root entry object (effectively a try statement without a catch
1072    // or a finally block) gives us a place to store values thrown from
1073    // locations where there is no enclosing try statement.
1074    this.tryEntries = [{ tryLoc: "root" }];
1075    tryLocsList.forEach(pushTryEntry, this);
1076    this.reset(true);
1077  }
1078
1079  runtime.keys = function(object) {
1080    var keys = [];
1081    for (var key in object) {
1082      keys.push(key);
1083    }
1084    keys.reverse();
1085
1086    // Rather than returning an object with a next method, we keep
1087    // things simple and return the next function itself.
1088    return function next() {
1089      while (keys.length) {
1090        var key = keys.pop();
1091        if (key in object) {
1092          next.value = key;
1093          next.done = false;
1094          return next;
1095        }
1096      }
1097
1098      // To avoid creating an additional object, we just hang the .value
1099      // and .done properties off the next function object itself. This
1100      // also ensures that the minifier will not anonymize the function.
1101      next.done = true;
1102      return next;
1103    };
1104  };
1105
1106  function values(iterable) {
1107    if (iterable) {
1108      var iteratorMethod = iterable[iteratorSymbol];
1109      if (iteratorMethod) {
1110        return iteratorMethod.call(iterable);
1111      }
1112
1113      if (typeof iterable.next === "function") {
1114        return iterable;
1115      }
1116
1117      if (!isNaN(iterable.length)) {
1118        var i = -1, next = function next() {
1119          while (++i < iterable.length) {
1120            if (hasOwn.call(iterable, i)) {
1121              next.value = iterable[i];
1122              next.done = false;
1123              return next;
1124            }
1125          }
1126
1127          next.value = undefined;
1128          next.done = true;
1129
1130          return next;
1131        };
1132
1133        return next.next = next;
1134      }
1135    }
1136
1137    // Return an iterator with no values.
1138    return { next: doneResult };
1139  }
1140  runtime.values = values;
1141
1142  function doneResult() {
1143    return { value: undefined, done: true };
1144  }
1145
1146  Context.prototype = {
1147    constructor: Context,
1148
1149    reset: function(skipTempReset) {
1150      this.prev = 0;
1151      this.next = 0;
1152      // Resetting context._sent for legacy support of Babel's
1153      // function.sent implementation.
1154      this.sent = this._sent = undefined;
1155      this.done = false;
1156      this.delegate = null;
1157
1158      this.method = "next";
1159      this.arg = undefined;
1160
1161      this.tryEntries.forEach(resetTryEntry);
1162
1163      if (!skipTempReset) {
1164        for (var name in this) {
1165          // Not sure about the optimal order of these conditions:
1166          if (name.charAt(0) === "t" &&
1167              hasOwn.call(this, name) &&
1168              !isNaN(+name.slice(1))) {
1169            this[name] = undefined;
1170          }
1171        }
1172      }
1173    },
1174
1175    stop: function() {
1176      this.done = true;
1177
1178      var rootEntry = this.tryEntries[0];
1179      var rootRecord = rootEntry.completion;
1180      if (rootRecord.type === "throw") {
1181        throw rootRecord.arg;
1182      }
1183
1184      return this.rval;
1185    },
1186
1187    dispatchException: function(exception) {
1188      if (this.done) {
1189        throw exception;
1190      }
1191
1192      var context = this;
1193      function handle(loc, caught) {
1194        record.type = "throw";
1195        record.arg = exception;
1196        context.next = loc;
1197
1198        if (caught) {
1199          // If the dispatched exception was caught by a catch block,
1200          // then let that catch block handle the exception normally.
1201          context.method = "next";
1202          context.arg = undefined;
1203        }
1204
1205        return !! caught;
1206      }
1207
1208      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1209        var entry = this.tryEntries[i];
1210        var record = entry.completion;
1211
1212        if (entry.tryLoc === "root") {
1213          // Exception thrown outside of any try block that could handle
1214          // it, so set the completion value of the entire function to
1215          // throw the exception.
1216          return handle("end");
1217        }
1218
1219        if (entry.tryLoc <= this.prev) {
1220          var hasCatch = hasOwn.call(entry, "catchLoc");
1221          var hasFinally = hasOwn.call(entry, "finallyLoc");
1222
1223          if (hasCatch && hasFinally) {
1224            if (this.prev < entry.catchLoc) {
1225              return handle(entry.catchLoc, true);
1226            } else if (this.prev < entry.finallyLoc) {
1227              return handle(entry.finallyLoc);
1228            }
1229
1230          } else if (hasCatch) {
1231            if (this.prev < entry.catchLoc) {
1232              return handle(entry.catchLoc, true);
1233            }
1234
1235          } else if (hasFinally) {
1236            if (this.prev < entry.finallyLoc) {
1237              return handle(entry.finallyLoc);
1238            }
1239
1240          } else {
1241            throw new Error("try statement without catch or finally");
1242          }
1243        }
1244      }
1245    },
1246
1247    abrupt: function(type, arg) {
1248      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1249        var entry = this.tryEntries[i];
1250        if (entry.tryLoc <= this.prev &&
1251            hasOwn.call(entry, "finallyLoc") &&
1252            this.prev < entry.finallyLoc) {
1253          var finallyEntry = entry;
1254          break;
1255        }
1256      }
1257
1258      if (finallyEntry &&
1259          (type === "break" ||
1260           type === "continue") &&
1261          finallyEntry.tryLoc <= arg &&
1262          arg <= finallyEntry.finallyLoc) {
1263        // Ignore the finally entry if control is not jumping to a
1264        // location outside the try/catch block.
1265        finallyEntry = null;
1266      }
1267
1268      var record = finallyEntry ? finallyEntry.completion : {};
1269      record.type = type;
1270      record.arg = arg;
1271
1272      if (finallyEntry) {
1273        this.method = "next";
1274        this.next = finallyEntry.finallyLoc;
1275        return ContinueSentinel;
1276      }
1277
1278      return this.complete(record);
1279    },
1280
1281    complete: function(record, afterLoc) {
1282      if (record.type === "throw") {
1283        throw record.arg;
1284      }
1285
1286      if (record.type === "break" ||
1287          record.type === "continue") {
1288        this.next = record.arg;
1289      } else if (record.type === "return") {
1290        this.rval = this.arg = record.arg;
1291        this.method = "return";
1292        this.next = "end";
1293      } else if (record.type === "normal" && afterLoc) {
1294        this.next = afterLoc;
1295      }
1296
1297      return ContinueSentinel;
1298    },
1299
1300    finish: function(finallyLoc) {
1301      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1302        var entry = this.tryEntries[i];
1303        if (entry.finallyLoc === finallyLoc) {
1304          this.complete(entry.completion, entry.afterLoc);
1305          resetTryEntry(entry);
1306          return ContinueSentinel;
1307        }
1308      }
1309    },
1310
1311    "catch": function(tryLoc) {
1312      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1313        var entry = this.tryEntries[i];
1314        if (entry.tryLoc === tryLoc) {
1315          var record = entry.completion;
1316          if (record.type === "throw") {
1317            var thrown = record.arg;
1318            resetTryEntry(entry);
1319          }
1320          return thrown;
1321        }
1322      }
1323
1324      // The context.catch method must only be called with a location
1325      // argument that corresponds to a known catch block.
1326      throw new Error("illegal catch attempt");
1327    },
1328
1329    delegateYield: function(iterable, resultName, nextLoc) {
1330      this.delegate = {
1331        iterator: values(iterable),
1332        resultName: resultName,
1333        nextLoc: nextLoc
1334      };
1335
1336      if (this.method === "next") {
1337        // Deliberately forget the last sent value so that we don't
1338        // accidentally pass it on to the delegate.
1339        this.arg = undefined;
1340      }
1341
1342      return ContinueSentinel;
1343    }
1344  };
1345})(
1346  // 

1552var toLength = require('./_to-length');
1553var toAbsoluteIndex = require('./_to-absolute-index');
1554module.exports = function (IS_INCLUDES) {
1555  return function ($this, el, fromIndex) {
1556    var O = toIObject($this);
1557    var length = toLength(O.length);
1558    var index = toAbsoluteIndex(fromIndex, length);
1559    var value;
1560    // Array#includes uses SameValueZero equality algorithm
1561    // eslint-disable-next-line no-self-compare
1562    if (IS_INCLUDES && el != el) while (length > index) {
1563      value = O[index++];
1564      // eslint-disable-next-line no-self-compare
1565      if (value != value) return true;
1566    // Array#indexOf ignores holes, Array#includes - not
1567    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
1568      if (O[index] === el) return IS_INCLUDES || index || 0;
1569    } return !IS_INCLUDES && -1;
1570  };
1571};
1572
1573},{"./_to-absolute-index":120,"./_to-iobject":123,"./_to-length":124}],18:[function(require,module,exports){
1574// 0 -> Array#forEach
1575// 1 -> Array#map
1576// 2 -> Array#filter
1577// 3 -> Array#some
1578// 4 -> Array#every
1579// 5 -> Array#find
1580// 6 -> Array#findIndex
1581var ctx = require('./_ctx');
1582var IObject = require('./_iobject');
1583var toObject = require('./_to-object');
1584var toLength = require('./_to-length');
1585var asc = require('./_array-species-create');
1586module.exports = function (TYPE, $create) {
1587  var IS_MAP = TYPE == 1;
1588  var IS_FILTER = TYPE == 2;
1589  var IS_SOME = TYPE == 3;
1590  var IS_EVERY = TYPE == 4;
1591  var IS_FIND_INDEX = TYPE == 6;
1592  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
1593  var create = $create || asc;
1594  return function ($this, callbackfn, that) {
1595    var O = toObject($this);
1596    var self = IObject(O);
1597    var f = ctx(callbackfn, that, 3);
1598    var length = toLength(self.length);
1599    var index = 0;
1600    var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
1601    var val, res;
1602    for (;length > index; index++) if (NO_HOLES || index in self) {
1603      val = self[index];
1604      res = f(val, index, O);
1605      if (TYPE) {
1606        if (IS_MAP) result[index] = res;   // map
1607        else if (res) switch (TYPE) {
1608          case 3: return true;             // some
1609          case 5: return val;              // find
1610          case 6: return index;            // findIndex
1611          case 2: result.push(val);        // filter
1612        } else if (IS_EVERY) return false; // every
1613      }
1614    }
1615    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
1616  };
1617};
1618
1619},{"./_array-species-create":21,"./_ctx":31,"./_iobject":54,"./_to-length":124,"./_to-object":125}],19:[function(require,module,exports){
1620var aFunction = require('./_a-function');
1621var toObject = require('./_to-object');
1622var IObject = require('./_iobject');
1623var toLength = require('./_to-length');
1624
1625module.exports = function (that, callbackfn, aLen, memo, isRight) {
1626  aFunction(callbackfn);
1627  var O = toObject(that);
1628  var self = IObject(O);
1629  var length = toLength(O.length);
1630  var index = isRight ? length - 1 : 0;
1631  var i = isRight ? -1 : 1;
1632  if (aLen < 2) for (;;) {
1633    if (index in self) {
1634      memo = self[index];
1635      index += i;
1636      break;
1637    }
1638    index += i;
1639    if (isRight ? index < 0 : length <= index) {
1640      throw TypeError('Reduce of empty array with no initial value');
1641    }
1642  }
1643  for (;isRight ? index >= 0 : length > index; index += i) if (index in self) {
1644    memo = callbackfn(memo, self[index], index, O);
1645  }
1646  return memo;
1647};
1648
1649},{"./_a-function":8,"./_iobject":54,"./_to-length":124,"./_to-object":125}],20:[function(require,module,exports){
1650var isObject = require('./_is-object');
1651var isArray = require('./_is-array');
1652var SPECIES = require('./_wks')('species');
1653
1654module.exports = function (original) {
1655  var C;
1656  if (isArray(original)) {
1657    C = original.constructor;
1658    // cross-realm fallback
1659    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
1660    if (isObject(C)) {
1661      C = C[SPECIES];
1662      if (C === null) C = undefined;
1663    }
1664  } return C === undefined ? Array : C;
1665};
1666
1667},{"./_is-array":56,"./_is-object":58,"./_wks":135}],21:[function(require,module,exports){
1668// 9.4.2.3 ArraySpeciesCreate(originalArray, length)
1669var speciesConstructor = require('./_array-species-constructor');
1670
1671module.exports = function (original, length) {
1672  return new (speciesConstructor(original))(length);
1673};
1674
1675},{"./_array-species-constructor":20}],22:[function(require,module,exports){
1676'use strict';
1677var aFunction = require('./_a-function');
1678var isObject = require('./_is-object');
1679var invoke = require('./_invoke');
1680var arraySlice = [].slice;
1681var factories = {};
1682
1683var construct = function (F, len, args) {
1684  if (!(len in factories)) {
1685    for (var n = [], i = 0; i < len; i++) n[i] = 'a[' + i + ']';
1686    // eslint-disable-next-line no-new-func
1687    factories[len] = Function('F,a', 'return new F(' + n.join(',') + ')');
1688  } return factories[len](F, args);
1689};
1690
1691module.exports = Function.bind || function bind(that /* , ...args */) {
1692  var fn = aFunction(this);
1693  var partArgs = arraySlice.call(arguments, 1);
1694  var bound = function (/* args... */) {
1695    var args = partArgs.concat(arraySlice.call(arguments));
1696    return this instanceof bound ? construct(fn, args.length, args) : invoke(fn, args, that);
1697  };
1698  if (isObject(fn.prototype)) bound.prototype = fn.prototype;
1699  return bound;
1700};
1701
1702},{"./_a-function":8,"./_invoke":53,"./_is-object":58}],23:[function(require,module,exports){
1703// getting tag from 19.1.3.6 Object.prototype.toString()
1704var cof = require('./_cof');
1705var TAG = require('./_wks')('toStringTag');
1706// ES3 wrong here
1707var ARG = cof(function () { return arguments; }()) == 'Arguments';
1708
1709// fallback for IE11 Script Access Denied error
1710var tryGet = function (it, key) {
1711  try {
1712    return it[key];
1713  } catch (e) { /* empty */ }
1714};
1715
1716module.exports = function (it) {
1717  var O, T, B;
1718  return it === undefined ? 'Undefined' : it === null ? 'Null'
1719    // @@toStringTag case
1720    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
1721    // builtinTag case
1722    : ARG ? cof(O)
1723    // ES3 arguments fallback
1724    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
1725};
1726
1727},{"./_cof":24,"./_wks":135}],24:[function(require,module,exports){
1728var toString = {}.toString;
1729
1730module.exports = function (it) {
1731  return toString.call(it).slice(8, -1);
1732};
1733
1734},{}],25:[function(require,module,exports){
1735'use strict';
1736var dP = require('./_object-dp').f;
1737var create = require('./_object-create');
1738var redefineAll = require('./_redefine-all');
1739var ctx = require('./_ctx');
1740var anInstance = require('./_an-instance');
1741var forOf = require('./_for-of');
1742var $iterDefine = require('./_iter-define');
1743var step = require('./_iter-step');
1744var setSpecies = require('./_set-species');
1745var DESCRIPTORS = require('./_descriptors');
1746var fastKey = require('./_meta').fastKey;
1747var validate = require('./_validate-collection');
1748var SIZE = DESCRIPTORS ? '_s' : 'size';
1749
1750var getEntry = function (that, key) {
1751  // fast case
1752  var index = fastKey(key);
1753  var entry;
1754  if (index !== 'F') return that._i[index];
1755  // frozen object case
1756  for (entry = that._f; entry; entry = entry.n) {
1757    if (entry.k == key) return entry;
1758  }
1759};
1760
1761module.exports = {
1762  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
1763    var C = wrapper(function (that, iterable) {
1764      anInstance(that, C, NAME, '_i');
1765      that._t = NAME;         // collection type
1766      that._i = create(null); // index
1767      that._f = undefined;    // first entry
1768      that._l = undefined;    // last entry
1769      that[SIZE] = 0;         // size
1770      if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
1771    });
1772    redefineAll(C.prototype, {
1773      // 23.1.3.1 Map.prototype.clear()
1774      // 23.2.3.2 Set.prototype.clear()
1775      clear: function clear() {
1776        for (var that = validate(this, NAME), data = that._i, entry = that._f; entry; entry = entry.n) {
1777          entry.r = true;
1778          if (entry.p) entry.p = entry.p.n = undefined;
1779          delete data[entry.i];
1780        }
1781        that._f = that._l = undefined;
1782        that[SIZE] = 0;
1783      },
1784      // 23.1.3.3 Map.prototype.delete(key)
1785      // 23.2.3.4 Set.prototype.delete(value)
1786      'delete': function (key) {
1787        var that = validate(this, NAME);
1788        var entry = getEntry(that, key);
1789        if (entry) {
1790          var next = entry.n;
1791          var prev = entry.p;
1792          delete that._i[entry.i];
1793          entry.r = true;
1794          if (prev) prev.n = next;
1795          if (next) next.p = prev;
1796          if (that._f == entry) that._f = next;
1797          if (that._l == entry) that._l = prev;
1798          that[SIZE]--;
1799        } return !!entry;
1800      },
1801      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
1802      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)

1803      forEach: function forEach(callbackfn /* , that = undefined */) {
1804        validate(this, NAME);
1805        var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
1806        var entry;
1807        while (entry = entry ? entry.n : this._f) {
1808          f(entry.v, entry.k, this);
1809          // revert to the last existing entry
1810          while (entry && entry.r) entry = entry.p;
1811        }
1812      },
1813      // 23.1.3.7 Map.prototype.has(key)
1814      // 23.2.3.7 Set.prototype.has(value)
1815      has: function has(key) {
1816        return !!getEntry(validate(this, NAME), key);
1817      }
1818    });
1819    if (DESCRIPTORS) dP(C.prototype, 'size', {
1820      get: function () {
1821        return validate(this, NAME)[SIZE];
1822      }
1823    });
1824    return C;
1825  },
1826  def: function (that, key, value) {
1827    var entry = getEntry(that, key);
1828    var prev, index;
1829    // change existing entry
1830    if (entry) {
1831      entry.v = value;
1832    // create new entry
1833    } else {
1834      that._l = entry = {
1835        i: index = fastKey(key, true), // <- index
1836        k: key,                        // <- key
1837        v: value,                      // <- value
1838        p: prev = that._l,             // <- previous entry
1839        n: undefined,                  // <- next entry
1840        r: false                       // <- removed
1841      };
1842      if (!that._f) that._f = entry;
1843      if (prev) prev.n = entry;
1844      that[SIZE]++;
1845      // add to index
1846      if (index !== 'F') that._i[index] = entry;
1847    } return that;
1848  },
1849  getEntry: getEntry,
1850  setStrong: function (C, NAME, IS_MAP) {
1851    // add .keys, .values, .entries, [@@iterator]
1852    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
1853    $iterDefine(C, NAME, function (iterated, kind) {
1854      this._t = validate(iterated, NAME); // target
1855      this._k = kind;                     // kind
1856      this._l = undefined;                // previous
1857    }, function () {
1858      var that = this;
1859      var kind = that._k;
1860      var entry = that._l;
1861      // revert to the last existing entry
1862      while (entry && entry.r) entry = entry.p;
1863      // get next entry
1864      if (!that._t || !(that._l = entry = entry ? entry.n : that._t._f)) {
1865        // or finish the iteration
1866        that._t = undefined;
1867        return step(1);
1868      }
1869      // return step by kind
1870      if (kind == 'keys') return step(0, entry.k);
1871      if (kind == 'values') return step(0, entry.v);
1872      return step(0, [entry.k, entry.v]);
1873    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
1874
1875    // add [@@species], 23.1.2.2, 23.2.2.2
1876    setSpecies(NAME);
1877  }
1878};
1879
1880},{"./_an-instance":12,"./_ctx":31,"./_descriptors":35,"./_for-of":45,"./_iter-define":62,"./_iter-step":64,"./_meta":72,"./_object-create":77,"./_object-dp":78,"./_redefine-all":97,"./_set-species":106,"./_validate-collection":132}],26:[function(require,module,exports){
1881// https://github.com/DavidBruant/Map-Set.prototype.toJSON
1882var classof = require('./_classof');
1883var from = require('./_array-from-iterable');
1884module.exports = function (NAME) {
1885  return function toJSON() {
1886    if (classof(this) != NAME) throw TypeError(NAME + "#toJSON isn't generic");
1887    return from(this);
1888  };
1889};
1890
1891},{"./_array-from-iterable":16,"./_classof":23}],27:[function(require,module,exports){
1892'use strict';
1893var redefineAll = require('./_redefine-all');
1894var getWeak = require('./_meta').getWeak;
1895var anObject = require('./_an-object');
1896var isObject = require('./_is-object');
1897var anInstance = require('./_an-instance');
1898var forOf = require('./_for-of');
1899var createArrayMethod = require('./_array-methods');
1900var $has = require('./_has');
1901var validate = require('./_validate-collection');
1902var arrayFind = createArrayMethod(5);
1903var arrayFindIndex = createArrayMethod(6);
1904var id = 0;
1905
1906// fallback for uncaught frozen keys
1907var uncaughtFrozenStore = function (that) {
1908  return that._l || (that._l = new UncaughtFrozenStore());
1909};
1910var UncaughtFrozenStore = function () {
1911  this.a = [];
1912};
1913var findUncaughtFrozen = function (store, key) {
1914  return arrayFind(store.a, function (it) {
1915    return it[0] === key;
1916  });
1917};
1918UncaughtFrozenStore.prototype = {
1919  get: function (key) {
1920    var entry = findUncaughtFrozen(this, key);
1921    if (entry) return entry[1];
1922  },
1923  has: function (key) {
1924    return !!findUncaughtFrozen(this, key);
1925  },
1926  set: function (key, value) {
1927    var entry = findUncaughtFrozen(this, key);
1928    if (entry) entry[1] = value;
1929    else this.a.push([key, value]);
1930  },
1931  'delete': function (key) {
1932    var index = arrayFindIndex(this.a, function (it) {
1933      return it[0] === key;
1934    });
1935    if (~index) this.a.splice(index, 1);
1936    return !!~index;
1937  }
1938};
1939
1940module.exports = {
1941  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
1942    var C = wrapper(function (that, iterable) {
1943      anInstance(that, C, NAME, '_i');
1944      that._t = NAME;      // collection type
1945      that._i = id++;      // collection id
1946      that._l = undefined; // leak store for uncaught frozen objects
1947      if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
1948    });
1949    redefineAll(C.prototype, {
1950      // 23.3.3.2 WeakMap.prototype.delete(key)
1951      // 23.4.3.3 WeakSet.prototype.delete(value)
1952      'delete': function (key) {
1953        if (!isObject(key)) return false;

1954        var data = getWeak(key);
1955        if (data === true) return uncaughtFrozenStore(validate(this, NAME))['delete'](key);
1956        return data && $has(data, this._i) && delete data[this._i];
1957      },
1958      // 23.3.3.4 WeakMap.prototype.has(key)
1959      // 23.4.3.4 WeakSet.prototype.has(value)
1960      has: function has(key) {
1961        if (!isObject(key)) return false;
1962        var data = getWeak(key);
1963        if (data === true) return uncaughtFrozenStore(validate(this, NAME)).has(key);
1964        return data && $has(data, this._i);
1965      }
1966    });
1967    return C;
1968  },
1969  def: function (that, key, value) {
1970    var data = getWeak(anObject(key), true);
1971    if (data === true) uncaughtFrozenStore(that).set(key, value);
1972    else data[that._i] = value;
1973    return that;
1974  },
1975  ufstore: uncaughtFrozenStore
1976};
1977
1978},{"./_an-instance":12,"./_an-object":13,"./_array-methods":18,"./_for-of":45,"./_has":48,"./_is-object":58,"./_meta":72,"./_redefine-all":97,"./_validate-collection":132}],28:[function(require,module,exports){
1979'use strict';
1980var global = require('./_global');
1981var $export = require('./_export');
1982var redefine = require('./_redefine');
1983var redefineAll = require('./_redefine-all');
1984var meta = require('./_meta');
1985var forOf = require('./_for-of');
1986var anInstance = require('./_an-instance');
1987var isObject = require('./_is-object');
1988var fails = require('./_fails');
1989var $iterDetect = require('./_iter-detect');
1990var setToStringTag = require('./_set-to-string-tag');
1991var inheritIfRequired = require('./_inherit-if-required');
1992
1993module.exports = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {
1994  var Base = global[NAME];
1995  var C = Base;
1996  var ADDER = IS_MAP ? 'set' : 'add';
1997  var proto = C && C.prototype;
1998  var O = {};
1999  var fixMethod = function (KEY) {
2000    var fn = proto[KEY];
2001    redefine(proto, KEY,
2002      KEY == 'delete' ? function (a) {
2003        return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
2004      } : KEY == 'has' ? function has(a) {
2005        return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
2006      } : KEY == 'get' ? function get(a) {
2007        return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);
2008      } : KEY == 'add' ? function add(a) { fn.call(this, a === 0 ? 0 : a); return this; }
2009        : function set(a, b) { fn.call(this, a === 0 ? 0 : a, b); return this; }
2010    );
2011  };
2012  if (typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function () {
2013    new C().entries().next();
2014  }))) {
2015    // create collection constructor
2016    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
2017    redefineAll(C.prototype, methods);
2018    meta.NEED = true;
2019  } else {
2020    var instance = new C();
2021    // early implementations not supports chaining
2022    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
2023    // V8 ~  Chromium 40- weak-collections throws on primitives, but should return false
2024    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });
2025    // most early implementations doesn't supports iterables, most modern - not close it correctly
2026    var ACCEPT_ITERABLES = $iterDetect(function (iter) { new C(iter); }); // eslint-disable-line no-new
2027    // for early implementations -0 and +0 not the same
2028    var BUGGY_ZERO = !IS_WEAK && fails(function () {
2029      // V8 ~ Chromium 42- fails only with 5+ elements
2030      var $instance = new C();
2031      var index = 5;
2032      while (index--) $instance[ADDER](index, index);
2033      return !$instance.has(-0);
2034    });
2035    if (!ACCEPT_ITERABLES) {
2036      C = wrapper(function (target, iterable) {
2037        anInstance(target, C, NAME);
2038        var that = inheritIfRequired(new Base(), target, C);
2039        if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
2040        return that;
2041      });
2042      C.prototype = proto;
2043      proto.constructor = C;
2044    }
2045    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
2046      fixMethod('delete');
2047      fixMethod('has');
2048      IS_MAP && fixMethod('get');
2049    }
2050    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);
2051    // weak collections should not contains .clear method
2052    if (IS_WEAK && proto.clear) delete proto.clear;
2053  }
2054
2055  setToStringTag(C, NAME);
2056
2057  O[NAME] = C;
2058  $export($export.G + $export.W + $export.F * (C != Base), O);
2059
2060  if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);
2061
2062  return C;
2063};
2064
2065},{"./_an-instance":12,"./_export":39,"./_fails":41,"./_for-of":45,"./_global":47,"./_inherit-if-required":52,"./_is-object":58,"./_iter-detect":63,"./_meta":72,"./_redefine":98,"./_redefine-all":97,"./_set-to-string-tag":107}],29:[function(require,module,exports){
2066var core = module.exports = { version: '2.6.12' };
2067if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
2068
2069},{}],30:[function(require,module,exports){
2070'use strict';
2071var $defineProperty = require('./_object-dp');
2072var createDesc = require('./_property-desc');
2073
2074module.exports = function (object, index, value) {
2075  if (index in object) $defineProperty.f(object, index, createDesc(0, value));
2076  else object[index] = value;
2077};
2078
2079},{"./_object-dp":78,"./_property-desc":96}],31:[function(require,module,exports){
2080// optional / simple context binding
2081var aFunction = require('./_a-function');
2082module.exports = function (fn, that, length) {
2083  aFunction(fn);
2084  if (that === undefined) return fn;
2085  switch (length) {
2086    case 1: return function (a) {
2087      return fn.call(that, a);
2088    };
2089    case 2: return function (a, b) {
2090      return fn.call(that, a, b);
2091    };
2092    case 3: return function (a, b, c) {
2093      return fn.call(that, a, b, c);
2094    };
2095  }
2096  return function (/* ...args */) {
2097    return fn.apply(that, arguments);
2098  };
2099};
2100
2101},{"./_a-function":8}],32:[function(require,module,exports){
2102'use strict';
2103// 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString()
2104var fails = require('./_fails');
2105var getTime = Date.prototype.getTime;
2106var $toISOString = Date.prototype.toISOString;
2107
2108var lz = function (num) {
2109  return num > 9 ? num : '0' + num;
2110};
2111
2112// PhantomJS / old WebKit has a broken implementations
2113module.exports = (fails(function () {
2114  return $toISOString.call(new Date(-5e13 - 1)) != '0385-07-25T07:06:39.999Z';
2115}) || !fails(function () {
2116  $toISOString.call(new Date(NaN));
2117})) ? function toISOString() {
2118  if (!isFinite(getTime.call(this))) throw RangeError('Invalid time value');
2119  var d = this;
2120  var y = d.getUTCFullYear();
2121  var m = d.getUTCMilliseconds();
2122  var s = y < 0 ? '-' : y > 9999 ? '+' : '';
2123  return s + ('00000' + Math.abs(y)).slice(s ? -6 : -4) +
2124    '-' + lz(d.getUTCMonth() + 1) + '-' + lz(d.getUTCDate()) +
2125    'T' + lz(d.getUTCHours()) + ':' + lz(d.getUTCMinutes()) +
2126    ':' + lz(d.getUTCSeconds()) + '.' + (m > 99 ? m : '0' + lz(m)) + 'Z';
2127} : $toISOString;
2128
2129},{"./_fails":41}],33:[function(require,module,exports){
2130'use strict';
2131var anObject = require('./_an-object');
2132var toPrimitive = require('./_to-primitive');
2133var NUMBER = 'number';
2134
2135module.exports = function (hint) {
2136  if (hint !== 'string' && hint !== NUMBER && hint !== 'default') throw TypeError('Incorrect hint');
2137  return toPrimitive(anObject(this), hint != NUMBER);
2138};
2139
2140},{"./_an-object":13,"./_to-primitive":126}],34:[function(require,module,exports){
2141// 7.2.1 RequireObjectCoercible(argument)
2142module.exports = function (it) {
2143  if (it == undefined) throw TypeError("Can't call method on  " + it);
2144  return it;
2145};
2146
2147},{}],35:[function(require,module,exports){
2148// Thank's IE8 for his funny defineProperty
2149module.exports = !require('./_fails')(function () {
2150  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
2151});
2152
2153},{"./_fails":41}],36:[function(require,module,exports){
2154var isObject = require('./_is-object');
2155var document = require('./_global').document;
2156// typeof document.createElement is 'object' in old IE
2157var is = isObject(document) && isObject(document.createElement);
2158module.exports = function (it) {
2159  return is ? document.createElement(it) : {};
2160};
2161
2162},{"./_global":47,"./_is-object":58}],37:[function(require,module,exports){
2163// IE 8- don't enum bug keys
2164module.exports = (
2165  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
2166).split(',');
2167
2168},{}],38:[function(require,module,exports){
2169// all enumerable object keys, includes symbols
2170var getKeys = require('./_object-keys');
2171var gOPS = require('./_object-gops');
2172var pIE = require('./_object-pie');
2173module.exports = function (it) {
2174  var result = getKeys(it);
2175  var getSymbols = gOPS.f;
2176  if (getSymbols) {
2177    var symbols = getSymbols(it);
2178    var isEnum = pIE.f;
2179    var i = 0;
2180    var key;
2181    while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key);
2182  } return result;
2183};
2184
2185},{"./_object-gops":84,"./_object-keys":87,"./_object-pie":88}],39:[function(require,module,exports){
2186var global = require('./_global');
2187var core = require('./_core');
2188var hide = require('./_hide');
2189var redefine = require('./_redefine');
2190var ctx = require('./_ctx');
2191var PROTOTYPE = 'prototype';
2192
2193var $export = function (type, name, source) {
2194  var IS_FORCED = type & $export.F;
2195  var IS_GLOBAL = type & $export.G;
2196  var IS_STATIC = type & $export.S;
2197  var IS_PROTO = type & $export.P;
2198  var IS_BIND = type & $export.B;
2199  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];
2200  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
2201  var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
2202  var key, own, out, exp;
2203  if (IS_GLOBAL) source = name;
2204  for (key in source) {
2205    // contains in native
2206    own = !IS_FORCED && target && target[key] !== undefined;
2207    // export native or passed
2208    out = (own ? target : source)[key];
2209    // bind timers to global for call from export context
2210    exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
2211    // extend global
2212    if (target) redefine(target, key, out, type & $export.U);
2213    // export
2214    if (exports[key] != out) hide(exports, key, exp);
2215    if (IS_PROTO && expProto[key] != out) expProto[key] = out;
2216  }
2217};
2218global.core = core;
2219// type bitmap
2220$export.F = 1;   // forced
2221$export.G = 2;   // global
2222$export.S = 4;   // static
2223$export.P = 8;   // proto
2224$export.B = 16;  // bind
2225$export.W = 32;  // wrap
2226$export.U = 64;  // safe
2227$export.R = 128; // real proto method for `library`
2228module.exports = $export;
2229
2230},{"./_core":29,"./_ctx":31,"./_global":47,"./_hide":49,"./_redefine":98}],40:[function(require,module,exports){
2231var MATCH = require('./_wks')('match');
2232module.exports = function (KEY) {
2233  var re = /./;
2234  try {
2235    '/./'[KEY](re);
2236  } catch (e) {
2237    try {
2238      re[MATCH] = false;
2239      return !'/./'[KEY](re);
2240    } catch (f) { /* empty */ }
2241  } return true;
2242};
2243
2244},{"./_wks":135}],41:[function(require,module,exports){
2245module.exports = function (exec) {
2246  try {
2247    return !!exec();
2248  } catch (e) {
2249    return true;
2250  }
2251};
2252
2253},{}],42:[function(require,module,exports){
2254'use strict';
2255require('./es6.regexp.exec');
2256var redefine = require('./_redefine');
2257var hide = require('./_hide');
2258var fails = require('./_fails');
2259var defined = require('./_defined');
2260var wks = require('./_wks');
2261var regexpExec = require('./_regexp-exec');
2262
2263var SPECIES = wks('species');
2264
2265var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
2266  // #replace needs built-in support for named groups.
2267  // #match works fine because it just return the exec results, even if it has
2268  // a "grops" property.
2269  var re = /./;
2270  re.exec = function () {
2271    var result = [];
2272    result.groups = { a: '7' };
2273    return result;
2274  };
2275  return ''.replace(re, '$<a>') !== '7';
2276});
2277
2278var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = (function () {
2279  // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
2280  var re = /(?:)/;
2281  var originalExec = re.exec;
2282  re.exec = function () { return originalExec.apply(this, arguments); };
2283  var result = 'ab'.split(re);
2284  return result.length === 2 && result[0] === 'a' && result[1] === 'b';
2285})();
2286
2287module.exports = function (KEY, length, exec) {
2288  var SYMBOL = wks(KEY);
2289
2290  var DELEGATES_TO_SYMBOL = !fails(function () {
2291    // String methods call symbol-named RegEp methods
2292    var O = {};
2293    O[SYMBOL] = function () { return 7; };
2294    return ''[KEY](O) != 7;
2295  });
2296
2297  var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL ? !fails(function () {
2298    // Symbol-named RegExp methods call .exec
2299    var execCalled = false;
2300    var re = /a/;
2301    re.exec = function () { execCalled = true; return null; };
2302    if (KEY === 'split') {
2303      // RegExp[@@split] doesn't call the regex's exec method, but first creates
2304      // a new one. We need to return the patched regex when creating the new one.
2305      re.constructor = {};
2306      re.constructor[SPECIES] = function () { return re; };
2307    }
2308    re[SYMBOL]('');
2309    return !execCalled;
2310  }) : undefined;
2311
2312  if (
2313    !DELEGATES_TO_SYMBOL ||
2314    !DELEGATES_TO_EXEC ||
2315    (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) ||
2316    (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)
2317  ) {
2318    var nativeRegExpMethod = /./[SYMBOL];
2319    var fns = exec(
2320      defined,
2321      SYMBOL,
2322      ''[KEY],
2323      function maybeCallNative(nativeMethod, regexp, str, arg2, forceStringMethod) {
2324        if (regexp.exec === regexpExec) {
2325          if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
2326            // The native String method already delegates to @@method (this
2327            // polyfilled function), leasing to infinite recursion.
2328            // We avoid it by directly calling the native @@method method.
2329            return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) };
2330          }
2331          return { done: true, value: nativeMethod.call(str, regexp, arg2) };
2332        }
2333        return { done: false };
2334      }
2335    );
2336    var strfn = fns[0];
2337    var rxfn = fns[1];
2338
2339    redefine(String.prototype, KEY, strfn);
2340    hide(RegExp.prototype, SYMBOL, length == 2
2341      // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)
2342      // 21.2.5.11 RegExp.prototype[@@split](string, limit)
2343      ? function (string, arg) { return rxfn.call(string, this, arg); }
2344      // 21.2.5.6 RegExp.prototype[@@match](string)
2345      // 21.2.5.9 RegExp.prototype[@@search](string)
2346      : function (string) { return rxfn.call(string, this); }
2347    );
2348  }
2349};
2350
2351},{"./_defined":34,"./_fails":41,"./_hide":49,"./_redefine":98,"./_regexp-exec":100,"./_wks":135,"./es6.regexp.exec":232}],43:[function(require,module,exports){
2352'use strict';
2353// 21.2.5.3 get RegExp.prototype.flags
2354var anObject = require('./_an-object');
2355module.exports = function () {
2356  var that = anObject(this);
2357  var result = '';
2358  if (that.global) result += 'g';
2359  if (that.ignoreCase) result += 'i';
2360  if (that.multiline) result += 'm';
2361  if (that.unicode) result += 'u';
2362  if (that.sticky) result += 'y';
2363  return result;
2364};
2365
2366},{"./_an-object":13}],44:[function(require,module,exports){
2367'use strict';
2368// https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray
2369var isArray = require('./_is-array');
2370var isObject = require('./_is-object');
2371var toLength = require('./_to-length');
2372var ctx = require('./_ctx');
2373var IS_CONCAT_SPREADABLE = require('./_wks')('isConcatSpreadable');
2374
2375function flattenIntoArray(target, original, source, sourceLen, start, depth, mapper, thisArg) {
2376  var targetIndex = start;
2377  var sourceIndex = 0;
2378  var mapFn = mapper ? ctx(mapper, thisArg, 3) : false;
2379  var element, spreadable;
2380
2381  while (sourceIndex < sourceLen) {
2382    if (sourceIndex in source) {
2383      element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];
2384
2385      spreadable = false;
2386      if (isObject(element)) {
2387        spreadable = element[IS_CONCAT_SPREADABLE];
2388        spreadable = spreadable !== undefined ? !!spreadable : isArray(element);
2389      }
2390
2391      if (spreadable && depth > 0) {
2392        targetIndex = flattenIntoArray(target, original, element, toLength(element.length), targetIndex, depth - 1) - 1;
2393      } else {
2394        if (targetIndex >= 0x1fffffffffffff) throw TypeError();
2395        target[targetIndex] = element;
2396      }
2397
2398      targetIndex++;
2399    }
2400    sourceIndex++;
2401  }
2402  return targetIndex;
2403}
2404
2405module.exports = flattenIntoArray;
2406
2407},{"./_ctx":31,"./_is-array":56,"./_is-object":58,"./_to-length":124,"./_wks":135}],45:[function(require,module,exports){
2408var ctx = require('./_ctx');
2409var call = require('./_iter-call');
2410var isArrayIter = require('./_is-array-iter');
2411var anObject = require('./_an-object');
2412var toLength = require('./_to-length');
2413var getIterFn = require('./core.get-iterator-method');
2414var BREAK = {};
2415var RETURN = {};
2416var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
2417  var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);
2418  var f = ctx(fn, that, entries ? 2 : 1);
2419  var index = 0;
2420  var length, step, iterator, result;
2421  if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
2422  // fast case for arrays with default iterator
2423  if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {
2424    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
2425    if (result === BREAK || result === RETURN) return result;
2426  } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
2427    result = call(iterator, f, step.value, entries);
2428    if (result === BREAK || result === RETURN) return result;
2429  }
2430};
2431exports.BREAK = BREAK;
2432exports.RETURN = RETURN;
2433
2434},{"./_an-object":13,"./_ctx":31,"./_is-array-iter":55,"./_iter-call":60,"./_to-length":124,"./core.get-iterator-method":136}],46:[function(require,module,exports){
2435module.exports = require('./_shared')('native-function-to-string', Function.toString);
2436
2437},{"./_shared":109}],47:[function(require,module,exports){
2438// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
2439var global = module.exports = typeof window != 'undefined' && window.Math == Math
2440  ? window : typeof self != 'undefined' && self.Math == Math ? self
2441  // eslint-disable-next-line no-new-func
2442  : Function('return this')();
2443if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
2444
2445},{}],48:[function(require,module,exports){
2446var hasOwnProperty = {}.hasOwnProperty;
2447module.exports = function (it, key) {
2448  return hasOwnProperty.call(it, key);
2449};
2450
2451},{}],49:[function(require,module,exports){
2452var dP = require('./_object-dp');
2453var createDesc = require('./_property-desc');
2454module.exports = require('./_descriptors') ? function (object, key, value) {
2455  return dP.f(object, key, createDesc(1, value));
2456} : function (object, key, value) {
2457  object[key] = value;
2458  return object;
2459};
2460
2461}

2579var $export = require('./_export');
2580var redefine = require('./_redefine');
2581var hide = require('./_hide');
2582var Iterators = require('./_iterators');
2583var $iterCreate = require('./_iter-create');
2584var setToStringTag = require('./_set-to-string-tag');
2585var getPrototypeOf = require('./_object-gpo');
2586var ITERATOR = require('./_wks')('iterator');
2587var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
2588var FF_ITERATOR = '@@iterator';
2589var KEYS = 'keys';
2590var VALUES = 'values';
2591
2592var returnThis = function () { return this; };
2593
2594module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
2595  $iterCreate(Constructor, NAME, next);
2596  var getMethod = function (kind) {
2597    if (!BUGGY && kind in proto) return proto[kind];
2598    switch (kind) {
2599      case KEYS: return function keys() { return new Constructor(this, kind); };
2600      case VALUES: return function values() { return new Constructor(this, kind); };
2601    } return function entries() { return new Constructor(this, kind); };
2602  };
2603  var TAG = NAME + ' Iterator';
2604  var DEF_VALUES = DEFAULT == VALUES;
2605  var VALUES_BUG = false;
2606  var proto = Base.prototype;
2607  var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
2608  var $default = $native || getMethod(DEFAULT);
2609  var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
2610  var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
2611  var methods, key, IteratorPrototype;
2612  // Fix native
2613  if ($anyNative) {
2614    IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
2615    if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
2616      // Set @@toStringTag to native iterators
2617      setToStringTag(IteratorPrototype, TAG, true);
2618      // fix for some old engines
2619      if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);
2620    }
2621  }
2622  // fix Array#{values, @@iterator}.name in V8 / FF
2623  if (DEF_VALUES && $native && $native.name !== VALUES) {
2624    VALUES_BUG = true;
2625    $default = function values() { return $native.call(this); };
2626  }
2627  // Define iterator
2628  if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
2629    hide(proto, ITERATOR, $default);
2630  }
2631  // Plug for library
2632  Iterators[NAME] = $default;
2633  Iterators[TAG] = returnThis;
2634  if (DEFAULT) {
2635    methods = {
2636      values: DEF_VALUES ? $default : getMethod(VALUES),
2637      keys: IS_SET ? $default : getMethod(KEYS),
2638      entries: $entries
2639    };
2640    if (FORCED) for (key in methods) {
2641      if (!(key in proto)) redefine(proto, key, methods[key]);
2642    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
2643  }
2644  return methods;
2645};
2646
2647},{"./_export":39,"./_hide":49,"./_iter-create":61,"./_iterators":65,"./_library":66,"./_object-gpo":85,"./_redefine":98,"./_set-to-string-tag":107,"./_wks":135}],63:[function(require,module,exports){
2648var ITERATOR = require('./_wks')('iterator');
2649var SAFE_CLOSING = false;
2650
2651try {
2652  var riter = [7][ITERATOR]();
2653  riter['return'] = function () { SAFE_CLOSING = true; };
2654  // eslint-disable-next-line no-throw-literal
2655  Array.from(riter, function () { throw 2; });
2656} catch (e) { /* empty */ }
2657
2658module.exports = function (exec, skipClosing) {
2659  if (!skipClosing && !SAFE_CLOSING) return false;
2660  var safe = false;
2661  try {
2662    var arr = [7];
2663    var iter = arr[ITERATOR]();
2664    iter.next = function () { return { done: safe = true }; };
2665    arr[ITERATOR] = function () { return iter; };
2666    exec(arr);
2667  } catch (e) { /* empty */ }
2668  return safe;
2669};
2670
2671},{"./_wks":135}],64:[function(require,module,exports){
2672module.exports = function (done, value) {
2673  return { value: value, done: !!done };
2674};
2675
2676},{}],65:[function(require,module,exports){
2677module.exports = {};
2678
2679},{}],66:[function(require,module,exports){
2680module.exports = false;
2681
2682},{}],67:[function(require,module,exports){
2683// 20.2.2.14 Math.expm1(x)
2684var $expm1 = Math.expm1;
2685module.exports = (!$expm1
2686  // Old FF bug
2687  || $expm1(10) > 22025.465794806719 || $expm1(10) < 22025.4657948067165168
2688  // Tor Browser bug
2689  || $expm1(-2e-17) != -2e-17
2690) ? function expm1(x) {
2691  return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1;
2692} : $expm1;
2693
2694},{}],68:[function(require,module,exports){
2695// 20.2.2.16 Math.fround(x)
2696var sign = require('./_math-sign');
2697var pow = Math.pow;
2698var EPSILON = pow(2, -52);
2699var EPSILON32 = pow(2, -23);
2700var MAX32 = pow(2, 127) * (2 - EPSILON32);
2701var MIN32 = pow(2, -126);
2702