{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./app/javascript/packs/shims.js","webpack:///./app/javascript/shims/index.js","webpack:///./node_modules/es5-shim/es5-shim.js","webpack:///./node_modules/es6-shim/es6-shim.js","webpack:///./node_modules/process/browser.js","webpack:///(webpack)/buildin/global.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","require","_typeof","iterator","obj","constructor","root","factory","isRegex","isString","$Array","Array","ArrayPrototype","$Object","ObjectPrototype","$Function","Function","FunctionPrototype","$String","String","StringPrototype","$Number","Number","NumberPrototype","array_slice","slice","array_splice","splice","array_push","push","array_unshift","unshift","array_concat","concat","array_join","join","apply","max","Math","min","to_string","toString","hasToStringTag","fnToStr","constructorRegex","isES6ClassFn","spaceStripped","replace","test","e","tryFunctionObject","fnClass","genClass","isCallable","strClass","regexExec","RegExp","exec","tryRegexExec","regexClass","strValue","valueOf","tryStringObject","stringClass","supportsDescriptors","_","x","defineProperties","has","method","forceAssign","configurable","writable","map","isPrimitive","input","type","isActualNaN","isNaN","ES","ToInteger","num","floor","abs","ToPrimitive","val","toStr","TypeError","ToObject","ToUint32","Empty","that","target","this","bound","args","arguments","binder","result","boundLength","length","boundArgs","owns","arraySlice","arraySliceApply","document","documentElement","childNodes","origArraySlice","origArraySliceApply","arr","strSlice","strSplit","split","strIndexOf","indexOf","pushCall","isEnum","propertyIsEnumerable","arraySort","sort","isArray","hasUnshiftReturnValueBug","boxedString","splitString","properlyBoxesContext","properlyBoxesNonStrict","properlyBoxesStrict","threwException","__","context","forEach","callbackfn","T","self","filter","every","some","reduceCoercesToObject","reduce","___","list","reduceRightCoercesToObject","reduceRight","hasFirefox2IndexOfBug","searchElement","hasFirefox2LastIndexOfBug","lastIndexOf","spliceNoopReturnsEmptyArray","a","start","deleteCount","spliceWorksWithEmptyObject","spliceWorksWithLargeSparseArrays","spliceWorksWithSmallSparseArrays","from","O","A","len","relativeStart","actualStart","actualDeleteCount","k","to","items","itemCount","maxK","minK","hasStringJoinBug","originalJoin","separator","sep","hasJoinUndefinedBug","undefined","pushShim","item","pushIsNotGeneric","pushUndefinedIsWeird","end","sortIgnoresNonFunctions","e2","sortThrowsOnRegex","sortIgnoresUndefined","compareFn","hasDontEnumBug","hasProtoEnumBug","hasStringEnumBug","equalsConstructorPrototype","ctor","excludedKeys","$applicationCache","$console","$external","$frame","$frameElement","$frames","$innerHeight","$innerWidth","$onmozfullscreenchange","$onmozfullscreenerror","$outerHeight","$outerWidth","$pageXOffset","$pageYOffset","$parent","$scrollLeft","$scrollTop","$scrollX","$scrollY","$self","$webkitIndexedDB","$webkitStorageInfo","$window","$width","$height","$top","$localStorage","hasAutomationEqualityBug","window","equalsConstructorPrototypeIfNotBuggy","dontEnums","dontEnumsLength","isStandardArguments","isLegacyArguments","callee","isArguments","keys","isFn","isArgs","isObject","isStr","theKeys","skipProto","skipConstructor","j","dontEnum","keysWorksWithArguments","keysHasArgumentsLengthBug","argKeys","originalKeys","hasToDateStringFormatBug","hasToStringFormatBug","hasNegativeMonthYearBug","Date","getUTCMonth","aNegativeTestDate","aPositiveTestDate","hasToUTCStringFormatBug","toUTCString","timeZoneOffset","getTimezoneOffset","toDateString","originalGetFullYear","getFullYear","originalGetMonth","getMonth","originalGetDate","getDate","originalGetUTCFullYear","getUTCFullYear","originalGetUTCMonth","originalGetUTCDate","getUTCDate","originalGetUTCDay","getUTCDay","originalGetUTCHours","getUTCHours","originalGetUTCMinutes","getUTCMinutes","originalGetUTCSeconds","getUTCSeconds","originalGetUTCMilliseconds","getUTCMilliseconds","dayName","monthName","daysInMonth","month","year","date","day","hour","minute","second","getDay","getHours","getMinutes","getSeconds","timezoneOffset","hoursOffset","minutesOffset","negativeDate","negativeYearString","hasNegativeDateBug","toISOString","hasSafari51DateBug","getTime","isFinite","RangeError","dateToJSONIsSupported","toJSON","NaN","tv","toISO","supportsExtendedYears","parse","acceptsInvalidDates","doesNotParseY2KNewYear","maxSafeUnsigned32Bit","pow","hasSafariSignedIntBug","NativeDate","DateShim","Y","M","D","h","ms","seconds","millis","msToShift","sToShift","isoDateExpression","months","dayFromMonth","toUTC","now","UTC","string","match","millisecond","isLocalTime","Boolean","signOffset","hourOffset","minuteOffset","hasMinutesOrSecondsOrMilliseconds","hasToFixedBugs","toFixed","toFixedHelpers","base","size","data","multiply","c2","divide","numToString","acc","log","x2","toFixedShim","fractionDigits","f","z","hasToPrecisionUndefinedBug","toPrecision","originalToPrecision","precision","compliantExecNpcg","maxSafe32BitInt","limit","separator2","lastIndex","lastLength","output","flags","ignoreCase","multiline","unicode","sticky","lastLastIndex","separatorCopy","source","splitLimit","index","str_replace","replaceReportsGroupsCorrectly","groups","group","searchValue","replaceValue","hasCapturingGroups","originalLastIndex","string_substr","substr","hasNegativeSubstrBug","normalizedStart","ws","zeroWidth","wsRegexChars","trimBeginRegexp","trimEndRegexp","hasTrimWhitespaceBug","trim","hasLastIndexBug","searchString","S","searchStr","numPos","pos","Infinity","searchLen","originalLastIndexOf","parseInt","origParseInt","hexRegex","str","radix","defaultedRadix","parseFloat","origParseFloat","inputString","errorToStringShim","msg","message","Error","ensureNonEnumerable","prop","desc","getOwnPropertyDescriptor","regexToString","global","ArrayIterator","_apply","_call","not","func","throwsError","valueOrFalseIfThrows","isCallableWithoutNew","arePropertyDescriptorsSupported","functionsHaveNames","_forEach","_reduce","_filter","_some","force","forceOverride","_toString","Value","_getter","proxy","originalObject","targetObject","originalDescriptor","set","redefine","newValue","descriptor","defineByDescriptor","preserveToString","properties","Prototype","supportsSubclassing","C","setPrototypeOf","Sub","Subclass","arg","getGlobal","globals","globalIsFinite","_indexOf","_arrayIndexOfApply","_concat","_strSlice","_push","_pushApply","_shift","shift","_max","_min","_floor","_abs","_exp","exp","_log","_sqrt","sqrt","_hasOwnProperty","noop","OrigMap","Map","origMapDelete","origMapGet","origMapHas","origMapSet","_Symbol","symbolSpecies","species","numberIsNaN","numberIsFinite","_sign","sign","number","_log1p","Type","primitive","regex","symbol","overrideNative","replacement","original","hasSymbols","$iterator$","Set","Reflect","domAll","all","isNullOrUndefined","Call","F","V","IsCallable","RequireObjectCoercible","optMessage","TypeIsObject","IsConstructor","ToInt32","ToNumber","ToLength","MAX_SAFE_INTEGER","SameValue","b","SameValueZero","IsIterable","GetIterator","itFn","GetMethod","it","IteratorComplete","iterResult","done","IteratorClose","completionIsThrow","returnMethod","innerResult","innerException","IteratorNext","next","IteratorStep","Construct","newTarget","isES6internal","construct","proto","SpeciesConstructor","defaultConstructor","CreateHTML","tag","attribute","ToString","p1","IsRegExp","argument","isRegExp","defineWellKnownSymbol","sym","search","symbolSearch","originalSearch","searchShim","regexp","searcher","symbolReplace","originalReplace","replaceShim","replacer","symbolSplit","originalSplit","splitShim","splitter","symbolMatchExists","stringMatchIgnoresSymbolMatch","symbolMatch","originalMatch","matchShim","matcher","wrapConstructor","keysToSkip","getOwnPropertyNames","defaultSpeciesGetter","addDefaultSpecies","addIterator","impl","implementation","createDataProperty","createDataPropertyOrThrow","emulateES6construct","defaultNewTarget","defaultProto","slots","fromCodePoint","originalFromCodePoint","codePoints","StringShims","fromCharCode","raw","callSite","cooked","rawString","literalsegments","nextKey","nextSeg","nextSub","stringElements","nextIndex","0","1","stringRepeat","repeat","times","half","stringMaxLength","StringPrototypeShims","thisStr","numTimes","startsWith","position","endsWith","endPosition","includes","codePointAt","first","charCodeAt","startsWithRejectsRegex","startsWithHandlesInfinity","startsWithSupportsSymbolMatch","re","endsWithSupportsSymbolMatch","includesSupportsSymbolMatch","trimRegexp","trimShim","nonWS","nonWSregex","isBadHexRegex","hasStringTrimBug","iteratorResult","StringIterator","_s","_i","ArrayShims","mapFn","mapping","usingIterator","nextValue","arrayLike","of","array","kind","retval","arrayOfSupportsSubclassing","Foo","fooArr","ArrayPrototypeShims","copyWithin","relativeTarget","relativeEnd","finalItem","count","direction","fill","find","predicate","thisArg","findIndex","values","entries","unscopables","originalArrayPrototypeValues","getPrototypeOf","arrayFromSwallowsNegativeLengths","arrayFromHandlesIterables","arrayFromHandlesUndefinedMapFunction","origArrayFrom","int32sAsOne","toLengthsCorrectly","reversed","originalForEach","callbackFn","originalMap","originalFilter","originalSome","originalEvery","originalReduce","originalReduceRight","lacksOctalSupport","lacksBinarySupport","trimsNonWhitespace","OrigNumber","binaryRegex","octalRegex","isBinary","isOctal","toPrimitive","hasNonWS","isBadHex","NumberShim","primValue","receiver","valueOfSucceeds","MAX_VALUE","MIN_VALUE","NEGATIVE_INFINITY","POSITIVE_INFINITY","maxSafeInteger","MIN_SAFE_INTEGER","EPSILON","isInteger","isSafeInteger","FAKENULL","gpo","spo","isEnumerableOn","ensureEnumerable","sliceArgs","initial","desiredArgCount","assignTo","assignReducer","symbols","sourceKeys","getOwnPropertySymbols","ObjectShims","assign","is","assignHasPendingExceptions","preventExtensions","thrower","ES5ObjectShims","magic","checkArgs","polyfill","objectKeysAcceptsPrimitives","originalObjectKeys","objectKeysRejectsRegex","regexRejectingObjectKeys","regexKeys","objectGOPNAcceptsPrimitives","cachedWindowNames","originalObjectGetOwnPropertyNames","objectGOPDAcceptsPrimitives","originalObjectGetOwnPropertyDescriptor","seal","objectSealAcceptsPrimitives","originalObjectSeal","isSealed","objectIsSealedAcceptsPrimitives","originalObjectIsSealed","freeze","objectFreezeAcceptsPrimitives","originalObjectFreeze","isFrozen","objectIsFrozenAcceptsPrimitives","originalObjectIsFrozen","objectPreventExtensionsAcceptsPrimitives","originalObjectPreventExtensions","isExtensible","objectIsExtensibleAcceptsPrimitives","originalObjectIsExtensible","objectGetProtoAcceptsPrimitives","originalGetProto","hasFlags","regExpFlagsGetter","regExpSupportsFlagsWithRegex","regExpNeedsToSupportSymbolMatch","regexToStringIsGeneric","regexToStringSupportsGenericFlags","origRegExpToString","R","flagsGetter","sourceDesc","legacySourceGetter","sourceGetter","OrigRegExp","RegExpShim","pattern","patternIsRegExp","$input","regexGlobals","lastMatch","lastParen","leftContext","rightContext","inverseEpsilon","roundTiesToEven","BINARY_32_EPSILON","BINARY_32_MAX_VALUE","BINARY_32_MIN_VALUE","E","LOG2E","LOG10E","numberCLZ","clz","MathShims","acosh","xInvSquared","halfX","asinh","aSquared","atanh","cbrt","negate","clz32","cosh","expm1","sum","hypot","y","largest","log2","log10","log1p","sinh","u","tanh","trunc","imul","al","bl","fround","v","withinULPDistance","expected","distance","expm1OfTen","origMathRound","round","roundHandlesBoundaryConditions","smallestPositiveNumberWhereRoundBreaks","largestPositiveNumberWhereRoundBreaks","roundDoesNotIncreaseIntegers","origImul","thenable","PromiseShim","setTimeout","IsPromise","promise","_promise","makeZeroTimeout","PromiseCapability","capability","resolve","reject","postMessage","timeouts","addEventListener","event","stopPropagation","fn","P","pr","Promise$prototype","Promise$prototype$then","enqueue","setImmediate","process","nextTick","Promise","task","then","PROMISE_IDENTITY","PROMISE_THROWER","PROMISE_FAKE_CAPABILITY","enqueuePromiseReactionJob","handler","promiseReactionJob","promiseCapability","handlerResult","fulfillPromise","reactionLength","fulfillReactionHandler0","reactionCapability0","rejectReactions0","idx","state","rejectPromise","reason","rejectReactionHandler0","createResolvingFunctions","alreadyResolved","resolution","promiseResolveThenableJob","optimizedThen","resolvingFunctions","resolver","_promiseAllResolver","remaining","alreadyCalled","iterable","iteratorRecord","resultCapability","nextPromise","resolveElement","performPromiseAll","exception","ee","race","performPromiseRace","rejectFunc","resolveFunc","onRejected","onFulfilled","returnValueIsIgnored","fulfillReactionHandler","rejectReactionHandler","accept","defer","chain","promiseSupportsSubclassing","promiseIgnoresNonFunctionThenCallbacks","promiseRequiresObjectContext","promiseResolveBroken","p2","getsThenSynchronously","BadResolverPromise","executor","hasBadResolverPromise","origAll","origRace","origResolve","origReject","testOrder","preservesInsertionOrder","preservesNumericInsertionOrder","fastkey","skipInsertionOrderCheck","emptyObject","addIterableToMap","MapConstructor","entry","iter","adder","nextItem","addIterableToSet","SetConstructor","add","collectionShims","empty","MapEntry","prev","isRemoved","Map$prototype","requireMapSlot","_es6map","isMap","MapIterator","head","_head","isMapIterator","MapShim","_map","_size","_storage","fkey","clear","callback","Set$prototype","requireSetSlot","_es6set","isSet","SetShim","ensureMap","charAt","decodeKey","hasFKey","SetIterator","entireSet","isSetIterator","isGoogleTranslate","remove","mapAcceptsArguments","testMap","mapUsesSameValueZero","mapSupportsChaining","testSet","setUsesSameValueZero","setSupportsChaining","origSetAdd","origSetHas","origSetDel","mapSupportsSubclassing","mapFailsToSupportSubclassing","mapRequiresNew","setSupportsSubclassing","setFailsToSupportSubclassing","setRequiresNew","OrigSet","newMap","mapIterationThrowsStopIterator","anonymousSetHas","throwUnlessTargetIsObject","ReflectShims","deleteProperty","ownKeys","callAndCatchException","internalGet","parent","internalSet","propertyKey","attributes","objectDotGetPrototypeOf","willCreateCircularPrototype","lastProto","defineOrOverrideReflectProperty","shim","originalReflectGetProto","basic","extensible","dateToString","shimmedDateToString","stringHTMLshims","anchor","big","blink","bold","fixed","fontcolor","color","fontsize","italics","link","url","small","strike","sub","sup","shouldOverwrite","quotesCount","toLowerCase","JSONstringifiesSymbols","stringify","JSON","JSONstringifyAcceptsObjectSymbol","origStringify","replaceFn","wrappedReplacer","parsedValue","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","g"],"mappings":"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","file":"js/shims-21df634cc64ea9a3c27e.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"https://d486qtqfb6csz.cloudfront.net/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 2185);\n","import '../shims';\n","require('es5-shim/es5-shim');\nrequire('es6-shim/es6-shim');\nrequire('core-js/es/array/includes');\n","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\n/*!\n * https://github.com/es-shims/es5-shim\n * @license es5-shim Copyright 2009-2015 by contributors, MIT License\n * see https://github.com/es-shims/es5-shim/blob/master/LICENSE\n */\n// vim: ts=4 sts=4 sw=4 expandtab\n// Add semicolon to prevent IIFE from being passed as argument to concatenated code.\n; // UMD (Universal Module Definition)\n// see https://github.com/umdjs/umd/blob/master/templates/returnExports.js\n\n(function (root, factory) {\n  'use strict';\n  /* global define, exports, module */\n\n  if (typeof define === 'function' && define.amd) {\n    // AMD. Register as an anonymous module.\n    define(factory);\n  } else if ((typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) === 'object') {\n    // Node. Does not work with strict CommonJS, but\n    // only CommonJS-like enviroments that support module.exports,\n    // like Node.\n    module.exports = factory();\n  } else {\n    // Browser globals (root is window)\n    root.returnExports = factory();\n  }\n})(this, function () {\n  /**\n   * Brings an environment as close to ECMAScript 5 compliance\n   * as is possible with the facilities of erstwhile engines.\n   *\n   * Annotated ES5: http://es5.github.com/ (specific links below)\n   * ES5 Spec: http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf\n   * Required reading: http://javascriptweblog.wordpress.com/2011/12/05/extending-javascript-natives/\n   */\n  // Shortcut to an often accessed properties, in order to avoid multiple\n  // dereference that costs universally. This also holds a reference to known-good\n  // functions.\n  var $Array = Array;\n  var ArrayPrototype = $Array.prototype;\n  var $Object = Object;\n  var ObjectPrototype = $Object.prototype;\n  var $Function = Function;\n  var FunctionPrototype = $Function.prototype;\n  var $String = String;\n  var StringPrototype = $String.prototype;\n  var $Number = Number;\n  var NumberPrototype = $Number.prototype;\n  var array_slice = ArrayPrototype.slice;\n  var array_splice = ArrayPrototype.splice;\n  var array_push = ArrayPrototype.push;\n  var array_unshift = ArrayPrototype.unshift;\n  var array_concat = ArrayPrototype.concat;\n  var array_join = ArrayPrototype.join;\n  var call = FunctionPrototype.call;\n  var apply = FunctionPrototype.apply;\n  var max = Math.max;\n  var min = Math.min; // Having a toString local variable name breaks in Opera so use to_string.\n\n  var to_string = ObjectPrototype.toString;\n  /* global Symbol */\n\n  /* eslint-disable one-var-declaration-per-line, no-redeclare, max-statements-per-line */\n\n  var hasToStringTag = typeof Symbol === 'function' && _typeof(Symbol.toStringTag) === 'symbol';\n  var isCallable;\n  /* inlined from https://npmjs.com/is-callable */\n\n  var fnToStr = Function.prototype.toString,\n      constructorRegex = /^\\s*class /,\n      isES6ClassFn = function isES6ClassFn(value) {\n    try {\n      var fnStr = fnToStr.call(value);\n      var singleStripped = fnStr.replace(/\\/\\/.*\\n/g, '');\n      var multiStripped = singleStripped.replace(/\\/\\*[.\\s\\S]*\\*\\//g, '');\n      var spaceStripped = multiStripped.replace(/\\n/mg, ' ').replace(/ {2}/g, ' ');\n      return constructorRegex.test(spaceStripped);\n    } catch (e) {\n      return false;\n      /* not a function */\n    }\n  },\n      tryFunctionObject = function tryFunctionObject(value) {\n    try {\n      if (isES6ClassFn(value)) {\n        return false;\n      }\n\n      fnToStr.call(value);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  },\n      fnClass = '[object Function]',\n      genClass = '[object GeneratorFunction]',\n      isCallable = function isCallable(value) {\n    if (!value) {\n      return false;\n    }\n\n    if (typeof value !== 'function' && _typeof(value) !== 'object') {\n      return false;\n    }\n\n    if (hasToStringTag) {\n      return tryFunctionObject(value);\n    }\n\n    if (isES6ClassFn(value)) {\n      return false;\n    }\n\n    var strClass = to_string.call(value);\n    return strClass === fnClass || strClass === genClass;\n  };\n\n  var isRegex;\n  /* inlined from https://npmjs.com/is-regex */\n\n  var regexExec = RegExp.prototype.exec,\n      tryRegexExec = function tryRegexExec(value) {\n    try {\n      regexExec.call(value);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  },\n      regexClass = '[object RegExp]';\n\n  isRegex = function isRegex(value) {\n    if (_typeof(value) !== 'object') {\n      return false;\n    }\n\n    return hasToStringTag ? tryRegexExec(value) : to_string.call(value) === regexClass;\n  };\n\n  var isString;\n  /* inlined from https://npmjs.com/is-string */\n\n  var strValue = String.prototype.valueOf,\n      tryStringObject = function tryStringObject(value) {\n    try {\n      strValue.call(value);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  },\n      stringClass = '[object String]';\n\n  isString = function isString(value) {\n    if (typeof value === 'string') {\n      return true;\n    }\n\n    if (_typeof(value) !== 'object') {\n      return false;\n    }\n\n    return hasToStringTag ? tryStringObject(value) : to_string.call(value) === stringClass;\n  };\n  /* eslint-enable one-var-declaration-per-line, no-redeclare, max-statements-per-line */\n\n  /* inlined from http://npmjs.com/define-properties */\n\n\n  var supportsDescriptors = $Object.defineProperty && function () {\n    try {\n      var obj = {};\n      $Object.defineProperty(obj, 'x', {\n        enumerable: false,\n        value: obj\n      });\n\n      for (var _ in obj) {\n        // jscs:ignore disallowUnusedVariables\n        return false;\n      }\n\n      return obj.x === obj;\n    } catch (e) {\n      /* this is ES3 */\n      return false;\n    }\n  }();\n\n  var defineProperties = function (has) {\n    // Define configurable, writable, and non-enumerable props\n    // if they don't exist.\n    var defineProperty;\n\n    if (supportsDescriptors) {\n      defineProperty = function defineProperty(object, name, method, forceAssign) {\n        if (!forceAssign && name in object) {\n          return;\n        }\n\n        $Object.defineProperty(object, name, {\n          configurable: true,\n          enumerable: false,\n          writable: true,\n          value: method\n        });\n      };\n    } else {\n      defineProperty = function defineProperty(object, name, method, forceAssign) {\n        if (!forceAssign && name in object) {\n          return;\n        }\n\n        object[name] = method;\n      };\n    }\n\n    return function defineProperties(object, map, forceAssign) {\n      for (var name in map) {\n        if (has.call(map, name)) {\n          defineProperty(object, name, map[name], forceAssign);\n        }\n      }\n    };\n  }(ObjectPrototype.hasOwnProperty); //\n  // Util\n  // ======\n  //\n\n  /* replaceable with https://npmjs.com/package/es-abstract /helpers/isPrimitive */\n\n\n  var isPrimitive = function isPrimitive(input) {\n    var type = _typeof(input);\n\n    return input === null || type !== 'object' && type !== 'function';\n  };\n\n  var isActualNaN = $Number.isNaN || function isActualNaN(x) {\n    return x !== x;\n  };\n\n  var ES = {\n    // ES5 9.4\n    // http://es5.github.com/#x9.4\n    // http://jsperf.com/to-integer\n\n    /* replaceable with https://npmjs.com/package/es-abstract ES5.ToInteger */\n    ToInteger: function ToInteger(num) {\n      var n = +num;\n\n      if (isActualNaN(n)) {\n        n = 0;\n      } else if (n !== 0 && n !== 1 / 0 && n !== -(1 / 0)) {\n        n = (n > 0 || -1) * Math.floor(Math.abs(n));\n      }\n\n      return n;\n    },\n\n    /* replaceable with https://npmjs.com/package/es-abstract ES5.ToPrimitive */\n    ToPrimitive: function ToPrimitive(input) {\n      var val, valueOf, toStr;\n\n      if (isPrimitive(input)) {\n        return input;\n      }\n\n      valueOf = input.valueOf;\n\n      if (isCallable(valueOf)) {\n        val = valueOf.call(input);\n\n        if (isPrimitive(val)) {\n          return val;\n        }\n      }\n\n      toStr = input.toString;\n\n      if (isCallable(toStr)) {\n        val = toStr.call(input);\n\n        if (isPrimitive(val)) {\n          return val;\n        }\n      }\n\n      throw new TypeError();\n    },\n    // ES5 9.9\n    // http://es5.github.com/#x9.9\n\n    /* replaceable with https://npmjs.com/package/es-abstract ES5.ToObject */\n    ToObject: function ToObject(o) {\n      if (o == null) {\n        // this matches both null and undefined\n        throw new TypeError(\"can't convert \" + o + ' to object');\n      }\n\n      return $Object(o);\n    },\n\n    /* replaceable with https://npmjs.com/package/es-abstract ES5.ToUint32 */\n    ToUint32: function ToUint32(x) {\n      return x >>> 0;\n    }\n  }; //\n  // Function\n  // ========\n  //\n  // ES-5 15.3.4.5\n  // http://es5.github.com/#x15.3.4.5\n\n  var Empty = function Empty() {};\n\n  defineProperties(FunctionPrototype, {\n    bind: function bind(that) {\n      // .length is 1\n      // 1. Let Target be the this value.\n      var target = this; // 2. If IsCallable(Target) is false, throw a TypeError exception.\n\n      if (!isCallable(target)) {\n        throw new TypeError('Function.prototype.bind called on incompatible ' + target);\n      } // 3. Let A be a new (possibly empty) internal list of all of the\n      //   argument values provided after thisArg (arg1, arg2 etc), in order.\n      // XXX slicedArgs will stand in for \"A\" if used\n\n\n      var args = array_slice.call(arguments, 1); // for normal call\n      // 4. Let F be a new native ECMAScript object.\n      // 11. Set the [[Prototype]] internal property of F to the standard\n      //   built-in Function prototype object as specified in 15.3.3.1.\n      // 12. Set the [[Call]] internal property of F as described in\n      //   15.3.4.5.1.\n      // 13. Set the [[Construct]] internal property of F as described in\n      //   15.3.4.5.2.\n      // 14. Set the [[HasInstance]] internal property of F as described in\n      //   15.3.4.5.3.\n\n      var bound;\n\n      var binder = function binder() {\n        if (this instanceof bound) {\n          // 15.3.4.5.2 [[Construct]]\n          // When the [[Construct]] internal method of a function object,\n          // F that was created using the bind function is called with a\n          // list of arguments ExtraArgs, the following steps are taken:\n          // 1. Let target be the value of F's [[TargetFunction]]\n          //   internal property.\n          // 2. If target has no [[Construct]] internal method, a\n          //   TypeError exception is thrown.\n          // 3. Let boundArgs be the value of F's [[BoundArgs]] internal\n          //   property.\n          // 4. Let args be a new list containing the same values as the\n          //   list boundArgs in the same order followed by the same\n          //   values as the list ExtraArgs in the same order.\n          // 5. Return the result of calling the [[Construct]] internal\n          //   method of target providing args as the arguments.\n          var result = apply.call(target, this, array_concat.call(args, array_slice.call(arguments)));\n\n          if ($Object(result) === result) {\n            return result;\n          }\n\n          return this;\n        } else {\n          // 15.3.4.5.1 [[Call]]\n          // When the [[Call]] internal method of a function object, F,\n          // which was created using the bind function is called with a\n          // this value and a list of arguments ExtraArgs, the following\n          // steps are taken:\n          // 1. Let boundArgs be the value of F's [[BoundArgs]] internal\n          //   property.\n          // 2. Let boundThis be the value of F's [[BoundThis]] internal\n          //   property.\n          // 3. Let target be the value of F's [[TargetFunction]] internal\n          //   property.\n          // 4. Let args be a new list containing the same values as the\n          //   list boundArgs in the same order followed by the same\n          //   values as the list ExtraArgs in the same order.\n          // 5. Return the result of calling the [[Call]] internal method\n          //   of target providing boundThis as the this value and\n          //   providing args as the arguments.\n          // equiv: target.call(this, ...boundArgs, ...args)\n          return apply.call(target, that, array_concat.call(args, array_slice.call(arguments)));\n        }\n      }; // 15. If the [[Class]] internal property of Target is \"Function\", then\n      //     a. Let L be the length property of Target minus the length of A.\n      //     b. Set the length own property of F to either 0 or L, whichever is\n      //       larger.\n      // 16. Else set the length own property of F to 0.\n\n\n      var boundLength = max(0, target.length - args.length); // 17. Set the attributes of the length own property of F to the values\n      //   specified in 15.3.5.1.\n\n      var boundArgs = [];\n\n      for (var i = 0; i < boundLength; i++) {\n        array_push.call(boundArgs, '$' + i);\n      } // XXX Build a dynamic function with desired amount of arguments is the only\n      // way to set the length property of a function.\n      // In environments where Content Security Policies enabled (Chrome extensions,\n      // for ex.) all use of eval or Function costructor throws an exception.\n      // However in all of these environments Function.prototype.bind exists\n      // and so this code will never be executed.\n\n\n      bound = $Function('binder', 'return function (' + array_join.call(boundArgs, ',') + '){ return binder.apply(this, arguments); }')(binder);\n\n      if (target.prototype) {\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty(); // Clean up dangling references.\n\n        Empty.prototype = null;\n      } // TODO\n      // 18. Set the [[Extensible]] internal property of F to true.\n      // TODO\n      // 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).\n      // 20. Call the [[DefineOwnProperty]] internal method of F with\n      //   arguments \"caller\", PropertyDescriptor {[[Get]]: thrower, [[Set]]:\n      //   thrower, [[Enumerable]]: false, [[Configurable]]: false}, and\n      //   false.\n      // 21. Call the [[DefineOwnProperty]] internal method of F with\n      //   arguments \"arguments\", PropertyDescriptor {[[Get]]: thrower,\n      //   [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false},\n      //   and false.\n      // TODO\n      // NOTE Function objects created using Function.prototype.bind do not\n      // have a prototype property or the [[Code]], [[FormalParameters]], and\n      // [[Scope]] internal properties.\n      // XXX can't delete prototype in pure-js.\n      // 22. Return F.\n\n\n      return bound;\n    }\n  }); // _Please note: Shortcuts are defined after `Function.prototype.bind` as we\n  // use it in defining shortcuts.\n\n  var owns = call.bind(ObjectPrototype.hasOwnProperty);\n  var toStr = call.bind(ObjectPrototype.toString);\n  var arraySlice = call.bind(array_slice);\n  var arraySliceApply = apply.bind(array_slice);\n  /* globals document */\n\n  if ((typeof document === \"undefined\" ? \"undefined\" : _typeof(document)) === 'object' && document && document.documentElement) {\n    try {\n      arraySlice(document.documentElement.childNodes);\n    } catch (e) {\n      var origArraySlice = arraySlice;\n      var origArraySliceApply = arraySliceApply;\n\n      arraySlice = function arraySliceIE(arr) {\n        var r = [];\n        var i = arr.length;\n\n        while (i-- > 0) {\n          r[i] = arr[i];\n        }\n\n        return origArraySliceApply(r, origArraySlice(arguments, 1));\n      };\n\n      arraySliceApply = function arraySliceApplyIE(arr, args) {\n        return origArraySliceApply(arraySlice(arr), args);\n      };\n    }\n  }\n\n  var strSlice = call.bind(StringPrototype.slice);\n  var strSplit = call.bind(StringPrototype.split);\n  var strIndexOf = call.bind(StringPrototype.indexOf);\n  var pushCall = call.bind(array_push);\n  var isEnum = call.bind(ObjectPrototype.propertyIsEnumerable);\n  var arraySort = call.bind(ArrayPrototype.sort); //\n  // Array\n  // =====\n  //\n\n  var isArray = $Array.isArray || function isArray(obj) {\n    return toStr(obj) === '[object Array]';\n  }; // ES5 15.4.4.12\n  // http://es5.github.com/#x15.4.4.13\n  // Return len+argCount.\n  // [bugfix, ielt8]\n  // IE < 8 bug: [].unshift(0) === undefined but should be \"1\"\n\n\n  var hasUnshiftReturnValueBug = [].unshift(0) !== 1;\n  defineProperties(ArrayPrototype, {\n    unshift: function unshift() {\n      array_unshift.apply(this, arguments);\n      return this.length;\n    }\n  }, hasUnshiftReturnValueBug); // ES5 15.4.3.2\n  // http://es5.github.com/#x15.4.3.2\n  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray\n\n  defineProperties($Array, {\n    isArray: isArray\n  }); // The IsCallable() check in the Array functions\n  // has been replaced with a strict check on the\n  // internal class of the object to trap cases where\n  // the provided function was actually a regular\n  // expression literal, which in V8 and\n  // JavaScriptCore is a typeof \"function\".  Only in\n  // V8 are regular expression literals permitted as\n  // reduce parameters, so it is desirable in the\n  // general case for the shim to match the more\n  // strict and common behavior of rejecting regular\n  // expressions.\n  // ES5 15.4.4.18\n  // http://es5.github.com/#x15.4.4.18\n  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/forEach\n  // Check failure of by-index access of string characters (IE < 9)\n  // and failure of `0 in boxedString` (Rhino)\n\n  var boxedString = $Object('a');\n  var splitString = boxedString[0] !== 'a' || !(0 in boxedString);\n\n  var properlyBoxesContext = function properlyBoxed(method) {\n    // Check node 0.6.21 bug where third parameter is not boxed\n    var properlyBoxesNonStrict = true;\n    var properlyBoxesStrict = true;\n    var threwException = false;\n\n    if (method) {\n      try {\n        method.call('foo', function (_, __, context) {\n          if (_typeof(context) !== 'object') {\n            properlyBoxesNonStrict = false;\n          }\n        });\n        method.call([1], function () {\n          'use strict';\n\n          properlyBoxesStrict = typeof this === 'string';\n        }, 'x');\n      } catch (e) {\n        threwException = true;\n      }\n    }\n\n    return !!method && !threwException && properlyBoxesNonStrict && properlyBoxesStrict;\n  };\n\n  defineProperties(ArrayPrototype, {\n    forEach: function forEach(callbackfn\n    /*, thisArg*/\n    ) {\n      var object = ES.ToObject(this);\n      var self = splitString && isString(this) ? strSplit(this, '') : object;\n      var i = -1;\n      var length = ES.ToUint32(self.length);\n      var T;\n\n      if (arguments.length > 1) {\n        T = arguments[1];\n      } // If no callback function or if callback is not a callable function\n\n\n      if (!isCallable(callbackfn)) {\n        throw new TypeError('Array.prototype.forEach callback must be a function');\n      }\n\n      while (++i < length) {\n        if (i in self) {\n          // Invoke the callback function with call, passing arguments:\n          // context, property value, property key, thisArg object\n          if (typeof T === 'undefined') {\n            callbackfn(self[i], i, object);\n          } else {\n            callbackfn.call(T, self[i], i, object);\n          }\n        }\n      }\n    }\n  }, !properlyBoxesContext(ArrayPrototype.forEach)); // ES5 15.4.4.19\n  // http://es5.github.com/#x15.4.4.19\n  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map\n\n  defineProperties(ArrayPrototype, {\n    map: function map(callbackfn\n    /*, thisArg*/\n    ) {\n      var object = ES.ToObject(this);\n      var self = splitString && isString(this) ? strSplit(this, '') : object;\n      var length = ES.ToUint32(self.length);\n      var result = $Array(length);\n      var T;\n\n      if (arguments.length > 1) {\n        T = arguments[1];\n      } // If no callback function or if callback is not a callable function\n\n\n      if (!isCallable(callbackfn)) {\n        throw new TypeError('Array.prototype.map callback must be a function');\n      }\n\n      for (var i = 0; i < length; i++) {\n        if (i in self) {\n          if (typeof T === 'undefined') {\n            result[i] = callbackfn(self[i], i, object);\n          } else {\n            result[i] = callbackfn.call(T, self[i], i, object);\n          }\n        }\n      }\n\n      return result;\n    }\n  }, !properlyBoxesContext(ArrayPrototype.map)); // ES5 15.4.4.20\n  // http://es5.github.com/#x15.4.4.20\n  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter\n\n  defineProperties(ArrayPrototype, {\n    filter: function filter(callbackfn\n    /*, thisArg*/\n    ) {\n      var object = ES.ToObject(this);\n      var self = splitString && isString(this) ? strSplit(this, '') : object;\n      var length = ES.ToUint32(self.length);\n      var result = [];\n      var value;\n      var T;\n\n      if (arguments.length > 1) {\n        T = arguments[1];\n      } // If no callback function or if callback is not a callable function\n\n\n      if (!isCallable(callbackfn)) {\n        throw new TypeError('Array.prototype.filter callback must be a function');\n      }\n\n      for (var i = 0; i < length; i++) {\n        if (i in self) {\n          value = self[i];\n\n          if (typeof T === 'undefined' ? callbackfn(value, i, object) : callbackfn.call(T, value, i, object)) {\n            pushCall(result, value);\n          }\n        }\n      }\n\n      return result;\n    }\n  }, !properlyBoxesContext(ArrayPrototype.filter)); // ES5 15.4.4.16\n  // http://es5.github.com/#x15.4.4.16\n  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every\n\n  defineProperties(ArrayPrototype, {\n    every: function every(callbackfn\n    /*, thisArg*/\n    ) {\n      var object = ES.ToObject(this);\n      var self = splitString && isString(this) ? strSplit(this, '') : object;\n      var length = ES.ToUint32(self.length);\n      var T;\n\n      if (arguments.length > 1) {\n        T = arguments[1];\n      } // If no callback function or if callback is not a callable function\n\n\n      if (!isCallable(callbackfn)) {\n        throw new TypeError('Array.prototype.every callback must be a function');\n      }\n\n      for (var i = 0; i < length; i++) {\n        if (i in self && !(typeof T === 'undefined' ? callbackfn(self[i], i, object) : callbackfn.call(T, self[i], i, object))) {\n          return false;\n        }\n      }\n\n      return true;\n    }\n  }, !properlyBoxesContext(ArrayPrototype.every)); // ES5 15.4.4.17\n  // http://es5.github.com/#x15.4.4.17\n  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some\n\n  defineProperties(ArrayPrototype, {\n    some: function some(callbackfn\n    /*, thisArg */\n    ) {\n      var object = ES.ToObject(this);\n      var self = splitString && isString(this) ? strSplit(this, '') : object;\n      var length = ES.ToUint32(self.length);\n      var T;\n\n      if (arguments.length > 1) {\n        T = arguments[1];\n      } // If no callback function or if callback is not a callable function\n\n\n      if (!isCallable(callbackfn)) {\n        throw new TypeError('Array.prototype.some callback must be a function');\n      }\n\n      for (var i = 0; i < length; i++) {\n        if (i in self && (typeof T === 'undefined' ? callbackfn(self[i], i, object) : callbackfn.call(T, self[i], i, object))) {\n          return true;\n        }\n      }\n\n      return false;\n    }\n  }, !properlyBoxesContext(ArrayPrototype.some)); // ES5 15.4.4.21\n  // http://es5.github.com/#x15.4.4.21\n  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce\n\n  var reduceCoercesToObject = false;\n\n  if (ArrayPrototype.reduce) {\n    reduceCoercesToObject = _typeof(ArrayPrototype.reduce.call('es5', function (_, __, ___, list) {\n      return list;\n    })) === 'object';\n  }\n\n  defineProperties(ArrayPrototype, {\n    reduce: function reduce(callbackfn\n    /*, initialValue*/\n    ) {\n      var object = ES.ToObject(this);\n      var self = splitString && isString(this) ? strSplit(this, '') : object;\n      var length = ES.ToUint32(self.length); // If no callback function or if callback is not a callable function\n\n      if (!isCallable(callbackfn)) {\n        throw new TypeError('Array.prototype.reduce callback must be a function');\n      } // no value to return if no initial value and an empty array\n\n\n      if (length === 0 && arguments.length === 1) {\n        throw new TypeError('reduce of empty array with no initial value');\n      }\n\n      var i = 0;\n      var result;\n\n      if (arguments.length >= 2) {\n        result = arguments[1];\n      } else {\n        do {\n          if (i in self) {\n            result = self[i++];\n            break;\n          } // if array contains no values, no initial value to return\n\n\n          if (++i >= length) {\n            throw new TypeError('reduce of empty array with no initial value');\n          }\n        } while (true);\n      }\n\n      for (; i < length; i++) {\n        if (i in self) {\n          result = callbackfn(result, self[i], i, object);\n        }\n      }\n\n      return result;\n    }\n  }, !reduceCoercesToObject); // ES5 15.4.4.22\n  // http://es5.github.com/#x15.4.4.22\n  // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight\n\n  var reduceRightCoercesToObject = false;\n\n  if (ArrayPrototype.reduceRight) {\n    reduceRightCoercesToObject = _typeof(ArrayPrototype.reduceRight.call('es5', function (_, __, ___, list) {\n      return list;\n    })) === 'object';\n  }\n\n  defineProperties(ArrayPrototype, {\n    reduceRight: function reduceRight(callbackfn\n    /*, initial*/\n    ) {\n      var object = ES.ToObject(this);\n      var self = splitString && isString(this) ? strSplit(this, '') : object;\n      var length = ES.ToUint32(self.length); // If no callback function or if callback is not a callable function\n\n      if (!isCallable(callbackfn)) {\n        throw new TypeError('Array.prototype.reduceRight callback must be a function');\n      } // no value to return if no initial value, empty array\n\n\n      if (length === 0 && arguments.length === 1) {\n        throw new TypeError('reduceRight of empty array with no initial value');\n      }\n\n      var result;\n      var i = length - 1;\n\n      if (arguments.length >= 2) {\n        result = arguments[1];\n      } else {\n        do {\n          if (i in self) {\n            result = self[i--];\n            break;\n          } // if array contains no values, no initial value to return\n\n\n          if (--i < 0) {\n            throw new TypeError('reduceRight of empty array with no initial value');\n          }\n        } while (true);\n      }\n\n      if (i < 0) {\n        return result;\n      }\n\n      do {\n        if (i in self) {\n          result = callbackfn(result, self[i], i, object);\n        }\n      } while (i--);\n\n      return result;\n    }\n  }, !reduceRightCoercesToObject); // ES5 15.4.4.14\n  // http://es5.github.com/#x15.4.4.14\n  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf\n\n  var hasFirefox2IndexOfBug = ArrayPrototype.indexOf && [0, 1].indexOf(1, 2) !== -1;\n  defineProperties(ArrayPrototype, {\n    indexOf: function indexOf(searchElement\n    /*, fromIndex */\n    ) {\n      var self = splitString && isString(this) ? strSplit(this, '') : ES.ToObject(this);\n      var length = ES.ToUint32(self.length);\n\n      if (length === 0) {\n        return -1;\n      }\n\n      var i = 0;\n\n      if (arguments.length > 1) {\n        i = ES.ToInteger(arguments[1]);\n      } // handle negative indices\n\n\n      i = i >= 0 ? i : max(0, length + i);\n\n      for (; i < length; i++) {\n        if (i in self && self[i] === searchElement) {\n          return i;\n        }\n      }\n\n      return -1;\n    }\n  }, hasFirefox2IndexOfBug); // ES5 15.4.4.15\n  // http://es5.github.com/#x15.4.4.15\n  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf\n\n  var hasFirefox2LastIndexOfBug = ArrayPrototype.lastIndexOf && [0, 1].lastIndexOf(0, -3) !== -1;\n  defineProperties(ArrayPrototype, {\n    lastIndexOf: function lastIndexOf(searchElement\n    /*, fromIndex */\n    ) {\n      var self = splitString && isString(this) ? strSplit(this, '') : ES.ToObject(this);\n      var length = ES.ToUint32(self.length);\n\n      if (length === 0) {\n        return -1;\n      }\n\n      var i = length - 1;\n\n      if (arguments.length > 1) {\n        i = min(i, ES.ToInteger(arguments[1]));\n      } // handle negative indices\n\n\n      i = i >= 0 ? i : length - Math.abs(i);\n\n      for (; i >= 0; i--) {\n        if (i in self && searchElement === self[i]) {\n          return i;\n        }\n      }\n\n      return -1;\n    }\n  }, hasFirefox2LastIndexOfBug); // ES5 15.4.4.12\n  // http://es5.github.com/#x15.4.4.12\n\n  var spliceNoopReturnsEmptyArray = function () {\n    var a = [1, 2];\n    var result = a.splice();\n    return a.length === 2 && isArray(result) && result.length === 0;\n  }();\n\n  defineProperties(ArrayPrototype, {\n    // Safari 5.0 bug where .splice() returns undefined\n    splice: function splice(start, deleteCount) {\n      if (arguments.length === 0) {\n        return [];\n      } else {\n        return array_splice.apply(this, arguments);\n      }\n    }\n  }, !spliceNoopReturnsEmptyArray);\n\n  var spliceWorksWithEmptyObject = function () {\n    var obj = {};\n    ArrayPrototype.splice.call(obj, 0, 0, 1);\n    return obj.length === 1;\n  }();\n\n  defineProperties(ArrayPrototype, {\n    splice: function splice(start, deleteCount) {\n      if (arguments.length === 0) {\n        return [];\n      }\n\n      var args = arguments;\n      this.length = max(ES.ToInteger(this.length), 0);\n\n      if (arguments.length > 0 && typeof deleteCount !== 'number') {\n        args = arraySlice(arguments);\n\n        if (args.length < 2) {\n          pushCall(args, this.length - start);\n        } else {\n          args[1] = ES.ToInteger(deleteCount);\n        }\n      }\n\n      return array_splice.apply(this, args);\n    }\n  }, !spliceWorksWithEmptyObject);\n\n  var spliceWorksWithLargeSparseArrays = function () {\n    // Per https://github.com/es-shims/es5-shim/issues/295\n    // Safari 7/8 breaks with sparse arrays of size 1e5 or greater\n    var arr = new $Array(1e5); // note: the index MUST be 8 or larger or the test will false pass\n\n    arr[8] = 'x';\n    arr.splice(1, 1); // note: this test must be defined *after* the indexOf shim\n    // per https://github.com/es-shims/es5-shim/issues/313\n\n    return arr.indexOf('x') === 7;\n  }();\n\n  var spliceWorksWithSmallSparseArrays = function () {\n    // Per https://github.com/es-shims/es5-shim/issues/295\n    // Opera 12.15 breaks on this, no idea why.\n    var n = 256;\n    var arr = [];\n    arr[n] = 'a';\n    arr.splice(n + 1, 0, 'b');\n    return arr[n] === 'a';\n  }();\n\n  defineProperties(ArrayPrototype, {\n    splice: function splice(start, deleteCount) {\n      var O = ES.ToObject(this);\n      var A = [];\n      var len = ES.ToUint32(O.length);\n      var relativeStart = ES.ToInteger(start);\n      var actualStart = relativeStart < 0 ? max(len + relativeStart, 0) : min(relativeStart, len);\n      var actualDeleteCount = min(max(ES.ToInteger(deleteCount), 0), len - actualStart);\n      var k = 0;\n      var from;\n\n      while (k < actualDeleteCount) {\n        from = $String(actualStart + k);\n\n        if (owns(O, from)) {\n          A[k] = O[from];\n        }\n\n        k += 1;\n      }\n\n      var items = arraySlice(arguments, 2);\n      var itemCount = items.length;\n      var to;\n\n      if (itemCount < actualDeleteCount) {\n        k = actualStart;\n        var maxK = len - actualDeleteCount;\n\n        while (k < maxK) {\n          from = $String(k + actualDeleteCount);\n          to = $String(k + itemCount);\n\n          if (owns(O, from)) {\n            O[to] = O[from];\n          } else {\n            delete O[to];\n          }\n\n          k += 1;\n        }\n\n        k = len;\n        var minK = len - actualDeleteCount + itemCount;\n\n        while (k > minK) {\n          delete O[k - 1];\n          k -= 1;\n        }\n      } else if (itemCount > actualDeleteCount) {\n        k = len - actualDeleteCount;\n\n        while (k > actualStart) {\n          from = $String(k + actualDeleteCount - 1);\n          to = $String(k + itemCount - 1);\n\n          if (owns(O, from)) {\n            O[to] = O[from];\n          } else {\n            delete O[to];\n          }\n\n          k -= 1;\n        }\n      }\n\n      k = actualStart;\n\n      for (var i = 0; i < items.length; ++i) {\n        O[k] = items[i];\n        k += 1;\n      }\n\n      O.length = len - actualDeleteCount + itemCount;\n      return A;\n    }\n  }, !spliceWorksWithLargeSparseArrays || !spliceWorksWithSmallSparseArrays);\n  var originalJoin = ArrayPrototype.join;\n  var hasStringJoinBug;\n\n  try {\n    hasStringJoinBug = Array.prototype.join.call('123', ',') !== '1,2,3';\n  } catch (e) {\n    hasStringJoinBug = true;\n  }\n\n  if (hasStringJoinBug) {\n    defineProperties(ArrayPrototype, {\n      join: function join(separator) {\n        var sep = typeof separator === 'undefined' ? ',' : separator;\n        return originalJoin.call(isString(this) ? strSplit(this, '') : this, sep);\n      }\n    }, hasStringJoinBug);\n  }\n\n  var hasJoinUndefinedBug = [1, 2].join(undefined) !== '1,2';\n\n  if (hasJoinUndefinedBug) {\n    defineProperties(ArrayPrototype, {\n      join: function join(separator) {\n        var sep = typeof separator === 'undefined' ? ',' : separator;\n        return originalJoin.call(this, sep);\n      }\n    }, hasJoinUndefinedBug);\n  }\n\n  var pushShim = function push(item) {\n    var O = ES.ToObject(this);\n    var n = ES.ToUint32(O.length);\n    var i = 0;\n\n    while (i < arguments.length) {\n      O[n + i] = arguments[i];\n      i += 1;\n    }\n\n    O.length = n + i;\n    return n + i;\n  };\n\n  var pushIsNotGeneric = function () {\n    var obj = {};\n    var result = Array.prototype.push.call(obj, undefined);\n    return result !== 1 || obj.length !== 1 || typeof obj[0] !== 'undefined' || !owns(obj, 0);\n  }();\n\n  defineProperties(ArrayPrototype, {\n    push: function push(item) {\n      if (isArray(this)) {\n        return array_push.apply(this, arguments);\n      }\n\n      return pushShim.apply(this, arguments);\n    }\n  }, pushIsNotGeneric); // This fixes a very weird bug in Opera 10.6 when pushing `undefined\n\n  var pushUndefinedIsWeird = function () {\n    var arr = [];\n    var result = arr.push(undefined);\n    return result !== 1 || arr.length !== 1 || typeof arr[0] !== 'undefined' || !owns(arr, 0);\n  }();\n\n  defineProperties(ArrayPrototype, {\n    push: pushShim\n  }, pushUndefinedIsWeird); // ES5 15.2.3.14\n  // http://es5.github.io/#x15.4.4.10\n  // Fix boxed string bug\n\n  defineProperties(ArrayPrototype, {\n    slice: function slice(start, end) {\n      var arr = isString(this) ? strSplit(this, '') : this;\n      return arraySliceApply(arr, arguments);\n    }\n  }, splitString);\n\n  var sortIgnoresNonFunctions = function () {\n    try {\n      [1, 2].sort(null);\n    } catch (e) {\n      try {\n        [1, 2].sort({});\n      } catch (e2) {\n        return false;\n      }\n    }\n\n    return true;\n  }();\n\n  var sortThrowsOnRegex = function () {\n    // this is a problem in Firefox 4, in which `typeof /a/ === 'function'`\n    try {\n      [1, 2].sort(/a/);\n      return false;\n    } catch (e) {}\n\n    return true;\n  }();\n\n  var sortIgnoresUndefined = function () {\n    // applies in IE 8, for one.\n    try {\n      [1, 2].sort(undefined);\n      return true;\n    } catch (e) {}\n\n    return false;\n  }();\n\n  defineProperties(ArrayPrototype, {\n    sort: function sort(compareFn) {\n      if (typeof compareFn === 'undefined') {\n        return arraySort(this);\n      }\n\n      if (!isCallable(compareFn)) {\n        throw new TypeError('Array.prototype.sort callback must be a function');\n      }\n\n      return arraySort(this, compareFn);\n    }\n  }, sortIgnoresNonFunctions || !sortIgnoresUndefined || !sortThrowsOnRegex); //\n  // Object\n  // ======\n  //\n  // ES5 15.2.3.14\n  // http://es5.github.com/#x15.2.3.14\n  // http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation\n\n  var hasDontEnumBug = !isEnum({\n    'toString': null\n  }, 'toString'); // jscs:ignore disallowQuotedKeysInObjects\n\n  var hasProtoEnumBug = isEnum(function () {}, 'prototype');\n  var hasStringEnumBug = !owns('x', '0');\n\n  var equalsConstructorPrototype = function equalsConstructorPrototype(o) {\n    var ctor = o.constructor;\n    return ctor && ctor.prototype === o;\n  };\n\n  var excludedKeys = {\n    $applicationCache: true,\n    $console: true,\n    $external: true,\n    $frame: true,\n    $frameElement: true,\n    $frames: true,\n    $innerHeight: true,\n    $innerWidth: true,\n    $onmozfullscreenchange: true,\n    $onmozfullscreenerror: true,\n    $outerHeight: true,\n    $outerWidth: true,\n    $pageXOffset: true,\n    $pageYOffset: true,\n    $parent: true,\n    $scrollLeft: true,\n    $scrollTop: true,\n    $scrollX: true,\n    $scrollY: true,\n    $self: true,\n    $webkitIndexedDB: true,\n    $webkitStorageInfo: true,\n    $window: true,\n    $width: true,\n    $height: true,\n    $top: true,\n    $localStorage: true\n  };\n\n  var hasAutomationEqualityBug = function () {\n    /* globals window */\n    if (typeof window === 'undefined') {\n      return false;\n    }\n\n    for (var k in window) {\n      try {\n        if (!excludedKeys['$' + k] && owns(window, k) && window[k] !== null && _typeof(window[k]) === 'object') {\n          equalsConstructorPrototype(window[k]);\n        }\n      } catch (e) {\n        return true;\n      }\n    }\n\n    return false;\n  }();\n\n  var equalsConstructorPrototypeIfNotBuggy = function equalsConstructorPrototypeIfNotBuggy(object) {\n    if (typeof window === 'undefined' || !hasAutomationEqualityBug) {\n      return equalsConstructorPrototype(object);\n    }\n\n    try {\n      return equalsConstructorPrototype(object);\n    } catch (e) {\n      return false;\n    }\n  };\n\n  var dontEnums = ['toString', 'toLocaleString', 'valueOf', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'constructor'];\n  var dontEnumsLength = dontEnums.length; // taken directly from https://github.com/ljharb/is-arguments/blob/master/index.js\n  // can be replaced with require('is-arguments') if we ever use a build process instead\n\n  var isStandardArguments = function isArguments(value) {\n    return toStr(value) === '[object Arguments]';\n  };\n\n  var isLegacyArguments = function isArguments(value) {\n    return value !== null && _typeof(value) === 'object' && typeof value.length === 'number' && value.length >= 0 && !isArray(value) && isCallable(value.callee);\n  };\n\n  var isArguments = isStandardArguments(arguments) ? isStandardArguments : isLegacyArguments;\n  defineProperties($Object, {\n    keys: function keys(object) {\n      var isFn = isCallable(object);\n      var isArgs = isArguments(object);\n      var isObject = object !== null && _typeof(object) === 'object';\n      var isStr = isObject && isString(object);\n\n      if (!isObject && !isFn && !isArgs) {\n        throw new TypeError('Object.keys called on a non-object');\n      }\n\n      var theKeys = [];\n      var skipProto = hasProtoEnumBug && isFn;\n\n      if (isStr && hasStringEnumBug || isArgs) {\n        for (var i = 0; i < object.length; ++i) {\n          pushCall(theKeys, $String(i));\n        }\n      }\n\n      if (!isArgs) {\n        for (var name in object) {\n          if (!(skipProto && name === 'prototype') && owns(object, name)) {\n            pushCall(theKeys, $String(name));\n          }\n        }\n      }\n\n      if (hasDontEnumBug) {\n        var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);\n\n        for (var j = 0; j < dontEnumsLength; j++) {\n          var dontEnum = dontEnums[j];\n\n          if (!(skipConstructor && dontEnum === 'constructor') && owns(object, dontEnum)) {\n            pushCall(theKeys, dontEnum);\n          }\n        }\n      }\n\n      return theKeys;\n    }\n  });\n\n  var keysWorksWithArguments = $Object.keys && function () {\n    // Safari 5.0 bug\n    return $Object.keys(arguments).length === 2;\n  }(1, 2);\n\n  var keysHasArgumentsLengthBug = $Object.keys && function () {\n    var argKeys = $Object.keys(arguments);\n    return arguments.length !== 1 || argKeys.length !== 1 || argKeys[0] !== 1;\n  }(1);\n\n  var originalKeys = $Object.keys;\n  defineProperties($Object, {\n    keys: function keys(object) {\n      if (isArguments(object)) {\n        return originalKeys(arraySlice(object));\n      } else {\n        return originalKeys(object);\n      }\n    }\n  }, !keysWorksWithArguments || keysHasArgumentsLengthBug); //\n  // Date\n  // ====\n  //\n\n  var hasNegativeMonthYearBug = new Date(-3509827329600292).getUTCMonth() !== 0;\n  var aNegativeTestDate = new Date(-1509842289600292);\n  var aPositiveTestDate = new Date(1449662400000);\n  var hasToUTCStringFormatBug = aNegativeTestDate.toUTCString() !== 'Mon, 01 Jan -45875 11:59:59 GMT';\n  var hasToDateStringFormatBug;\n  var hasToStringFormatBug;\n  var timeZoneOffset = aNegativeTestDate.getTimezoneOffset();\n\n  if (timeZoneOffset < -720) {\n    hasToDateStringFormatBug = aNegativeTestDate.toDateString() !== 'Tue Jan 02 -45875';\n    hasToStringFormatBug = !/^Thu Dec 10 2015 \\d\\d:\\d\\d:\\d\\d GMT[-+]\\d\\d\\d\\d(?: |$)/.test(String(aPositiveTestDate));\n  } else {\n    hasToDateStringFormatBug = aNegativeTestDate.toDateString() !== 'Mon Jan 01 -45875';\n    hasToStringFormatBug = !/^Wed Dec 09 2015 \\d\\d:\\d\\d:\\d\\d GMT[-+]\\d\\d\\d\\d(?: |$)/.test(String(aPositiveTestDate));\n  }\n\n  var originalGetFullYear = call.bind(Date.prototype.getFullYear);\n  var originalGetMonth = call.bind(Date.prototype.getMonth);\n  var originalGetDate = call.bind(Date.prototype.getDate);\n  var originalGetUTCFullYear = call.bind(Date.prototype.getUTCFullYear);\n  var originalGetUTCMonth = call.bind(Date.prototype.getUTCMonth);\n  var originalGetUTCDate = call.bind(Date.prototype.getUTCDate);\n  var originalGetUTCDay = call.bind(Date.prototype.getUTCDay);\n  var originalGetUTCHours = call.bind(Date.prototype.getUTCHours);\n  var originalGetUTCMinutes = call.bind(Date.prototype.getUTCMinutes);\n  var originalGetUTCSeconds = call.bind(Date.prototype.getUTCSeconds);\n  var originalGetUTCMilliseconds = call.bind(Date.prototype.getUTCMilliseconds);\n  var dayName = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];\n  var monthName = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];\n\n  var daysInMonth = function daysInMonth(month, year) {\n    return originalGetDate(new Date(year, month, 0));\n  };\n\n  defineProperties(Date.prototype, {\n    getFullYear: function getFullYear() {\n      if (!this || !(this instanceof Date)) {\n        throw new TypeError('this is not a Date object.');\n      }\n\n      var year = originalGetFullYear(this);\n\n      if (year < 0 && originalGetMonth(this) > 11) {\n        return year + 1;\n      }\n\n      return year;\n    },\n    getMonth: function getMonth() {\n      if (!this || !(this instanceof Date)) {\n        throw new TypeError('this is not a Date object.');\n      }\n\n      var year = originalGetFullYear(this);\n      var month = originalGetMonth(this);\n\n      if (year < 0 && month > 11) {\n        return 0;\n      }\n\n      return month;\n    },\n    getDate: function getDate() {\n      if (!this || !(this instanceof Date)) {\n        throw new TypeError('this is not a Date object.');\n      }\n\n      var year = originalGetFullYear(this);\n      var month = originalGetMonth(this);\n      var date = originalGetDate(this);\n\n      if (year < 0 && month > 11) {\n        if (month === 12) {\n          return date;\n        }\n\n        var days = daysInMonth(0, year + 1);\n        return days - date + 1;\n      }\n\n      return date;\n    },\n    getUTCFullYear: function getUTCFullYear() {\n      if (!this || !(this instanceof Date)) {\n        throw new TypeError('this is not a Date object.');\n      }\n\n      var year = originalGetUTCFullYear(this);\n\n      if (year < 0 && originalGetUTCMonth(this) > 11) {\n        return year + 1;\n      }\n\n      return year;\n    },\n    getUTCMonth: function getUTCMonth() {\n      if (!this || !(this instanceof Date)) {\n        throw new TypeError('this is not a Date object.');\n      }\n\n      var year = originalGetUTCFullYear(this);\n      var month = originalGetUTCMonth(this);\n\n      if (year < 0 && month > 11) {\n        return 0;\n      }\n\n      return month;\n    },\n    getUTCDate: function getUTCDate() {\n      if (!this || !(this instanceof Date)) {\n        throw new TypeError('this is not a Date object.');\n      }\n\n      var year = originalGetUTCFullYear(this);\n      var month = originalGetUTCMonth(this);\n      var date = originalGetUTCDate(this);\n\n      if (year < 0 && month > 11) {\n        if (month === 12) {\n          return date;\n        }\n\n        var days = daysInMonth(0, year + 1);\n        return days - date + 1;\n      }\n\n      return date;\n    }\n  }, hasNegativeMonthYearBug);\n  defineProperties(Date.prototype, {\n    toUTCString: function toUTCString() {\n      if (!this || !(this instanceof Date)) {\n        throw new TypeError('this is not a Date object.');\n      }\n\n      var day = originalGetUTCDay(this);\n      var date = originalGetUTCDate(this);\n      var month = originalGetUTCMonth(this);\n      var year = originalGetUTCFullYear(this);\n      var hour = originalGetUTCHours(this);\n      var minute = originalGetUTCMinutes(this);\n      var second = originalGetUTCSeconds(this);\n      return dayName[day] + ', ' + (date < 10 ? '0' + date : date) + ' ' + monthName[month] + ' ' + year + ' ' + (hour < 10 ? '0' + hour : hour) + ':' + (minute < 10 ? '0' + minute : minute) + ':' + (second < 10 ? '0' + second : second) + ' GMT';\n    }\n  }, hasNegativeMonthYearBug || hasToUTCStringFormatBug); // Opera 12 has `,`\n\n  defineProperties(Date.prototype, {\n    toDateString: function toDateString() {\n      if (!this || !(this instanceof Date)) {\n        throw new TypeError('this is not a Date object.');\n      }\n\n      var day = this.getDay();\n      var date = this.getDate();\n      var month = this.getMonth();\n      var year = this.getFullYear();\n      return dayName[day] + ' ' + monthName[month] + ' ' + (date < 10 ? '0' + date : date) + ' ' + year;\n    }\n  }, hasNegativeMonthYearBug || hasToDateStringFormatBug); // can't use defineProperties here because of toString enumeration issue in IE <= 8\n\n  if (hasNegativeMonthYearBug || hasToStringFormatBug) {\n    Date.prototype.toString = function toString() {\n      if (!this || !(this instanceof Date)) {\n        throw new TypeError('this is not a Date object.');\n      }\n\n      var day = this.getDay();\n      var date = this.getDate();\n      var month = this.getMonth();\n      var year = this.getFullYear();\n      var hour = this.getHours();\n      var minute = this.getMinutes();\n      var second = this.getSeconds();\n      var timezoneOffset = this.getTimezoneOffset();\n      var hoursOffset = Math.floor(Math.abs(timezoneOffset) / 60);\n      var minutesOffset = Math.floor(Math.abs(timezoneOffset) % 60);\n      return dayName[day] + ' ' + monthName[month] + ' ' + (date < 10 ? '0' + date : date) + ' ' + year + ' ' + (hour < 10 ? '0' + hour : hour) + ':' + (minute < 10 ? '0' + minute : minute) + ':' + (second < 10 ? '0' + second : second) + ' GMT' + (timezoneOffset > 0 ? '-' : '+') + (hoursOffset < 10 ? '0' + hoursOffset : hoursOffset) + (minutesOffset < 10 ? '0' + minutesOffset : minutesOffset);\n    };\n\n    if (supportsDescriptors) {\n      $Object.defineProperty(Date.prototype, 'toString', {\n        configurable: true,\n        enumerable: false,\n        writable: true\n      });\n    }\n  } // ES5 15.9.5.43\n  // http://es5.github.com/#x15.9.5.43\n  // This function returns a String value represent the instance in time\n  // represented by this Date object. The format of the String is the Date Time\n  // string format defined in 15.9.1.15. All fields are present in the String.\n  // The time zone is always UTC, denoted by the suffix Z. If the time value of\n  // this object is not a finite Number a RangeError exception is thrown.\n\n\n  var negativeDate = -62198755200000;\n  var negativeYearString = '-000001';\n  var hasNegativeDateBug = Date.prototype.toISOString && new Date(negativeDate).toISOString().indexOf(negativeYearString) === -1; // eslint-disable-line max-len\n\n  var hasSafari51DateBug = Date.prototype.toISOString && new Date(-1).toISOString() !== '1969-12-31T23:59:59.999Z';\n  var getTime = call.bind(Date.prototype.getTime);\n  defineProperties(Date.prototype, {\n    toISOString: function toISOString() {\n      if (!isFinite(this) || !isFinite(getTime(this))) {\n        // Adope Photoshop requires the second check.\n        throw new RangeError('Date.prototype.toISOString called on non-finite value.');\n      }\n\n      var year = originalGetUTCFullYear(this);\n      var month = originalGetUTCMonth(this); // see https://github.com/es-shims/es5-shim/issues/111\n\n      year += Math.floor(month / 12);\n      month = (month % 12 + 12) % 12; // the date time string format is specified in 15.9.1.15.\n\n      var result = [month + 1, originalGetUTCDate(this), originalGetUTCHours(this), originalGetUTCMinutes(this), originalGetUTCSeconds(this)];\n      year = (year < 0 ? '-' : year > 9999 ? '+' : '') + strSlice('00000' + Math.abs(year), 0 <= year && year <= 9999 ? -4 : -6);\n\n      for (var i = 0; i < result.length; ++i) {\n        // pad months, days, hours, minutes, and seconds to have two digits.\n        result[i] = strSlice('00' + result[i], -2);\n      } // pad milliseconds to have three digits.\n\n\n      return year + '-' + arraySlice(result, 0, 2).join('-') + 'T' + arraySlice(result, 2).join(':') + '.' + strSlice('000' + originalGetUTCMilliseconds(this), -3) + 'Z';\n    }\n  }, hasNegativeDateBug || hasSafari51DateBug); // ES5 15.9.5.44\n  // http://es5.github.com/#x15.9.5.44\n  // This function provides a String representation of a Date object for use by\n  // JSON.stringify (15.12.3).\n\n  var dateToJSONIsSupported = function () {\n    try {\n      return Date.prototype.toJSON && new Date(NaN).toJSON() === null && new Date(negativeDate).toJSON().indexOf(negativeYearString) !== -1 && Date.prototype.toJSON.call({\n        // generic\n        toISOString: function toISOString() {\n          return true;\n        }\n      });\n    } catch (e) {\n      return false;\n    }\n  }();\n\n  if (!dateToJSONIsSupported) {\n    Date.prototype.toJSON = function toJSON(key) {\n      // When the toJSON method is called with argument key, the following\n      // steps are taken:\n      // 1.  Let O be the result of calling ToObject, giving it the this\n      // value as its argument.\n      // 2. Let tv be ES.ToPrimitive(O, hint Number).\n      var O = $Object(this);\n      var tv = ES.ToPrimitive(O); // 3. If tv is a Number and is not finite, return null.\n\n      if (typeof tv === 'number' && !isFinite(tv)) {\n        return null;\n      } // 4. Let toISO be the result of calling the [[Get]] internal method of\n      // O with argument \"toISOString\".\n\n\n      var toISO = O.toISOString; // 5. If IsCallable(toISO) is false, throw a TypeError exception.\n\n      if (!isCallable(toISO)) {\n        throw new TypeError('toISOString property is not callable');\n      } // 6. Return the result of calling the [[Call]] internal method of\n      //  toISO with O as the this value and an empty argument list.\n\n\n      return toISO.call(O); // NOTE 1 The argument is ignored.\n      // NOTE 2 The toJSON function is intentionally generic; it does not\n      // require that its this value be a Date object. Therefore, it can be\n      // transferred to other kinds of objects for use as a method. However,\n      // it does require that any such object have a toISOString method. An\n      // object is free to use the argument key to filter its\n      // stringification.\n    };\n  } // ES5 15.9.4.2\n  // http://es5.github.com/#x15.9.4.2\n  // based on work shared by Daniel Friesen (dantman)\n  // http://gist.github.com/303249\n\n\n  var supportsExtendedYears = Date.parse('+033658-09-27T01:46:40.000Z') === 1e15;\n  var acceptsInvalidDates = !isNaN(Date.parse('2012-04-04T24:00:00.500Z')) || !isNaN(Date.parse('2012-11-31T23:59:59.000Z')) || !isNaN(Date.parse('2012-12-31T23:59:60.000Z'));\n  var doesNotParseY2KNewYear = isNaN(Date.parse('2000-01-01T00:00:00.000Z'));\n\n  if (doesNotParseY2KNewYear || acceptsInvalidDates || !supportsExtendedYears) {\n    // XXX global assignment won't work in embeddings that use\n    // an alternate object for the context.\n\n    /* global Date: true */\n    var maxSafeUnsigned32Bit = Math.pow(2, 31) - 1;\n    var hasSafariSignedIntBug = isActualNaN(new Date(1970, 0, 1, 0, 0, 0, maxSafeUnsigned32Bit + 1).getTime()); // eslint-disable-next-line no-implicit-globals, no-global-assign\n\n    Date = function (NativeDate) {\n      // Date.length === 7\n      var DateShim = function Date(Y, M, D, h, m, s, ms) {\n        var length = arguments.length;\n        var date;\n\n        if (this instanceof NativeDate) {\n          var seconds = s;\n          var millis = ms;\n\n          if (hasSafariSignedIntBug && length >= 7 && ms > maxSafeUnsigned32Bit) {\n            // work around a Safari 8/9 bug where it treats the seconds as signed\n            var msToShift = Math.floor(ms / maxSafeUnsigned32Bit) * maxSafeUnsigned32Bit;\n            var sToShift = Math.floor(msToShift / 1e3);\n            seconds += sToShift;\n            millis -= sToShift * 1e3;\n          }\n\n          date = length === 1 && $String(Y) === Y // isString(Y)\n          // We explicitly pass it through parse:\n          ? new NativeDate(DateShim.parse(Y)) // We have to manually make calls depending on argument\n          // length here\n          : length >= 7 ? new NativeDate(Y, M, D, h, m, seconds, millis) : length >= 6 ? new NativeDate(Y, M, D, h, m, seconds) : length >= 5 ? new NativeDate(Y, M, D, h, m) : length >= 4 ? new NativeDate(Y, M, D, h) : length >= 3 ? new NativeDate(Y, M, D) : length >= 2 ? new NativeDate(Y, M) : length >= 1 ? new NativeDate(Y instanceof NativeDate ? +Y : Y) : new NativeDate();\n        } else {\n          date = NativeDate.apply(this, arguments);\n        }\n\n        if (!isPrimitive(date)) {\n          // Prevent mixups with unfixed Date object\n          defineProperties(date, {\n            constructor: DateShim\n          }, true);\n        }\n\n        return date;\n      }; // 15.9.1.15 Date Time String Format.\n\n\n      var isoDateExpression = new RegExp('^' + '(\\\\d{4}|[+-]\\\\d{6})' // four-digit year capture or sign + 6-digit extended year\n      + '(?:-(\\\\d{2})' // optional month capture\n      + '(?:-(\\\\d{2})' // optional day capture\n      + '(?:' // capture hours:minutes:seconds.milliseconds\n      + 'T(\\\\d{2})' // hours capture\n      + ':(\\\\d{2})' // minutes capture\n      + '(?:' // optional :seconds.milliseconds\n      + ':(\\\\d{2})' // seconds capture\n      + '(?:(\\\\.\\\\d{1,}))?' // milliseconds capture\n      + ')?' + '(' // capture UTC offset component\n      + 'Z|' // UTC capture\n      + '(?:' // offset specifier +/-hours:minutes\n      + '([-+])' // sign capture\n      + '(\\\\d{2})' // hours offset capture\n      + ':(\\\\d{2})' // minutes offset capture\n      + ')' + ')?)?)?)?' + '$');\n      var months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365];\n\n      var dayFromMonth = function dayFromMonth(year, month) {\n        var t = month > 1 ? 1 : 0;\n        return months[month] + Math.floor((year - 1969 + t) / 4) - Math.floor((year - 1901 + t) / 100) + Math.floor((year - 1601 + t) / 400) + 365 * (year - 1970);\n      };\n\n      var toUTC = function toUTC(t) {\n        var s = 0;\n        var ms = t;\n\n        if (hasSafariSignedIntBug && ms > maxSafeUnsigned32Bit) {\n          // work around a Safari 8/9 bug where it treats the seconds as signed\n          var msToShift = Math.floor(ms / maxSafeUnsigned32Bit) * maxSafeUnsigned32Bit;\n          var sToShift = Math.floor(msToShift / 1e3);\n          s += sToShift;\n          ms -= sToShift * 1e3;\n        }\n\n        return $Number(new NativeDate(1970, 0, 1, 0, 0, s, ms));\n      }; // Copy any custom methods a 3rd party library may have added\n\n\n      for (var key in NativeDate) {\n        if (owns(NativeDate, key)) {\n          DateShim[key] = NativeDate[key];\n        }\n      } // Copy \"native\" methods explicitly; they may be non-enumerable\n\n\n      defineProperties(DateShim, {\n        now: NativeDate.now,\n        UTC: NativeDate.UTC\n      }, true);\n      DateShim.prototype = NativeDate.prototype;\n      defineProperties(DateShim.prototype, {\n        constructor: DateShim\n      }, true); // Upgrade Date.parse to handle simplified ISO 8601 strings\n\n      var parseShim = function parse(string) {\n        var match = isoDateExpression.exec(string);\n\n        if (match) {\n          // parse months, days, hours, minutes, seconds, and milliseconds\n          // provide default values if necessary\n          // parse the UTC offset component\n          var year = $Number(match[1]),\n              month = $Number(match[2] || 1) - 1,\n              day = $Number(match[3] || 1) - 1,\n              hour = $Number(match[4] || 0),\n              minute = $Number(match[5] || 0),\n              second = $Number(match[6] || 0),\n              millisecond = Math.floor($Number(match[7] || 0) * 1000),\n              // When time zone is missed, local offset should be used\n          // (ES 5.1 bug)\n          // see https://bugs.ecmascript.org/show_bug.cgi?id=112\n          isLocalTime = Boolean(match[4] && !match[8]),\n              signOffset = match[9] === '-' ? 1 : -1,\n              hourOffset = $Number(match[10] || 0),\n              minuteOffset = $Number(match[11] || 0),\n              result;\n          var hasMinutesOrSecondsOrMilliseconds = minute > 0 || second > 0 || millisecond > 0;\n\n          if (hour < (hasMinutesOrSecondsOrMilliseconds ? 24 : 25) && minute < 60 && second < 60 && millisecond < 1000 && month > -1 && month < 12 && hourOffset < 24 && minuteOffset < 60 // detect invalid offsets\n          && day > -1 && day < dayFromMonth(year, month + 1) - dayFromMonth(year, month)) {\n            result = ((dayFromMonth(year, month) + day) * 24 + hour + hourOffset * signOffset) * 60;\n            result = ((result + minute + minuteOffset * signOffset) * 60 + second) * 1000 + millisecond;\n\n            if (isLocalTime) {\n              result = toUTC(result);\n            }\n\n            if (-8.64e15 <= result && result <= 8.64e15) {\n              return result;\n            }\n          }\n\n          return NaN;\n        }\n\n        return NativeDate.parse.apply(this, arguments);\n      };\n\n      defineProperties(DateShim, {\n        parse: parseShim\n      });\n      return DateShim;\n    }(Date);\n    /* global Date: false */\n\n  } // ES5 15.9.4.4\n  // http://es5.github.com/#x15.9.4.4\n\n\n  if (!Date.now) {\n    Date.now = function now() {\n      return new Date().getTime();\n    };\n  } //\n  // Number\n  // ======\n  //\n  // ES5.1 15.7.4.5\n  // http://es5.github.com/#x15.7.4.5\n\n\n  var hasToFixedBugs = NumberPrototype.toFixed && (0.00008.toFixed(3) !== '0.000' || 0.9.toFixed(0) !== '1' || 1.255.toFixed(2) !== '1.25' || 1000000000000000128 .toFixed(0) !== '1000000000000000128');\n  var toFixedHelpers = {\n    base: 1e7,\n    size: 6,\n    data: [0, 0, 0, 0, 0, 0],\n    multiply: function multiply(n, c) {\n      var i = -1;\n      var c2 = c;\n\n      while (++i < toFixedHelpers.size) {\n        c2 += n * toFixedHelpers.data[i];\n        toFixedHelpers.data[i] = c2 % toFixedHelpers.base;\n        c2 = Math.floor(c2 / toFixedHelpers.base);\n      }\n    },\n    divide: function divide(n) {\n      var i = toFixedHelpers.size;\n      var c = 0;\n\n      while (--i >= 0) {\n        c += toFixedHelpers.data[i];\n        toFixedHelpers.data[i] = Math.floor(c / n);\n        c = c % n * toFixedHelpers.base;\n      }\n    },\n    numToString: function numToString() {\n      var i = toFixedHelpers.size;\n      var s = '';\n\n      while (--i >= 0) {\n        if (s !== '' || i === 0 || toFixedHelpers.data[i] !== 0) {\n          var t = $String(toFixedHelpers.data[i]);\n\n          if (s === '') {\n            s = t;\n          } else {\n            s += strSlice('0000000', 0, 7 - t.length) + t;\n          }\n        }\n      }\n\n      return s;\n    },\n    pow: function pow(x, n, acc) {\n      return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc);\n    },\n    log: function log(x) {\n      var n = 0;\n      var x2 = x;\n\n      while (x2 >= 4096) {\n        n += 12;\n        x2 /= 4096;\n      }\n\n      while (x2 >= 2) {\n        n += 1;\n        x2 /= 2;\n      }\n\n      return n;\n    }\n  };\n\n  var toFixedShim = function toFixed(fractionDigits) {\n    var f, x, s, m, e, z, j, k; // Test for NaN and round fractionDigits down\n\n    f = $Number(fractionDigits);\n    f = isActualNaN(f) ? 0 : Math.floor(f);\n\n    if (f < 0 || f > 20) {\n      throw new RangeError('Number.toFixed called with invalid number of decimals');\n    }\n\n    x = $Number(this);\n\n    if (isActualNaN(x)) {\n      return 'NaN';\n    } // If it is too big or small, return the string value of the number\n\n\n    if (x <= -1e21 || x >= 1e21) {\n      return $String(x);\n    }\n\n    s = '';\n\n    if (x < 0) {\n      s = '-';\n      x = -x;\n    }\n\n    m = '0';\n\n    if (x > 1e-21) {\n      // 1e-21 < x < 1e21\n      // -70 < log2(x) < 70\n      e = toFixedHelpers.log(x * toFixedHelpers.pow(2, 69, 1)) - 69;\n      z = e < 0 ? x * toFixedHelpers.pow(2, -e, 1) : x / toFixedHelpers.pow(2, e, 1);\n      z *= 0x10000000000000; // Math.pow(2, 52);\n\n      e = 52 - e; // -18 < e < 122\n      // x = z / 2 ^ e\n\n      if (e > 0) {\n        toFixedHelpers.multiply(0, z);\n        j = f;\n\n        while (j >= 7) {\n          toFixedHelpers.multiply(1e7, 0);\n          j -= 7;\n        }\n\n        toFixedHelpers.multiply(toFixedHelpers.pow(10, j, 1), 0);\n        j = e - 1;\n\n        while (j >= 23) {\n          toFixedHelpers.divide(1 << 23);\n          j -= 23;\n        }\n\n        toFixedHelpers.divide(1 << j);\n        toFixedHelpers.multiply(1, 1);\n        toFixedHelpers.divide(2);\n        m = toFixedHelpers.numToString();\n      } else {\n        toFixedHelpers.multiply(0, z);\n        toFixedHelpers.multiply(1 << -e, 0);\n        m = toFixedHelpers.numToString() + strSlice('0.00000000000000000000', 2, 2 + f);\n      }\n    }\n\n    if (f > 0) {\n      k = m.length;\n\n      if (k <= f) {\n        m = s + strSlice('0.0000000000000000000', 0, f - k + 2) + m;\n      } else {\n        m = s + strSlice(m, 0, k - f) + '.' + strSlice(m, k - f);\n      }\n    } else {\n      m = s + m;\n    }\n\n    return m;\n  };\n\n  defineProperties(NumberPrototype, {\n    toFixed: toFixedShim\n  }, hasToFixedBugs);\n\n  var hasToPrecisionUndefinedBug = function () {\n    try {\n      return 1.0.toPrecision(undefined) === '1';\n    } catch (e) {\n      return true;\n    }\n  }();\n\n  var originalToPrecision = NumberPrototype.toPrecision;\n  defineProperties(NumberPrototype, {\n    toPrecision: function toPrecision(precision) {\n      return typeof precision === 'undefined' ? originalToPrecision.call(this) : originalToPrecision.call(this, precision);\n    }\n  }, hasToPrecisionUndefinedBug); //\n  // String\n  // ======\n  //\n  // ES5 15.5.4.14\n  // http://es5.github.com/#x15.5.4.14\n  // [bugfix, IE lt 9, firefox 4, Konqueror, Opera, obscure browsers]\n  // Many browsers do not split properly with regular expressions or they\n  // do not perform the split correctly under obscure conditions.\n  // See http://blog.stevenlevithan.com/archives/cross-browser-split\n  // I've tested in many browsers and this seems to cover the deviant ones:\n  //    'ab'.split(/(?:ab)*/) should be [\"\", \"\"], not [\"\"]\n  //    '.'.split(/(.?)(.?)/) should be [\"\", \".\", \"\", \"\"], not [\"\", \"\"]\n  //    'tesst'.split(/(s)*/) should be [\"t\", undefined, \"e\", \"s\", \"t\"], not\n  //       [undefined, \"t\", undefined, \"e\", ...]\n  //    ''.split(/.?/) should be [], not [\"\"]\n  //    '.'.split(/()()/) should be [\".\"], not [\"\", \"\", \".\"]\n\n  if ('ab'.split(/(?:ab)*/).length !== 2 || '.'.split(/(.?)(.?)/).length !== 4 || 'tesst'.split(/(s)*/)[1] === 't' || 'test'.split(/(?:)/, -1).length !== 4 || ''.split(/.?/).length || '.'.split(/()()/).length > 1) {\n    (function () {\n      var compliantExecNpcg = typeof /()??/.exec('')[1] === 'undefined'; // NPCG: nonparticipating capturing group\n\n      var maxSafe32BitInt = Math.pow(2, 32) - 1;\n\n      StringPrototype.split = function (separator, limit) {\n        var string = String(this);\n\n        if (typeof separator === 'undefined' && limit === 0) {\n          return [];\n        } // If `separator` is not a regex, use native split\n\n\n        if (!isRegex(separator)) {\n          return strSplit(this, separator, limit);\n        }\n\n        var output = [];\n        var flags = (separator.ignoreCase ? 'i' : '') + (separator.multiline ? 'm' : '') + (separator.unicode ? 'u' : '') // in ES6\n        + (separator.sticky ? 'y' : ''),\n            // Firefox 3+ and ES6\n        lastLastIndex = 0,\n            // Make `global` and avoid `lastIndex` issues by working with a copy\n        separator2,\n            match,\n            lastIndex,\n            lastLength;\n        var separatorCopy = new RegExp(separator.source, flags + 'g');\n\n        if (!compliantExecNpcg) {\n          // Doesn't need flags gy, but they don't hurt\n          separator2 = new RegExp('^' + separatorCopy.source + '$(?!\\\\s)', flags);\n        }\n        /* Values for `limit`, per the spec:\n         * If undefined: 4294967295 // maxSafe32BitInt\n         * If 0, Infinity, or NaN: 0\n         * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296;\n         * If negative number: 4294967296 - Math.floor(Math.abs(limit))\n         * If other: Type-convert, then use the above rules\n         */\n\n\n        var splitLimit = typeof limit === 'undefined' ? maxSafe32BitInt : ES.ToUint32(limit);\n        match = separatorCopy.exec(string);\n\n        while (match) {\n          // `separatorCopy.lastIndex` is not reliable cross-browser\n          lastIndex = match.index + match[0].length;\n\n          if (lastIndex > lastLastIndex) {\n            pushCall(output, strSlice(string, lastLastIndex, match.index)); // Fix browsers whose `exec` methods don't consistently return `undefined` for\n            // nonparticipating capturing groups\n\n            if (!compliantExecNpcg && match.length > 1) {\n              /* eslint-disable no-loop-func */\n              match[0].replace(separator2, function () {\n                for (var i = 1; i < arguments.length - 2; i++) {\n                  if (typeof arguments[i] === 'undefined') {\n                    match[i] = void 0;\n                  }\n                }\n              });\n              /* eslint-enable no-loop-func */\n            }\n\n            if (match.length > 1 && match.index < string.length) {\n              array_push.apply(output, arraySlice(match, 1));\n            }\n\n            lastLength = match[0].length;\n            lastLastIndex = lastIndex;\n\n            if (output.length >= splitLimit) {\n              break;\n            }\n          }\n\n          if (separatorCopy.lastIndex === match.index) {\n            separatorCopy.lastIndex++; // Avoid an infinite loop\n          }\n\n          match = separatorCopy.exec(string);\n        }\n\n        if (lastLastIndex === string.length) {\n          if (lastLength || !separatorCopy.test('')) {\n            pushCall(output, '');\n          }\n        } else {\n          pushCall(output, strSlice(string, lastLastIndex));\n        }\n\n        return output.length > splitLimit ? arraySlice(output, 0, splitLimit) : output;\n      };\n    })(); // [bugfix, chrome]\n    // If separator is undefined, then the result array contains just one String,\n    // which is the this value (converted to a String). If limit is not undefined,\n    // then the output array is truncated so that it contains no more than limit\n    // elements.\n    // \"0\".split(undefined, 0) -> []\n\n  } else if ('0'.split(void 0, 0).length) {\n    StringPrototype.split = function split(separator, limit) {\n      if (typeof separator === 'undefined' && limit === 0) {\n        return [];\n      }\n\n      return strSplit(this, separator, limit);\n    };\n  }\n\n  var str_replace = StringPrototype.replace;\n\n  var replaceReportsGroupsCorrectly = function () {\n    var groups = [];\n    'x'.replace(/x(.)?/g, function (match, group) {\n      pushCall(groups, group);\n    });\n    return groups.length === 1 && typeof groups[0] === 'undefined';\n  }();\n\n  if (!replaceReportsGroupsCorrectly) {\n    StringPrototype.replace = function replace(searchValue, replaceValue) {\n      var isFn = isCallable(replaceValue);\n      var hasCapturingGroups = isRegex(searchValue) && /\\)[*?]/.test(searchValue.source);\n\n      if (!isFn || !hasCapturingGroups) {\n        return str_replace.call(this, searchValue, replaceValue);\n      } else {\n        var wrappedReplaceValue = function wrappedReplaceValue(match) {\n          var length = arguments.length;\n          var originalLastIndex = searchValue.lastIndex;\n          searchValue.lastIndex = 0;\n          var args = searchValue.exec(match) || [];\n          searchValue.lastIndex = originalLastIndex;\n          pushCall(args, arguments[length - 2], arguments[length - 1]);\n          return replaceValue.apply(this, args);\n        };\n\n        return str_replace.call(this, searchValue, wrappedReplaceValue);\n      }\n    };\n  } // ECMA-262, 3rd B.2.3\n  // Not an ECMAScript standard, although ECMAScript 3rd Edition has a\n  // non-normative section suggesting uniform semantics and it should be\n  // normalized across all browsers\n  // [bugfix, IE lt 9] IE < 9 substr() with negative value not working in IE\n\n\n  var string_substr = StringPrototype.substr;\n  var hasNegativeSubstrBug = ''.substr && '0b'.substr(-1) !== 'b';\n  defineProperties(StringPrototype, {\n    substr: function substr(start, length) {\n      var normalizedStart = start;\n\n      if (start < 0) {\n        normalizedStart = max(this.length + start, 0);\n      }\n\n      return string_substr.call(this, normalizedStart, length);\n    }\n  }, hasNegativeSubstrBug); // ES5 15.5.4.20\n  // whitespace from: http://es5.github.io/#x15.5.4.20\n\n  var ws = \"\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\" + \"\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\" + \"\\u2029\\uFEFF\";\n  var zeroWidth = \"\\u200B\";\n  var wsRegexChars = '[' + ws + ']';\n  var trimBeginRegexp = new RegExp('^' + wsRegexChars + wsRegexChars + '*');\n  var trimEndRegexp = new RegExp(wsRegexChars + wsRegexChars + '*$');\n  var hasTrimWhitespaceBug = StringPrototype.trim && (ws.trim() || !zeroWidth.trim());\n  defineProperties(StringPrototype, {\n    // http://blog.stevenlevithan.com/archives/faster-trim-javascript\n    // http://perfectionkills.com/whitespace-deviations/\n    trim: function trim() {\n      if (typeof this === 'undefined' || this === null) {\n        throw new TypeError(\"can't convert \" + this + ' to object');\n      }\n\n      return $String(this).replace(trimBeginRegexp, '').replace(trimEndRegexp, '');\n    }\n  }, hasTrimWhitespaceBug);\n  var trim = call.bind(String.prototype.trim);\n  var hasLastIndexBug = StringPrototype.lastIndexOf && 'abcあい'.lastIndexOf('あい', 2) !== -1;\n  defineProperties(StringPrototype, {\n    lastIndexOf: function lastIndexOf(searchString) {\n      if (typeof this === 'undefined' || this === null) {\n        throw new TypeError(\"can't convert \" + this + ' to object');\n      }\n\n      var S = $String(this);\n      var searchStr = $String(searchString);\n      var numPos = arguments.length > 1 ? $Number(arguments[1]) : NaN;\n      var pos = isActualNaN(numPos) ? Infinity : ES.ToInteger(numPos);\n      var start = min(max(pos, 0), S.length);\n      var searchLen = searchStr.length;\n      var k = start + searchLen;\n\n      while (k > 0) {\n        k = max(0, k - searchLen);\n        var index = strIndexOf(strSlice(S, k, start + searchLen), searchStr);\n\n        if (index !== -1) {\n          return k + index;\n        }\n      }\n\n      return -1;\n    }\n  }, hasLastIndexBug);\n  var originalLastIndexOf = StringPrototype.lastIndexOf;\n  defineProperties(StringPrototype, {\n    lastIndexOf: function lastIndexOf(searchString) {\n      return originalLastIndexOf.apply(this, arguments);\n    }\n  }, StringPrototype.lastIndexOf.length !== 1); // ES-5 15.1.2.2\n  // eslint-disable-next-line radix\n\n  if (parseInt(ws + '08') !== 8 || parseInt(ws + '0x16') !== 22) {\n    /* global parseInt: true */\n    parseInt = function (origParseInt) {\n      var hexRegex = /^[-+]?0[xX]/;\n      return function parseInt(str, radix) {\n        if (_typeof(str) === 'symbol') {\n          // handle Symbols in node 8.3/8.4\n          // eslint-disable-next-line no-implicit-coercion, no-unused-expressions\n          '' + str; // jscs:ignore disallowImplicitTypeConversion\n        }\n\n        var string = trim(String(str));\n        var defaultedRadix = $Number(radix) || (hexRegex.test(string) ? 16 : 10);\n        return origParseInt(string, defaultedRadix);\n      };\n    }(parseInt);\n  } // https://es5.github.io/#x15.1.2.3\n\n\n  if (1 / parseFloat('-0') !== -Infinity) {\n    /* global parseFloat: true */\n    parseFloat = function (origParseFloat) {\n      return function parseFloat(string) {\n        var inputString = trim(String(string));\n        var result = origParseFloat(inputString);\n        return result === 0 && strSlice(inputString, 0, 1) === '-' ? -0 : result;\n      };\n    }(parseFloat);\n  }\n\n  if (String(new RangeError('test')) !== 'RangeError: test') {\n    var errorToStringShim = function toString() {\n      if (typeof this === 'undefined' || this === null) {\n        throw new TypeError(\"can't convert \" + this + ' to object');\n      }\n\n      var name = this.name;\n\n      if (typeof name === 'undefined') {\n        name = 'Error';\n      } else if (typeof name !== 'string') {\n        name = $String(name);\n      }\n\n      var msg = this.message;\n\n      if (typeof msg === 'undefined') {\n        msg = '';\n      } else if (typeof msg !== 'string') {\n        msg = $String(msg);\n      }\n\n      if (!name) {\n        return msg;\n      }\n\n      if (!msg) {\n        return name;\n      }\n\n      return name + ': ' + msg;\n    }; // can't use defineProperties here because of toString enumeration issue in IE <= 8\n\n\n    Error.prototype.toString = errorToStringShim;\n  }\n\n  if (supportsDescriptors) {\n    var ensureNonEnumerable = function ensureNonEnumerable(obj, prop) {\n      if (isEnum(obj, prop)) {\n        var desc = Object.getOwnPropertyDescriptor(obj, prop);\n\n        if (desc.configurable) {\n          desc.enumerable = false;\n          Object.defineProperty(obj, prop, desc);\n        }\n      }\n    };\n\n    ensureNonEnumerable(Error.prototype, 'message');\n\n    if (Error.prototype.message !== '') {\n      Error.prototype.message = '';\n    }\n\n    ensureNonEnumerable(Error.prototype, 'name');\n  }\n\n  if (String(/a/mig) !== '/a/gim') {\n    var regexToString = function toString() {\n      var str = '/' + this.source + '/';\n\n      if (this.global) {\n        str += 'g';\n      }\n\n      if (this.ignoreCase) {\n        str += 'i';\n      }\n\n      if (this.multiline) {\n        str += 'm';\n      }\n\n      return str;\n    }; // can't use defineProperties here because of toString enumeration issue in IE <= 8\n\n\n    RegExp.prototype.toString = regexToString;\n  }\n});","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\n/*!\n * https://github.com/paulmillr/es6-shim\n * @license es6-shim Copyright 2013-2016 by Paul Miller (http://paulmillr.com)\n *   and contributors,  MIT License\n * es6-shim: v0.35.4\n * see https://github.com/paulmillr/es6-shim/blob/0.35.3/LICENSE\n * Details and documentation:\n * https://github.com/paulmillr/es6-shim/\n */\n// UMD (Universal Module Definition)\n// see https://github.com/umdjs/umd/blob/master/returnExports.js\n(function (root, factory) {\n  /*global define, module, exports */\n  if (typeof define === 'function' && define.amd) {\n    // AMD. Register as an anonymous module.\n    define(factory);\n  } else if ((typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) === 'object') {\n    // Node. Does not work with strict CommonJS, but\n    // only CommonJS-like environments that support module.exports,\n    // like Node.\n    module.exports = factory();\n  } else {\n    // Browser globals (root is window)\n    root.returnExports = factory();\n  }\n})(this, function () {\n  'use strict';\n\n  var _apply = Function.call.bind(Function.apply);\n\n  var _call = Function.call.bind(Function.call);\n\n  var isArray = Array.isArray;\n  var keys = Object.keys;\n\n  var not = function notThunker(func) {\n    return function notThunk() {\n      return !_apply(func, this, arguments);\n    };\n  };\n\n  var throwsError = function throwsError(func) {\n    try {\n      func();\n      return false;\n    } catch (e) {\n      return true;\n    }\n  };\n\n  var valueOrFalseIfThrows = function valueOrFalseIfThrows(func) {\n    try {\n      return func();\n    } catch (e) {\n      return false;\n    }\n  };\n\n  var isCallableWithoutNew = not(throwsError);\n\n  var arePropertyDescriptorsSupported = function arePropertyDescriptorsSupported() {\n    // if Object.defineProperty exists but throws, it's IE 8\n    return !throwsError(function () {\n      return Object.defineProperty({}, 'x', {\n        get: function get() {}\n      }); // eslint-disable-line getter-return\n    });\n  };\n\n  var supportsDescriptors = !!Object.defineProperty && arePropertyDescriptorsSupported();\n\n  var functionsHaveNames = function foo() {}.name === 'foo'; // eslint-disable-line no-extra-parens\n\n\n  var _forEach = Function.call.bind(Array.prototype.forEach);\n\n  var _reduce = Function.call.bind(Array.prototype.reduce);\n\n  var _filter = Function.call.bind(Array.prototype.filter);\n\n  var _some = Function.call.bind(Array.prototype.some);\n\n  var defineProperty = function defineProperty(object, name, value, force) {\n    if (!force && name in object) {\n      return;\n    }\n\n    if (supportsDescriptors) {\n      Object.defineProperty(object, name, {\n        configurable: true,\n        enumerable: false,\n        writable: true,\n        value: value\n      });\n    } else {\n      object[name] = value;\n    }\n  }; // Define configurable, writable and non-enumerable props\n  // if they don’t exist.\n\n\n  var defineProperties = function defineProperties(object, map, forceOverride) {\n    _forEach(keys(map), function (name) {\n      var method = map[name];\n      defineProperty(object, name, method, !!forceOverride);\n    });\n  };\n\n  var _toString = Function.call.bind(Object.prototype.toString);\n\n  var isCallable = typeof /abc/ === 'function' ? function IsCallableSlow(x) {\n    // Some old browsers (IE, FF) say that typeof /abc/ === 'function'\n    return typeof x === 'function' && _toString(x) === '[object Function]';\n  } : function IsCallableFast(x) {\n    return typeof x === 'function';\n  };\n  var Value = {\n    getter: function getter(object, name, _getter) {\n      if (!supportsDescriptors) {\n        throw new TypeError('getters require true ES5 support');\n      }\n\n      Object.defineProperty(object, name, {\n        configurable: true,\n        enumerable: false,\n        get: _getter\n      });\n    },\n    proxy: function proxy(originalObject, key, targetObject) {\n      if (!supportsDescriptors) {\n        throw new TypeError('getters require true ES5 support');\n      }\n\n      var originalDescriptor = Object.getOwnPropertyDescriptor(originalObject, key);\n      Object.defineProperty(targetObject, key, {\n        configurable: originalDescriptor.configurable,\n        enumerable: originalDescriptor.enumerable,\n        get: function getKey() {\n          return originalObject[key];\n        },\n        set: function setKey(value) {\n          originalObject[key] = value;\n        }\n      });\n    },\n    redefine: function redefine(object, property, newValue) {\n      if (supportsDescriptors) {\n        var descriptor = Object.getOwnPropertyDescriptor(object, property);\n        descriptor.value = newValue;\n        Object.defineProperty(object, property, descriptor);\n      } else {\n        object[property] = newValue;\n      }\n    },\n    defineByDescriptor: function defineByDescriptor(object, property, descriptor) {\n      if (supportsDescriptors) {\n        Object.defineProperty(object, property, descriptor);\n      } else if ('value' in descriptor) {\n        object[property] = descriptor.value;\n      }\n    },\n    preserveToString: function preserveToString(target, source) {\n      if (source && isCallable(source.toString)) {\n        defineProperty(target, 'toString', source.toString.bind(source), true);\n      }\n    }\n  }; // Simple shim for Object.create on ES3 browsers\n  // (unlike real shim, no attempt to support `prototype === null`)\n\n  var create = Object.create || function (prototype, properties) {\n    var Prototype = function Prototype() {};\n\n    Prototype.prototype = prototype;\n    var object = new Prototype();\n\n    if (typeof properties !== 'undefined') {\n      keys(properties).forEach(function (key) {\n        Value.defineByDescriptor(object, key, properties[key]);\n      });\n    }\n\n    return object;\n  };\n\n  var supportsSubclassing = function supportsSubclassing(C, f) {\n    if (!Object.setPrototypeOf) {\n      return false;\n      /* skip test on IE < 11 */\n    }\n\n    return valueOrFalseIfThrows(function () {\n      var Sub = function Subclass(arg) {\n        var o = new C(arg);\n        Object.setPrototypeOf(o, Subclass.prototype);\n        return o;\n      };\n\n      Object.setPrototypeOf(Sub, C);\n      Sub.prototype = create(C.prototype, {\n        constructor: {\n          value: Sub\n        }\n      });\n      return f(Sub);\n    });\n  };\n\n  var getGlobal = function getGlobal() {\n    /* global self, window, global */\n    // the only reliable means to get the global object is\n    // `Function('return this')()`\n    // However, this causes CSP violations in Chrome apps.\n    if (typeof self !== 'undefined') {\n      return self;\n    }\n\n    if (typeof window !== 'undefined') {\n      return window;\n    }\n\n    if (typeof global !== 'undefined') {\n      return global;\n    }\n\n    throw new Error('unable to locate global object');\n  };\n\n  var globals = getGlobal();\n  var globalIsFinite = globals.isFinite;\n\n  var _indexOf = Function.call.bind(String.prototype.indexOf);\n\n  var _arrayIndexOfApply = Function.apply.bind(Array.prototype.indexOf);\n\n  var _concat = Function.call.bind(Array.prototype.concat); // var _sort = Function.call.bind(Array.prototype.sort);\n\n\n  var _strSlice = Function.call.bind(String.prototype.slice);\n\n  var _push = Function.call.bind(Array.prototype.push);\n\n  var _pushApply = Function.apply.bind(Array.prototype.push);\n\n  var _shift = Function.call.bind(Array.prototype.shift);\n\n  var _max = Math.max;\n  var _min = Math.min;\n  var _floor = Math.floor;\n  var _abs = Math.abs;\n  var _exp = Math.exp;\n  var _log = Math.log;\n  var _sqrt = Math.sqrt;\n\n  var _hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty);\n\n  var ArrayIterator; // make our implementation private\n\n  var noop = function noop() {};\n\n  var OrigMap = globals.Map;\n  var origMapDelete = OrigMap && OrigMap.prototype['delete'];\n  var origMapGet = OrigMap && OrigMap.prototype.get;\n  var origMapHas = OrigMap && OrigMap.prototype.has;\n  var origMapSet = OrigMap && OrigMap.prototype.set;\n\n  var _Symbol = globals.Symbol || {};\n\n  var symbolSpecies = _Symbol.species || '@@species';\n\n  var numberIsNaN = Number.isNaN || function isNaN(value) {\n    // NaN !== NaN, but they are identical.\n    // NaNs are the only non-reflexive value, i.e., if x !== x,\n    // then x is NaN.\n    // isNaN is broken: it converts its argument to number, so\n    // isNaN('foo') => true\n    return value !== value;\n  };\n\n  var numberIsFinite = Number.isFinite || function isFinite(value) {\n    return typeof value === 'number' && globalIsFinite(value);\n  };\n\n  var _sign = isCallable(Math.sign) ? Math.sign : function sign(value) {\n    var number = Number(value);\n\n    if (number === 0) {\n      return number;\n    }\n\n    if (numberIsNaN(number)) {\n      return number;\n    }\n\n    return number < 0 ? -1 : 1;\n  };\n\n  var _log1p = function log1p(value) {\n    var x = Number(value);\n\n    if (x < -1 || numberIsNaN(x)) {\n      return NaN;\n    }\n\n    if (x === 0 || x === Infinity) {\n      return x;\n    }\n\n    if (x === -1) {\n      return -Infinity;\n    }\n\n    return 1 + x - 1 === 0 ? x : x * (_log(1 + x) / (1 + x - 1));\n  }; // taken directly from https://github.com/ljharb/is-arguments/blob/master/index.js\n  // can be replaced with require('is-arguments') if we ever use a build process instead\n\n\n  var isStandardArguments = function isArguments(value) {\n    return _toString(value) === '[object Arguments]';\n  };\n\n  var isLegacyArguments = function isArguments(value) {\n    return value !== null && _typeof(value) === 'object' && typeof value.length === 'number' && value.length >= 0 && _toString(value) !== '[object Array]' && _toString(value.callee) === '[object Function]';\n  };\n\n  var isArguments = isStandardArguments(arguments) ? isStandardArguments : isLegacyArguments;\n  var Type = {\n    primitive: function primitive(x) {\n      return x === null || typeof x !== 'function' && _typeof(x) !== 'object';\n    },\n    string: function string(x) {\n      return _toString(x) === '[object String]';\n    },\n    regex: function regex(x) {\n      return _toString(x) === '[object RegExp]';\n    },\n    symbol: function symbol(x) {\n      return typeof globals.Symbol === 'function' && _typeof(x) === 'symbol';\n    }\n  };\n\n  var overrideNative = function overrideNative(object, property, replacement) {\n    var original = object[property];\n    defineProperty(object, property, replacement, true);\n    Value.preserveToString(object[property], original);\n  }; // eslint-disable-next-line no-restricted-properties\n\n\n  var hasSymbols = typeof _Symbol === 'function' && typeof _Symbol['for'] === 'function' && Type.symbol(_Symbol()); // This is a private name in the es6 spec, equal to '[Symbol.iterator]'\n  // we're going to use an arbitrary _-prefixed name to make our shims\n  // work properly with each other, even though we don't have full Iterator\n  // support.  That is, `Array.from(map.keys())` will work, but we don't\n  // pretend to export a \"real\" Iterator interface.\n\n  var $iterator$ = Type.symbol(_Symbol.iterator) ? _Symbol.iterator : '_es6-shim iterator_'; // Firefox ships a partial implementation using the name @@iterator.\n  // https://bugzilla.mozilla.org/show_bug.cgi?id=907077#c14\n  // So use that name if we detect it.\n\n  if (globals.Set && typeof new globals.Set()['@@iterator'] === 'function') {\n    $iterator$ = '@@iterator';\n  } // Reflect\n\n\n  if (!globals.Reflect) {\n    defineProperty(globals, 'Reflect', {}, true);\n  }\n\n  var Reflect = globals.Reflect;\n  var $String = String;\n  /* global document */\n\n  var domAll = typeof document === 'undefined' || !document ? null : document.all;\n  var isNullOrUndefined = domAll == null ? function isNullOrUndefined(x) {\n    return x == null;\n  } : function isNullOrUndefinedAndNotDocumentAll(x) {\n    return x == null && x !== domAll;\n  };\n  var ES = {\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-call\n    Call: function Call(F, V) {\n      var args = arguments.length > 2 ? arguments[2] : [];\n\n      if (!ES.IsCallable(F)) {\n        throw new TypeError(F + ' is not a function');\n      }\n\n      return _apply(F, V, args);\n    },\n    RequireObjectCoercible: function RequireObjectCoercible(x, optMessage) {\n      if (isNullOrUndefined(x)) {\n        throw new TypeError(optMessage || 'Cannot call method on ' + x);\n      }\n\n      return x;\n    },\n    // This might miss the \"(non-standard exotic and does not implement\n    // [[Call]])\" case from\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-typeof-operator-runtime-semantics-evaluation\n    // but we can't find any evidence these objects exist in practice.\n    // If we find some in the future, you could test `Object(x) === x`,\n    // which is reliable according to\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toobject\n    // but is not well optimized by runtimes and creates an object\n    // whenever it returns false, and thus is very slow.\n    TypeIsObject: function TypeIsObject(x) {\n      if (x === void 0 || x === null || x === true || x === false) {\n        return false;\n      }\n\n      return typeof x === 'function' || _typeof(x) === 'object' || x === domAll;\n    },\n    ToObject: function ToObject(o, optMessage) {\n      return Object(ES.RequireObjectCoercible(o, optMessage));\n    },\n    IsCallable: isCallable,\n    IsConstructor: function IsConstructor(x) {\n      // We can't tell callables from constructors in ES5\n      return ES.IsCallable(x);\n    },\n    ToInt32: function ToInt32(x) {\n      return ES.ToNumber(x) >> 0;\n    },\n    ToUint32: function ToUint32(x) {\n      return ES.ToNumber(x) >>> 0;\n    },\n    ToNumber: function ToNumber(value) {\n      if (_toString(value) === '[object Symbol]') {\n        throw new TypeError('Cannot convert a Symbol value to a number');\n      }\n\n      return +value;\n    },\n    ToInteger: function ToInteger(value) {\n      var number = ES.ToNumber(value);\n\n      if (numberIsNaN(number)) {\n        return 0;\n      }\n\n      if (number === 0 || !numberIsFinite(number)) {\n        return number;\n      }\n\n      return (number > 0 ? 1 : -1) * _floor(_abs(number));\n    },\n    ToLength: function ToLength(value) {\n      var len = ES.ToInteger(value);\n\n      if (len <= 0) {\n        return 0;\n      } // includes converting -0 to +0\n\n\n      if (len > Number.MAX_SAFE_INTEGER) {\n        return Number.MAX_SAFE_INTEGER;\n      }\n\n      return len;\n    },\n    SameValue: function SameValue(a, b) {\n      if (a === b) {\n        // 0 === -0, but they are not identical.\n        if (a === 0) {\n          return 1 / a === 1 / b;\n        }\n\n        return true;\n      }\n\n      return numberIsNaN(a) && numberIsNaN(b);\n    },\n    SameValueZero: function SameValueZero(a, b) {\n      // same as SameValue except for SameValueZero(+0, -0) == true\n      return a === b || numberIsNaN(a) && numberIsNaN(b);\n    },\n    IsIterable: function IsIterable(o) {\n      return ES.TypeIsObject(o) && (typeof o[$iterator$] !== 'undefined' || isArguments(o));\n    },\n    GetIterator: function GetIterator(o) {\n      if (isArguments(o)) {\n        // special case support for `arguments`\n        return new ArrayIterator(o, 'value');\n      }\n\n      var itFn = ES.GetMethod(o, $iterator$);\n\n      if (!ES.IsCallable(itFn)) {\n        // Better diagnostics if itFn is null or undefined\n        throw new TypeError('value is not an iterable');\n      }\n\n      var it = ES.Call(itFn, o);\n\n      if (!ES.TypeIsObject(it)) {\n        throw new TypeError('bad iterator');\n      }\n\n      return it;\n    },\n    GetMethod: function GetMethod(o, p) {\n      var func = ES.ToObject(o)[p];\n\n      if (isNullOrUndefined(func)) {\n        return void 0;\n      }\n\n      if (!ES.IsCallable(func)) {\n        throw new TypeError('Method not callable: ' + p);\n      }\n\n      return func;\n    },\n    IteratorComplete: function IteratorComplete(iterResult) {\n      return !!iterResult.done;\n    },\n    IteratorClose: function IteratorClose(iterator, completionIsThrow) {\n      var returnMethod = ES.GetMethod(iterator, 'return');\n\n      if (returnMethod === void 0) {\n        return;\n      }\n\n      var innerResult, innerException;\n\n      try {\n        innerResult = ES.Call(returnMethod, iterator);\n      } catch (e) {\n        innerException = e;\n      }\n\n      if (completionIsThrow) {\n        return;\n      }\n\n      if (innerException) {\n        throw innerException;\n      }\n\n      if (!ES.TypeIsObject(innerResult)) {\n        throw new TypeError(\"Iterator's return method returned a non-object.\");\n      }\n    },\n    IteratorNext: function IteratorNext(it) {\n      var result = arguments.length > 1 ? it.next(arguments[1]) : it.next();\n\n      if (!ES.TypeIsObject(result)) {\n        throw new TypeError('bad iterator');\n      }\n\n      return result;\n    },\n    IteratorStep: function IteratorStep(it) {\n      var result = ES.IteratorNext(it);\n      var done = ES.IteratorComplete(result);\n      return done ? false : result;\n    },\n    Construct: function Construct(C, args, newTarget, isES6internal) {\n      var target = typeof newTarget === 'undefined' ? C : newTarget;\n\n      if (!isES6internal && Reflect.construct) {\n        // Try to use Reflect.construct if available\n        return Reflect.construct(C, args, target);\n      } // OK, we have to fake it.  This will only work if the\n      // C.[[ConstructorKind]] == \"base\" -- but that's the only\n      // kind we can make in ES5 code anyway.\n      // OrdinaryCreateFromConstructor(target, \"%ObjectPrototype%\")\n\n\n      var proto = target.prototype;\n\n      if (!ES.TypeIsObject(proto)) {\n        proto = Object.prototype;\n      }\n\n      var obj = create(proto); // Call the constructor.\n\n      var result = ES.Call(C, obj, args);\n      return ES.TypeIsObject(result) ? result : obj;\n    },\n    SpeciesConstructor: function SpeciesConstructor(O, defaultConstructor) {\n      var C = O.constructor;\n\n      if (C === void 0) {\n        return defaultConstructor;\n      }\n\n      if (!ES.TypeIsObject(C)) {\n        throw new TypeError('Bad constructor');\n      }\n\n      var S = C[symbolSpecies];\n\n      if (isNullOrUndefined(S)) {\n        return defaultConstructor;\n      }\n\n      if (!ES.IsConstructor(S)) {\n        throw new TypeError('Bad @@species');\n      }\n\n      return S;\n    },\n    CreateHTML: function CreateHTML(string, tag, attribute, value) {\n      var S = ES.ToString(string);\n      var p1 = '<' + tag;\n\n      if (attribute !== '') {\n        var V = ES.ToString(value);\n        var escapedV = V.replace(/\"/g, '&quot;');\n        p1 += ' ' + attribute + '=\"' + escapedV + '\"';\n      }\n\n      var p2 = p1 + '>';\n      var p3 = p2 + S;\n      return p3 + '</' + tag + '>';\n    },\n    IsRegExp: function IsRegExp(argument) {\n      if (!ES.TypeIsObject(argument)) {\n        return false;\n      }\n\n      var isRegExp = argument[_Symbol.match];\n\n      if (typeof isRegExp !== 'undefined') {\n        return !!isRegExp;\n      }\n\n      return Type.regex(argument);\n    },\n    ToString: function ToString(string) {\n      return $String(string);\n    }\n  }; // Well-known Symbol shims\n\n  if (supportsDescriptors && hasSymbols) {\n    var defineWellKnownSymbol = function defineWellKnownSymbol(name) {\n      if (Type.symbol(_Symbol[name])) {\n        return _Symbol[name];\n      } // eslint-disable-next-line no-restricted-properties\n\n\n      var sym = _Symbol['for']('Symbol.' + name);\n\n      Object.defineProperty(_Symbol, name, {\n        configurable: false,\n        enumerable: false,\n        writable: false,\n        value: sym\n      });\n      return sym;\n    };\n\n    if (!Type.symbol(_Symbol.search)) {\n      var symbolSearch = defineWellKnownSymbol('search');\n      var originalSearch = String.prototype.search;\n      defineProperty(RegExp.prototype, symbolSearch, function search(string) {\n        return ES.Call(originalSearch, string, [this]);\n      });\n\n      var searchShim = function search(regexp) {\n        var O = ES.RequireObjectCoercible(this);\n\n        if (!isNullOrUndefined(regexp)) {\n          var searcher = ES.GetMethod(regexp, symbolSearch);\n\n          if (typeof searcher !== 'undefined') {\n            return ES.Call(searcher, regexp, [O]);\n          }\n        }\n\n        return ES.Call(originalSearch, O, [ES.ToString(regexp)]);\n      };\n\n      overrideNative(String.prototype, 'search', searchShim);\n    }\n\n    if (!Type.symbol(_Symbol.replace)) {\n      var symbolReplace = defineWellKnownSymbol('replace');\n      var originalReplace = String.prototype.replace;\n      defineProperty(RegExp.prototype, symbolReplace, function replace(string, replaceValue) {\n        return ES.Call(originalReplace, string, [this, replaceValue]);\n      });\n\n      var replaceShim = function replace(searchValue, replaceValue) {\n        var O = ES.RequireObjectCoercible(this);\n\n        if (!isNullOrUndefined(searchValue)) {\n          var replacer = ES.GetMethod(searchValue, symbolReplace);\n\n          if (typeof replacer !== 'undefined') {\n            return ES.Call(replacer, searchValue, [O, replaceValue]);\n          }\n        }\n\n        return ES.Call(originalReplace, O, [ES.ToString(searchValue), replaceValue]);\n      };\n\n      overrideNative(String.prototype, 'replace', replaceShim);\n    }\n\n    if (!Type.symbol(_Symbol.split)) {\n      var symbolSplit = defineWellKnownSymbol('split');\n      var originalSplit = String.prototype.split;\n      defineProperty(RegExp.prototype, symbolSplit, function split(string, limit) {\n        return ES.Call(originalSplit, string, [this, limit]);\n      });\n\n      var splitShim = function split(separator, limit) {\n        var O = ES.RequireObjectCoercible(this);\n\n        if (!isNullOrUndefined(separator)) {\n          var splitter = ES.GetMethod(separator, symbolSplit);\n\n          if (typeof splitter !== 'undefined') {\n            return ES.Call(splitter, separator, [O, limit]);\n          }\n        }\n\n        return ES.Call(originalSplit, O, [ES.ToString(separator), limit]);\n      };\n\n      overrideNative(String.prototype, 'split', splitShim);\n    }\n\n    var symbolMatchExists = Type.symbol(_Symbol.match);\n\n    var stringMatchIgnoresSymbolMatch = symbolMatchExists && function () {\n      // Firefox 41, through Nightly 45 has Symbol.match, but String#match ignores it.\n      // Firefox 40 and below have Symbol.match but String#match works fine.\n      var o = {};\n\n      o[_Symbol.match] = function () {\n        return 42;\n      };\n\n      return 'a'.match(o) !== 42;\n    }();\n\n    if (!symbolMatchExists || stringMatchIgnoresSymbolMatch) {\n      var symbolMatch = defineWellKnownSymbol('match');\n      var originalMatch = String.prototype.match;\n      defineProperty(RegExp.prototype, symbolMatch, function match(string) {\n        return ES.Call(originalMatch, string, [this]);\n      });\n\n      var matchShim = function match(regexp) {\n        var O = ES.RequireObjectCoercible(this);\n\n        if (!isNullOrUndefined(regexp)) {\n          var matcher = ES.GetMethod(regexp, symbolMatch);\n\n          if (typeof matcher !== 'undefined') {\n            return ES.Call(matcher, regexp, [O]);\n          }\n        }\n\n        return ES.Call(originalMatch, O, [ES.ToString(regexp)]);\n      };\n\n      overrideNative(String.prototype, 'match', matchShim);\n    }\n  }\n\n  var wrapConstructor = function wrapConstructor(original, replacement, keysToSkip) {\n    Value.preserveToString(replacement, original);\n\n    if (Object.setPrototypeOf) {\n      // sets up proper prototype chain where possible\n      Object.setPrototypeOf(original, replacement);\n    }\n\n    if (supportsDescriptors) {\n      _forEach(Object.getOwnPropertyNames(original), function (key) {\n        if (key in noop || keysToSkip[key]) {\n          return;\n        }\n\n        Value.proxy(original, key, replacement);\n      });\n    } else {\n      _forEach(Object.keys(original), function (key) {\n        if (key in noop || keysToSkip[key]) {\n          return;\n        }\n\n        replacement[key] = original[key];\n      });\n    }\n\n    replacement.prototype = original.prototype;\n    Value.redefine(original.prototype, 'constructor', replacement);\n  };\n\n  var defaultSpeciesGetter = function defaultSpeciesGetter() {\n    return this;\n  };\n\n  var addDefaultSpecies = function addDefaultSpecies(C) {\n    if (supportsDescriptors && !_hasOwnProperty(C, symbolSpecies)) {\n      Value.getter(C, symbolSpecies, defaultSpeciesGetter);\n    }\n  };\n\n  var addIterator = function addIterator(prototype, impl) {\n    var implementation = impl || function iterator() {\n      return this;\n    };\n\n    defineProperty(prototype, $iterator$, implementation);\n\n    if (!prototype[$iterator$] && Type.symbol($iterator$)) {\n      // implementations are buggy when $iterator$ is a Symbol\n      prototype[$iterator$] = implementation;\n    }\n  };\n\n  var createDataProperty = function createDataProperty(object, name, value) {\n    if (supportsDescriptors) {\n      Object.defineProperty(object, name, {\n        configurable: true,\n        enumerable: true,\n        writable: true,\n        value: value\n      });\n    } else {\n      object[name] = value;\n    }\n  };\n\n  var createDataPropertyOrThrow = function createDataPropertyOrThrow(object, name, value) {\n    createDataProperty(object, name, value);\n\n    if (!ES.SameValue(object[name], value)) {\n      throw new TypeError('property is nonconfigurable');\n    }\n  };\n\n  var emulateES6construct = function emulateES6construct(o, defaultNewTarget, defaultProto, slots) {\n    // This is an es5 approximation to es6 construct semantics.  in es6,\n    // 'new Foo' invokes Foo.[[Construct]] which (for almost all objects)\n    // just sets the internal variable NewTarget (in es6 syntax `new.target`)\n    // to Foo and then returns Foo().\n    // Many ES6 object then have constructors of the form:\n    // 1. If NewTarget is undefined, throw a TypeError exception\n    // 2. Let xxx by OrdinaryCreateFromConstructor(NewTarget, yyy, zzz)\n    // So we're going to emulate those first two steps.\n    if (!ES.TypeIsObject(o)) {\n      throw new TypeError('Constructor requires `new`: ' + defaultNewTarget.name);\n    }\n\n    var proto = defaultNewTarget.prototype;\n\n    if (!ES.TypeIsObject(proto)) {\n      proto = defaultProto;\n    }\n\n    var obj = create(proto);\n\n    for (var name in slots) {\n      if (_hasOwnProperty(slots, name)) {\n        var value = slots[name];\n        defineProperty(obj, name, value, true);\n      }\n    }\n\n    return obj;\n  }; // Firefox 31 reports this function's length as 0\n  // https://bugzilla.mozilla.org/show_bug.cgi?id=1062484\n\n\n  if (String.fromCodePoint && String.fromCodePoint.length !== 1) {\n    var originalFromCodePoint = String.fromCodePoint;\n    overrideNative(String, 'fromCodePoint', function fromCodePoint(codePoints) {\n      return ES.Call(originalFromCodePoint, this, arguments);\n    });\n  }\n\n  var StringShims = {\n    fromCodePoint: function fromCodePoint(codePoints) {\n      var result = [];\n      var next;\n\n      for (var i = 0, length = arguments.length; i < length; i++) {\n        next = Number(arguments[i]);\n\n        if (!ES.SameValue(next, ES.ToInteger(next)) || next < 0 || next > 0x10FFFF) {\n          throw new RangeError('Invalid code point ' + next);\n        }\n\n        if (next < 0x10000) {\n          _push(result, String.fromCharCode(next));\n        } else {\n          next -= 0x10000;\n\n          _push(result, String.fromCharCode((next >> 10) + 0xD800));\n\n          _push(result, String.fromCharCode(next % 0x400 + 0xDC00));\n        }\n      }\n\n      return result.join('');\n    },\n    raw: function raw(callSite) {\n      var cooked = ES.ToObject(callSite, 'bad callSite');\n      var rawString = ES.ToObject(cooked.raw, 'bad raw value');\n      var len = rawString.length;\n      var literalsegments = ES.ToLength(len);\n\n      if (literalsegments <= 0) {\n        return '';\n      }\n\n      var stringElements = [];\n      var nextIndex = 0;\n      var nextKey, next, nextSeg, nextSub;\n\n      while (nextIndex < literalsegments) {\n        nextKey = ES.ToString(nextIndex);\n        nextSeg = ES.ToString(rawString[nextKey]);\n\n        _push(stringElements, nextSeg);\n\n        if (nextIndex + 1 >= literalsegments) {\n          break;\n        }\n\n        next = nextIndex + 1 < arguments.length ? arguments[nextIndex + 1] : '';\n        nextSub = ES.ToString(next);\n\n        _push(stringElements, nextSub);\n\n        nextIndex += 1;\n      }\n\n      return stringElements.join('');\n    }\n  };\n\n  if (String.raw && String.raw({\n    raw: {\n      0: 'x',\n      1: 'y',\n      length: 2\n    }\n  }) !== 'xy') {\n    // IE 11 TP has a broken String.raw implementation\n    overrideNative(String, 'raw', StringShims.raw);\n  }\n\n  defineProperties(String, StringShims); // Fast repeat, uses the `Exponentiation by squaring` algorithm.\n  // Perf: http://jsperf.com/string-repeat2/2\n\n  var stringRepeat = function repeat(s, times) {\n    if (times < 1) {\n      return '';\n    }\n\n    if (times % 2) {\n      return repeat(s, times - 1) + s;\n    }\n\n    var half = repeat(s, times / 2);\n    return half + half;\n  };\n\n  var stringMaxLength = Infinity;\n  var StringPrototypeShims = {\n    repeat: function repeat(times) {\n      var thisStr = ES.ToString(ES.RequireObjectCoercible(this));\n      var numTimes = ES.ToInteger(times);\n\n      if (numTimes < 0 || numTimes >= stringMaxLength) {\n        throw new RangeError('repeat count must be less than infinity and not overflow maximum string size');\n      }\n\n      return stringRepeat(thisStr, numTimes);\n    },\n    startsWith: function startsWith(searchString) {\n      var S = ES.ToString(ES.RequireObjectCoercible(this));\n\n      if (ES.IsRegExp(searchString)) {\n        throw new TypeError('Cannot call method \"startsWith\" with a regex');\n      }\n\n      var searchStr = ES.ToString(searchString);\n      var position;\n\n      if (arguments.length > 1) {\n        position = arguments[1];\n      }\n\n      var start = _max(ES.ToInteger(position), 0);\n\n      return _strSlice(S, start, start + searchStr.length) === searchStr;\n    },\n    endsWith: function endsWith(searchString) {\n      var S = ES.ToString(ES.RequireObjectCoercible(this));\n\n      if (ES.IsRegExp(searchString)) {\n        throw new TypeError('Cannot call method \"endsWith\" with a regex');\n      }\n\n      var searchStr = ES.ToString(searchString);\n      var len = S.length;\n      var endPosition;\n\n      if (arguments.length > 1) {\n        endPosition = arguments[1];\n      }\n\n      var pos = typeof endPosition === 'undefined' ? len : ES.ToInteger(endPosition);\n\n      var end = _min(_max(pos, 0), len);\n\n      return _strSlice(S, end - searchStr.length, end) === searchStr;\n    },\n    includes: function includes(searchString) {\n      if (ES.IsRegExp(searchString)) {\n        throw new TypeError('\"includes\" does not accept a RegExp');\n      }\n\n      var searchStr = ES.ToString(searchString);\n      var position;\n\n      if (arguments.length > 1) {\n        position = arguments[1];\n      } // Somehow this trick makes method 100% compat with the spec.\n\n\n      return _indexOf(this, searchStr, position) !== -1;\n    },\n    codePointAt: function codePointAt(pos) {\n      var thisStr = ES.ToString(ES.RequireObjectCoercible(this));\n      var position = ES.ToInteger(pos);\n      var length = thisStr.length;\n\n      if (position >= 0 && position < length) {\n        var first = thisStr.charCodeAt(position);\n        var isEnd = position + 1 === length;\n\n        if (first < 0xD800 || first > 0xDBFF || isEnd) {\n          return first;\n        }\n\n        var second = thisStr.charCodeAt(position + 1);\n\n        if (second < 0xDC00 || second > 0xDFFF) {\n          return first;\n        }\n\n        return (first - 0xD800) * 1024 + (second - 0xDC00) + 0x10000;\n      }\n    }\n  };\n\n  if (String.prototype.includes && 'a'.includes('a', Infinity) !== false) {\n    overrideNative(String.prototype, 'includes', StringPrototypeShims.includes);\n  }\n\n  if (String.prototype.startsWith && String.prototype.endsWith) {\n    var startsWithRejectsRegex = throwsError(function () {\n      /* throws if spec-compliant */\n      return '/a/'.startsWith(/a/);\n    });\n    var startsWithHandlesInfinity = valueOrFalseIfThrows(function () {\n      return 'abc'.startsWith('a', Infinity) === false;\n    });\n\n    if (!startsWithRejectsRegex || !startsWithHandlesInfinity) {\n      // Firefox (< 37?) and IE 11 TP have a noncompliant startsWith implementation\n      overrideNative(String.prototype, 'startsWith', StringPrototypeShims.startsWith);\n      overrideNative(String.prototype, 'endsWith', StringPrototypeShims.endsWith);\n    }\n  }\n\n  if (hasSymbols) {\n    var startsWithSupportsSymbolMatch = valueOrFalseIfThrows(function () {\n      var re = /a/;\n      re[_Symbol.match] = false;\n      return '/a/'.startsWith(re);\n    });\n\n    if (!startsWithSupportsSymbolMatch) {\n      overrideNative(String.prototype, 'startsWith', StringPrototypeShims.startsWith);\n    }\n\n    var endsWithSupportsSymbolMatch = valueOrFalseIfThrows(function () {\n      var re = /a/;\n      re[_Symbol.match] = false;\n      return '/a/'.endsWith(re);\n    });\n\n    if (!endsWithSupportsSymbolMatch) {\n      overrideNative(String.prototype, 'endsWith', StringPrototypeShims.endsWith);\n    }\n\n    var includesSupportsSymbolMatch = valueOrFalseIfThrows(function () {\n      var re = /a/;\n      re[_Symbol.match] = false;\n      return '/a/'.includes(re);\n    });\n\n    if (!includesSupportsSymbolMatch) {\n      overrideNative(String.prototype, 'includes', StringPrototypeShims.includes);\n    }\n  }\n\n  defineProperties(String.prototype, StringPrototypeShims); // whitespace from: http://es5.github.io/#x15.5.4.20\n  // implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324\n\n  var ws = [\"\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\", \"\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\", \"\\u2029\\uFEFF\"].join('');\n  var trimRegexp = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');\n\n  var trimShim = function trim() {\n    return ES.ToString(ES.RequireObjectCoercible(this)).replace(trimRegexp, '');\n  };\n\n  var nonWS = [\"\\x85\", \"\\u200B\", \"\\uFFFE\"].join('');\n  var nonWSregex = new RegExp('[' + nonWS + ']', 'g');\n  var isBadHexRegex = /^[-+]0x[0-9a-f]+$/i;\n  var hasStringTrimBug = nonWS.trim().length !== nonWS.length;\n  defineProperty(String.prototype, 'trim', trimShim, hasStringTrimBug); // Given an argument x, it will return an IteratorResult object,\n  // with value set to x and done to false.\n  // Given no arguments, it will return an iterator completion object.\n\n  var iteratorResult = function iteratorResult(x) {\n    return {\n      value: x,\n      done: arguments.length === 0\n    };\n  }; // see http://www.ecma-international.org/ecma-262/6.0/#sec-string.prototype-@@iterator\n\n\n  var StringIterator = function StringIterator(s) {\n    ES.RequireObjectCoercible(s);\n    this._s = ES.ToString(s);\n    this._i = 0;\n  };\n\n  StringIterator.prototype.next = function () {\n    var s = this._s;\n    var i = this._i;\n\n    if (typeof s === 'undefined' || i >= s.length) {\n      this._s = void 0;\n      return iteratorResult();\n    }\n\n    var first = s.charCodeAt(i);\n    var second, len;\n\n    if (first < 0xD800 || first > 0xDBFF || i + 1 === s.length) {\n      len = 1;\n    } else {\n      second = s.charCodeAt(i + 1);\n      len = second < 0xDC00 || second > 0xDFFF ? 1 : 2;\n    }\n\n    this._i = i + len;\n    return iteratorResult(s.substr(i, len));\n  };\n\n  addIterator(StringIterator.prototype);\n  addIterator(String.prototype, function () {\n    return new StringIterator(this);\n  });\n  var ArrayShims = {\n    from: function from(items) {\n      var C = this;\n      var mapFn;\n\n      if (arguments.length > 1) {\n        mapFn = arguments[1];\n      }\n\n      var mapping, T;\n\n      if (typeof mapFn === 'undefined') {\n        mapping = false;\n      } else {\n        if (!ES.IsCallable(mapFn)) {\n          throw new TypeError('Array.from: when provided, the second argument must be a function');\n        }\n\n        if (arguments.length > 2) {\n          T = arguments[2];\n        }\n\n        mapping = true;\n      } // Note that that Arrays will use ArrayIterator:\n      // https://bugs.ecmascript.org/show_bug.cgi?id=2416\n\n\n      var usingIterator = typeof (isArguments(items) || ES.GetMethod(items, $iterator$)) !== 'undefined';\n      var length, result, i;\n\n      if (usingIterator) {\n        result = ES.IsConstructor(C) ? Object(new C()) : [];\n        var iterator = ES.GetIterator(items);\n        var next, nextValue;\n        i = 0;\n\n        while (true) {\n          next = ES.IteratorStep(iterator);\n\n          if (next === false) {\n            break;\n          }\n\n          nextValue = next.value;\n\n          try {\n            if (mapping) {\n              nextValue = typeof T === 'undefined' ? mapFn(nextValue, i) : _call(mapFn, T, nextValue, i);\n            }\n\n            result[i] = nextValue;\n          } catch (e) {\n            ES.IteratorClose(iterator, true);\n            throw e;\n          }\n\n          i += 1;\n        }\n\n        length = i;\n      } else {\n        var arrayLike = ES.ToObject(items);\n        length = ES.ToLength(arrayLike.length);\n        result = ES.IsConstructor(C) ? Object(new C(length)) : new Array(length);\n        var value;\n\n        for (i = 0; i < length; ++i) {\n          value = arrayLike[i];\n\n          if (mapping) {\n            value = typeof T === 'undefined' ? mapFn(value, i) : _call(mapFn, T, value, i);\n          }\n\n          createDataPropertyOrThrow(result, i, value);\n        }\n      }\n\n      result.length = length;\n      return result;\n    },\n    of: function of() {\n      var len = arguments.length;\n      var C = this;\n      var A = isArray(C) || !ES.IsCallable(C) ? new Array(len) : ES.Construct(C, [len]);\n\n      for (var k = 0; k < len; ++k) {\n        createDataPropertyOrThrow(A, k, arguments[k]);\n      }\n\n      A.length = len;\n      return A;\n    }\n  };\n  defineProperties(Array, ArrayShims);\n  addDefaultSpecies(Array); // Our ArrayIterator is private; see\n  // https://github.com/paulmillr/es6-shim/issues/252\n\n  ArrayIterator = function ArrayIterator(array, kind) {\n    this.i = 0;\n    this.array = array;\n    this.kind = kind;\n  };\n\n  defineProperties(ArrayIterator.prototype, {\n    next: function next() {\n      var i = this.i;\n      var array = this.array;\n\n      if (!(this instanceof ArrayIterator)) {\n        throw new TypeError('Not an ArrayIterator');\n      }\n\n      if (typeof array !== 'undefined') {\n        var len = ES.ToLength(array.length);\n\n        for (; i < len; i++) {\n          var kind = this.kind;\n          var retval;\n\n          if (kind === 'key') {\n            retval = i;\n          } else if (kind === 'value') {\n            retval = array[i];\n          } else if (kind === 'entry') {\n            retval = [i, array[i]];\n          }\n\n          this.i = i + 1;\n          return iteratorResult(retval);\n        }\n      }\n\n      this.array = void 0;\n      return iteratorResult();\n    }\n  });\n  addIterator(ArrayIterator.prototype);\n  /*\n  var orderKeys = function orderKeys(a, b) {\n    var aNumeric = String(ES.ToInteger(a)) === a;\n    var bNumeric = String(ES.ToInteger(b)) === b;\n    if (aNumeric && bNumeric) {\n      return b - a;\n    } else if (aNumeric && !bNumeric) {\n      return -1;\n    } else if (!aNumeric && bNumeric) {\n      return 1;\n    } else {\n      return a.localeCompare(b);\n    }\n  };\n   var getAllKeys = function getAllKeys(object) {\n    var ownKeys = [];\n    var keys = [];\n     for (var key in object) {\n      _push(_hasOwnProperty(object, key) ? ownKeys : keys, key);\n    }\n    _sort(ownKeys, orderKeys);\n    _sort(keys, orderKeys);\n     return _concat(ownKeys, keys);\n  };\n  */\n  // note: this is positioned here because it depends on ArrayIterator\n\n  var arrayOfSupportsSubclassing = Array.of === ArrayShims.of || function () {\n    // Detects a bug in Webkit nightly r181886\n    var Foo = function Foo(len) {\n      this.length = len;\n    };\n\n    Foo.prototype = [];\n    var fooArr = Array.of.apply(Foo, [1, 2]);\n    return fooArr instanceof Foo && fooArr.length === 2;\n  }();\n\n  if (!arrayOfSupportsSubclassing) {\n    overrideNative(Array, 'of', ArrayShims.of);\n  }\n\n  var ArrayPrototypeShims = {\n    copyWithin: function copyWithin(target, start) {\n      var o = ES.ToObject(this);\n      var len = ES.ToLength(o.length);\n      var relativeTarget = ES.ToInteger(target);\n      var relativeStart = ES.ToInteger(start);\n      var to = relativeTarget < 0 ? _max(len + relativeTarget, 0) : _min(relativeTarget, len);\n      var from = relativeStart < 0 ? _max(len + relativeStart, 0) : _min(relativeStart, len);\n      var end;\n\n      if (arguments.length > 2) {\n        end = arguments[2];\n      }\n\n      var relativeEnd = typeof end === 'undefined' ? len : ES.ToInteger(end);\n      var finalItem = relativeEnd < 0 ? _max(len + relativeEnd, 0) : _min(relativeEnd, len);\n\n      var count = _min(finalItem - from, len - to);\n\n      var direction = 1;\n\n      if (from < to && to < from + count) {\n        direction = -1;\n        from += count - 1;\n        to += count - 1;\n      }\n\n      while (count > 0) {\n        if (from in o) {\n          o[to] = o[from];\n        } else {\n          delete o[to];\n        }\n\n        from += direction;\n        to += direction;\n        count -= 1;\n      }\n\n      return o;\n    },\n    fill: function fill(value) {\n      var start;\n\n      if (arguments.length > 1) {\n        start = arguments[1];\n      }\n\n      var end;\n\n      if (arguments.length > 2) {\n        end = arguments[2];\n      }\n\n      var O = ES.ToObject(this);\n      var len = ES.ToLength(O.length);\n      start = ES.ToInteger(typeof start === 'undefined' ? 0 : start);\n      end = ES.ToInteger(typeof end === 'undefined' ? len : end);\n      var relativeStart = start < 0 ? _max(len + start, 0) : _min(start, len);\n      var relativeEnd = end < 0 ? len + end : end;\n\n      for (var i = relativeStart; i < len && i < relativeEnd; ++i) {\n        O[i] = value;\n      }\n\n      return O;\n    },\n    find: function find(predicate) {\n      var list = ES.ToObject(this);\n      var length = ES.ToLength(list.length);\n\n      if (!ES.IsCallable(predicate)) {\n        throw new TypeError('Array#find: predicate must be a function');\n      }\n\n      var thisArg = arguments.length > 1 ? arguments[1] : null;\n\n      for (var i = 0, value; i < length; i++) {\n        value = list[i];\n\n        if (thisArg) {\n          if (_call(predicate, thisArg, value, i, list)) {\n            return value;\n          }\n        } else if (predicate(value, i, list)) {\n          return value;\n        }\n      }\n    },\n    findIndex: function findIndex(predicate) {\n      var list = ES.ToObject(this);\n      var length = ES.ToLength(list.length);\n\n      if (!ES.IsCallable(predicate)) {\n        throw new TypeError('Array#findIndex: predicate must be a function');\n      }\n\n      var thisArg = arguments.length > 1 ? arguments[1] : null;\n\n      for (var i = 0; i < length; i++) {\n        if (thisArg) {\n          if (_call(predicate, thisArg, list[i], i, list)) {\n            return i;\n          }\n        } else if (predicate(list[i], i, list)) {\n          return i;\n        }\n      }\n\n      return -1;\n    },\n    keys: function keys() {\n      return new ArrayIterator(this, 'key');\n    },\n    values: function values() {\n      return new ArrayIterator(this, 'value');\n    },\n    entries: function entries() {\n      return new ArrayIterator(this, 'entry');\n    }\n  }; // Safari 7.1 defines Array#keys and Array#entries natively,\n  // but the resulting ArrayIterator objects don't have a \"next\" method.\n\n  if (Array.prototype.keys && !ES.IsCallable([1].keys().next)) {\n    delete Array.prototype.keys;\n  }\n\n  if (Array.prototype.entries && !ES.IsCallable([1].entries().next)) {\n    delete Array.prototype.entries;\n  } // Chrome 38 defines Array#keys and Array#entries, and Array#@@iterator, but not Array#values\n\n\n  if (Array.prototype.keys && Array.prototype.entries && !Array.prototype.values && Array.prototype[$iterator$]) {\n    defineProperties(Array.prototype, {\n      values: Array.prototype[$iterator$]\n    });\n\n    if (Type.symbol(_Symbol.unscopables)) {\n      Array.prototype[_Symbol.unscopables].values = true;\n    }\n  } // Chrome 40 defines Array#values with the incorrect name, although Array#{keys,entries} have the correct name\n\n\n  if (functionsHaveNames && Array.prototype.values && Array.prototype.values.name !== 'values') {\n    var originalArrayPrototypeValues = Array.prototype.values;\n    overrideNative(Array.prototype, 'values', function values() {\n      return ES.Call(originalArrayPrototypeValues, this, arguments);\n    });\n    defineProperty(Array.prototype, $iterator$, Array.prototype.values, true);\n  }\n\n  defineProperties(Array.prototype, ArrayPrototypeShims);\n\n  if (1 / [true].indexOf(true, -0) < 0) {\n    // indexOf when given a position arg of -0 should return +0.\n    // https://github.com/tc39/ecma262/pull/316\n    defineProperty(Array.prototype, 'indexOf', function indexOf(searchElement) {\n      var value = _arrayIndexOfApply(this, arguments);\n\n      if (value === 0 && 1 / value < 0) {\n        return 0;\n      }\n\n      return value;\n    }, true);\n  }\n\n  addIterator(Array.prototype, function () {\n    return this.values();\n  }); // Chrome defines keys/values/entries on Array, but doesn't give us\n  // any way to identify its iterator.  So add our own shimmed field.\n\n  if (Object.getPrototypeOf) {\n    addIterator(Object.getPrototypeOf([].values()));\n  } // note: this is positioned here because it relies on Array#entries\n\n\n  var arrayFromSwallowsNegativeLengths = function () {\n    // Detects a Firefox bug in v32\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1063993\n    return valueOrFalseIfThrows(function () {\n      return Array.from({\n        length: -1\n      }).length === 0;\n    });\n  }();\n\n  var arrayFromHandlesIterables = function () {\n    // Detects a bug in Webkit nightly r181886\n    var arr = Array.from([0].entries());\n    return arr.length === 1 && isArray(arr[0]) && arr[0][0] === 0 && arr[0][1] === 0;\n  }();\n\n  if (!arrayFromSwallowsNegativeLengths || !arrayFromHandlesIterables) {\n    overrideNative(Array, 'from', ArrayShims.from);\n  }\n\n  var arrayFromHandlesUndefinedMapFunction = function () {\n    // Microsoft Edge v0.11 throws if the mapFn argument is *provided* but undefined,\n    // but the spec doesn't care if it's provided or not - undefined doesn't throw.\n    return valueOrFalseIfThrows(function () {\n      return Array.from([0], void 0);\n    });\n  }();\n\n  if (!arrayFromHandlesUndefinedMapFunction) {\n    var origArrayFrom = Array.from;\n    overrideNative(Array, 'from', function from(items) {\n      if (arguments.length > 1 && typeof arguments[1] !== 'undefined') {\n        return ES.Call(origArrayFrom, this, arguments);\n      } else {\n        return _call(origArrayFrom, this, items);\n      }\n    });\n  }\n\n  var int32sAsOne = -(Math.pow(2, 32) - 1);\n\n  var toLengthsCorrectly = function toLengthsCorrectly(method, reversed) {\n    var obj = {\n      length: int32sAsOne\n    };\n    obj[reversed ? (obj.length >>> 0) - 1 : 0] = true;\n    return valueOrFalseIfThrows(function () {\n      _call(method, obj, function () {\n        // note: in nonconforming browsers, this will be called\n        // -1 >>> 0 times, which is 4294967295, so the throw matters.\n        throw new RangeError('should not reach here');\n      }, []);\n\n      return true;\n    });\n  };\n\n  if (!toLengthsCorrectly(Array.prototype.forEach)) {\n    var originalForEach = Array.prototype.forEach;\n    overrideNative(Array.prototype, 'forEach', function forEach(callbackFn) {\n      return ES.Call(originalForEach, this.length >= 0 ? this : [], arguments);\n    }, true);\n  }\n\n  if (!toLengthsCorrectly(Array.prototype.map)) {\n    var originalMap = Array.prototype.map;\n    overrideNative(Array.prototype, 'map', function map(callbackFn) {\n      return ES.Call(originalMap, this.length >= 0 ? this : [], arguments);\n    }, true);\n  }\n\n  if (!toLengthsCorrectly(Array.prototype.filter)) {\n    var originalFilter = Array.prototype.filter;\n    overrideNative(Array.prototype, 'filter', function filter(callbackFn) {\n      return ES.Call(originalFilter, this.length >= 0 ? this : [], arguments);\n    }, true);\n  }\n\n  if (!toLengthsCorrectly(Array.prototype.some)) {\n    var originalSome = Array.prototype.some;\n    overrideNative(Array.prototype, 'some', function some(callbackFn) {\n      return ES.Call(originalSome, this.length >= 0 ? this : [], arguments);\n    }, true);\n  }\n\n  if (!toLengthsCorrectly(Array.prototype.every)) {\n    var originalEvery = Array.prototype.every;\n    overrideNative(Array.prototype, 'every', function every(callbackFn) {\n      return ES.Call(originalEvery, this.length >= 0 ? this : [], arguments);\n    }, true);\n  }\n\n  if (!toLengthsCorrectly(Array.prototype.reduce)) {\n    var originalReduce = Array.prototype.reduce;\n    overrideNative(Array.prototype, 'reduce', function reduce(callbackFn) {\n      return ES.Call(originalReduce, this.length >= 0 ? this : [], arguments);\n    }, true);\n  }\n\n  if (!toLengthsCorrectly(Array.prototype.reduceRight, true)) {\n    var originalReduceRight = Array.prototype.reduceRight;\n    overrideNative(Array.prototype, 'reduceRight', function reduceRight(callbackFn) {\n      return ES.Call(originalReduceRight, this.length >= 0 ? this : [], arguments);\n    }, true);\n  }\n\n  var lacksOctalSupport = Number('0o10') !== 8;\n  var lacksBinarySupport = Number('0b10') !== 2;\n\n  var trimsNonWhitespace = _some(nonWS, function (c) {\n    return Number(c + 0 + c) === 0;\n  });\n\n  if (lacksOctalSupport || lacksBinarySupport || trimsNonWhitespace) {\n    var OrigNumber = Number;\n    var binaryRegex = /^0b[01]+$/i;\n    var octalRegex = /^0o[0-7]+$/i; // Note that in IE 8, RegExp.prototype.test doesn't seem to exist: ie, \"test\" is an own property of regexes. wtf.\n\n    var isBinary = binaryRegex.test.bind(binaryRegex);\n    var isOctal = octalRegex.test.bind(octalRegex);\n\n    var toPrimitive = function toPrimitive(O) {\n      // need to replace this with `es-to-primitive/es6`\n      var result;\n\n      if (typeof O.valueOf === 'function') {\n        result = O.valueOf();\n\n        if (Type.primitive(result)) {\n          return result;\n        }\n      }\n\n      if (typeof O.toString === 'function') {\n        result = O.toString();\n\n        if (Type.primitive(result)) {\n          return result;\n        }\n      }\n\n      throw new TypeError('No default value');\n    };\n\n    var hasNonWS = nonWSregex.test.bind(nonWSregex);\n    var isBadHex = isBadHexRegex.test.bind(isBadHexRegex);\n\n    var NumberShim = function () {\n      // this is wrapped in an IIFE because of IE 6-8's wacky scoping issues with named function expressions.\n      var NumberShim = function Number(value) {\n        var primValue;\n\n        if (arguments.length > 0) {\n          primValue = Type.primitive(value) ? value : toPrimitive(value, 'number');\n        } else {\n          primValue = 0;\n        }\n\n        if (typeof primValue === 'string') {\n          primValue = ES.Call(trimShim, primValue);\n\n          if (isBinary(primValue)) {\n            primValue = parseInt(_strSlice(primValue, 2), 2);\n          } else if (isOctal(primValue)) {\n            primValue = parseInt(_strSlice(primValue, 2), 8);\n          } else if (hasNonWS(primValue) || isBadHex(primValue)) {\n            primValue = NaN;\n          }\n        }\n\n        var receiver = this;\n        var valueOfSucceeds = valueOrFalseIfThrows(function () {\n          OrigNumber.prototype.valueOf.call(receiver);\n          return true;\n        });\n\n        if (receiver instanceof NumberShim && !valueOfSucceeds) {\n          return new OrigNumber(primValue);\n        }\n\n        return OrigNumber(primValue);\n      };\n\n      return NumberShim;\n    }();\n\n    wrapConstructor(OrigNumber, NumberShim, {}); // this is necessary for ES3 browsers, where these properties are non-enumerable.\n\n    defineProperties(NumberShim, {\n      NaN: OrigNumber.NaN,\n      MAX_VALUE: OrigNumber.MAX_VALUE,\n      MIN_VALUE: OrigNumber.MIN_VALUE,\n      NEGATIVE_INFINITY: OrigNumber.NEGATIVE_INFINITY,\n      POSITIVE_INFINITY: OrigNumber.POSITIVE_INFINITY\n    });\n    /* globals Number: true */\n\n    /* eslint-disable no-undef, no-global-assign */\n\n    Number = NumberShim;\n    Value.redefine(globals, 'Number', NumberShim);\n    /* eslint-enable no-undef, no-global-assign */\n\n    /* globals Number: false */\n  }\n\n  var maxSafeInteger = Math.pow(2, 53) - 1;\n  defineProperties(Number, {\n    MAX_SAFE_INTEGER: maxSafeInteger,\n    MIN_SAFE_INTEGER: -maxSafeInteger,\n    EPSILON: 2.220446049250313e-16,\n    parseInt: globals.parseInt,\n    parseFloat: globals.parseFloat,\n    isFinite: numberIsFinite,\n    isInteger: function isInteger(value) {\n      return numberIsFinite(value) && ES.ToInteger(value) === value;\n    },\n    isSafeInteger: function isSafeInteger(value) {\n      return Number.isInteger(value) && _abs(value) <= Number.MAX_SAFE_INTEGER;\n    },\n    isNaN: numberIsNaN\n  }); // Firefox 37 has a conforming Number.parseInt, but it's not === to the global parseInt (fixed in v40)\n\n  defineProperty(Number, 'parseInt', globals.parseInt, Number.parseInt !== globals.parseInt); // Work around bugs in Array#find and Array#findIndex -- early\n  // implementations skipped holes in sparse arrays. (Note that the\n  // implementations of find/findIndex indirectly use shimmed\n  // methods of Number, so this test has to happen down here.)\n\n  /* eslint-disable no-sparse-arrays */\n\n  if ([, 1].find(function () {\n    return true;\n  }) === 1) {\n    overrideNative(Array.prototype, 'find', ArrayPrototypeShims.find);\n  }\n\n  if ([, 1].findIndex(function () {\n    return true;\n  }) !== 0) {\n    overrideNative(Array.prototype, 'findIndex', ArrayPrototypeShims.findIndex);\n  }\n  /* eslint-enable no-sparse-arrays */\n\n\n  var isEnumerableOn = Function.bind.call(Function.bind, Object.prototype.propertyIsEnumerable);\n\n  var ensureEnumerable = function ensureEnumerable(obj, prop) {\n    if (supportsDescriptors && isEnumerableOn(obj, prop)) {\n      Object.defineProperty(obj, prop, {\n        enumerable: false\n      });\n    }\n  };\n\n  var sliceArgs = function sliceArgs() {\n    // per https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments\n    // and https://gist.github.com/WebReflection/4327762cb87a8c634a29\n    var initial = Number(this);\n    var len = arguments.length;\n    var desiredArgCount = len - initial;\n    var args = new Array(desiredArgCount < 0 ? 0 : desiredArgCount);\n\n    for (var i = initial; i < len; ++i) {\n      args[i - initial] = arguments[i];\n    }\n\n    return args;\n  };\n\n  var assignTo = function assignTo(source) {\n    return function assignToSource(target, key) {\n      target[key] = source[key];\n      return target;\n    };\n  };\n\n  var assignReducer = function assignReducer(target, source) {\n    var sourceKeys = keys(Object(source));\n    var symbols;\n\n    if (ES.IsCallable(Object.getOwnPropertySymbols)) {\n      symbols = _filter(Object.getOwnPropertySymbols(Object(source)), isEnumerableOn(source));\n    }\n\n    return _reduce(_concat(sourceKeys, symbols || []), assignTo(source), target);\n  };\n\n  var ObjectShims = {\n    // 19.1.3.1\n    assign: function assign(target, source) {\n      var to = ES.ToObject(target, 'Cannot convert undefined or null to object');\n      return _reduce(ES.Call(sliceArgs, 1, arguments), assignReducer, to);\n    },\n    // Added in WebKit in https://bugs.webkit.org/show_bug.cgi?id=143865\n    is: function is(a, b) {\n      return ES.SameValue(a, b);\n    }\n  };\n\n  var assignHasPendingExceptions = Object.assign && Object.preventExtensions && function () {\n    // Firefox 37 still has \"pending exception\" logic in its Object.assign implementation,\n    // which is 72% slower than our shim, and Firefox 40's native implementation.\n    var thrower = Object.preventExtensions({\n      1: 2\n    });\n\n    try {\n      Object.assign(thrower, 'xy');\n    } catch (e) {\n      return thrower[1] === 'y';\n    }\n  }();\n\n  if (assignHasPendingExceptions) {\n    overrideNative(Object, 'assign', ObjectShims.assign);\n  }\n\n  defineProperties(Object, ObjectShims);\n\n  if (supportsDescriptors) {\n    var ES5ObjectShims = {\n      // 19.1.3.9\n      // shim from https://gist.github.com/WebReflection/5593554\n      setPrototypeOf: function (Object, magic) {\n        var set;\n\n        var checkArgs = function checkArgs(O, proto) {\n          if (!ES.TypeIsObject(O)) {\n            throw new TypeError('cannot set prototype on a non-object');\n          }\n\n          if (!(proto === null || ES.TypeIsObject(proto))) {\n            throw new TypeError('can only set prototype to an object or null' + proto);\n          }\n        };\n\n        var setPrototypeOf = function setPrototypeOf(O, proto) {\n          checkArgs(O, proto);\n\n          _call(set, O, proto);\n\n          return O;\n        };\n\n        try {\n          // this works already in Firefox and Safari\n          set = Object.getOwnPropertyDescriptor(Object.prototype, magic).set;\n\n          _call(set, {}, null);\n        } catch (e) {\n          if (Object.prototype !== {}[magic]) {\n            // IE < 11 cannot be shimmed\n            return;\n          } // probably Chrome or some old Mobile stock browser\n\n\n          set = function set(proto) {\n            this[magic] = proto;\n          }; // please note that this will **not** work\n          // in those browsers that do not inherit\n          // __proto__ by mistake from Object.prototype\n          // in these cases we should probably throw an error\n          // or at least be informed about the issue\n\n\n          setPrototypeOf.polyfill = setPrototypeOf(setPrototypeOf({}, null), Object.prototype) instanceof Object; // setPrototypeOf.polyfill === true means it works as meant\n          // setPrototypeOf.polyfill === false means it's not 100% reliable\n          // setPrototypeOf.polyfill === undefined\n          // or\n          // setPrototypeOf.polyfill ==  null means it's not a polyfill\n          // which means it works as expected\n          // we can even delete Object.prototype.__proto__;\n        }\n\n        return setPrototypeOf;\n      }(Object, '__proto__')\n    };\n    defineProperties(Object, ES5ObjectShims);\n  } // Workaround bug in Opera 12 where setPrototypeOf(x, null) doesn't work,\n  // but Object.create(null) does.\n\n\n  if (Object.setPrototypeOf && Object.getPrototypeOf && Object.getPrototypeOf(Object.setPrototypeOf({}, null)) !== null && Object.getPrototypeOf(Object.create(null)) === null) {\n    (function () {\n      var FAKENULL = Object.create(null);\n      var gpo = Object.getPrototypeOf;\n      var spo = Object.setPrototypeOf;\n\n      Object.getPrototypeOf = function (o) {\n        var result = gpo(o);\n        return result === FAKENULL ? null : result;\n      };\n\n      Object.setPrototypeOf = function (o, p) {\n        var proto = p === null ? FAKENULL : p;\n        return spo(o, proto);\n      };\n\n      Object.setPrototypeOf.polyfill = false;\n    })();\n  }\n\n  var objectKeysAcceptsPrimitives = !throwsError(function () {\n    return Object.keys('foo');\n  });\n\n  if (!objectKeysAcceptsPrimitives) {\n    var originalObjectKeys = Object.keys;\n    overrideNative(Object, 'keys', function keys(value) {\n      return originalObjectKeys(ES.ToObject(value));\n    });\n    keys = Object.keys;\n  }\n\n  var objectKeysRejectsRegex = throwsError(function () {\n    return Object.keys(/a/g);\n  });\n\n  if (objectKeysRejectsRegex) {\n    var regexRejectingObjectKeys = Object.keys;\n    overrideNative(Object, 'keys', function keys(value) {\n      if (Type.regex(value)) {\n        var regexKeys = [];\n\n        for (var k in value) {\n          if (_hasOwnProperty(value, k)) {\n            _push(regexKeys, k);\n          }\n        }\n\n        return regexKeys;\n      }\n\n      return regexRejectingObjectKeys(value);\n    });\n    keys = Object.keys;\n  }\n\n  if (Object.getOwnPropertyNames) {\n    var objectGOPNAcceptsPrimitives = !throwsError(function () {\n      return Object.getOwnPropertyNames('foo');\n    });\n\n    if (!objectGOPNAcceptsPrimitives) {\n      var cachedWindowNames = (typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === 'object' ? Object.getOwnPropertyNames(window) : [];\n      var originalObjectGetOwnPropertyNames = Object.getOwnPropertyNames;\n      overrideNative(Object, 'getOwnPropertyNames', function getOwnPropertyNames(value) {\n        var val = ES.ToObject(value);\n\n        if (_toString(val) === '[object Window]') {\n          try {\n            return originalObjectGetOwnPropertyNames(val);\n          } catch (e) {\n            // IE bug where layout engine calls userland gOPN for cross-domain `window` objects\n            return _concat([], cachedWindowNames);\n          }\n        }\n\n        return originalObjectGetOwnPropertyNames(val);\n      });\n    }\n  }\n\n  if (Object.getOwnPropertyDescriptor) {\n    var objectGOPDAcceptsPrimitives = !throwsError(function () {\n      return Object.getOwnPropertyDescriptor('foo', 'bar');\n    });\n\n    if (!objectGOPDAcceptsPrimitives) {\n      var originalObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n      overrideNative(Object, 'getOwnPropertyDescriptor', function getOwnPropertyDescriptor(value, property) {\n        return originalObjectGetOwnPropertyDescriptor(ES.ToObject(value), property);\n      });\n    }\n  }\n\n  if (Object.seal) {\n    var objectSealAcceptsPrimitives = !throwsError(function () {\n      return Object.seal('foo');\n    });\n\n    if (!objectSealAcceptsPrimitives) {\n      var originalObjectSeal = Object.seal;\n      overrideNative(Object, 'seal', function seal(value) {\n        if (!ES.TypeIsObject(value)) {\n          return value;\n        }\n\n        return originalObjectSeal(value);\n      });\n    }\n  }\n\n  if (Object.isSealed) {\n    var objectIsSealedAcceptsPrimitives = !throwsError(function () {\n      return Object.isSealed('foo');\n    });\n\n    if (!objectIsSealedAcceptsPrimitives) {\n      var originalObjectIsSealed = Object.isSealed;\n      overrideNative(Object, 'isSealed', function isSealed(value) {\n        if (!ES.TypeIsObject(value)) {\n          return true;\n        }\n\n        return originalObjectIsSealed(value);\n      });\n    }\n  }\n\n  if (Object.freeze) {\n    var objectFreezeAcceptsPrimitives = !throwsError(function () {\n      return Object.freeze('foo');\n    });\n\n    if (!objectFreezeAcceptsPrimitives) {\n      var originalObjectFreeze = Object.freeze;\n      overrideNative(Object, 'freeze', function freeze(value) {\n        if (!ES.TypeIsObject(value)) {\n          return value;\n        }\n\n        return originalObjectFreeze(value);\n      });\n    }\n  }\n\n  if (Object.isFrozen) {\n    var objectIsFrozenAcceptsPrimitives = !throwsError(function () {\n      return Object.isFrozen('foo');\n    });\n\n    if (!objectIsFrozenAcceptsPrimitives) {\n      var originalObjectIsFrozen = Object.isFrozen;\n      overrideNative(Object, 'isFrozen', function isFrozen(value) {\n        if (!ES.TypeIsObject(value)) {\n          return true;\n        }\n\n        return originalObjectIsFrozen(value);\n      });\n    }\n  }\n\n  if (Object.preventExtensions) {\n    var objectPreventExtensionsAcceptsPrimitives = !throwsError(function () {\n      return Object.preventExtensions('foo');\n    });\n\n    if (!objectPreventExtensionsAcceptsPrimitives) {\n      var originalObjectPreventExtensions = Object.preventExtensions;\n      overrideNative(Object, 'preventExtensions', function preventExtensions(value) {\n        if (!ES.TypeIsObject(value)) {\n          return value;\n        }\n\n        return originalObjectPreventExtensions(value);\n      });\n    }\n  }\n\n  if (Object.isExtensible) {\n    var objectIsExtensibleAcceptsPrimitives = !throwsError(function () {\n      return Object.isExtensible('foo');\n    });\n\n    if (!objectIsExtensibleAcceptsPrimitives) {\n      var originalObjectIsExtensible = Object.isExtensible;\n      overrideNative(Object, 'isExtensible', function isExtensible(value) {\n        if (!ES.TypeIsObject(value)) {\n          return false;\n        }\n\n        return originalObjectIsExtensible(value);\n      });\n    }\n  }\n\n  if (Object.getPrototypeOf) {\n    var objectGetProtoAcceptsPrimitives = !throwsError(function () {\n      return Object.getPrototypeOf('foo');\n    });\n\n    if (!objectGetProtoAcceptsPrimitives) {\n      var originalGetProto = Object.getPrototypeOf;\n      overrideNative(Object, 'getPrototypeOf', function getPrototypeOf(value) {\n        return originalGetProto(ES.ToObject(value));\n      });\n    }\n  }\n\n  var hasFlags = supportsDescriptors && function () {\n    var desc = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags');\n    return desc && ES.IsCallable(desc.get);\n  }();\n\n  if (supportsDescriptors && !hasFlags) {\n    var regExpFlagsGetter = function flags() {\n      if (!ES.TypeIsObject(this)) {\n        throw new TypeError('Method called on incompatible type: must be an object.');\n      }\n\n      var result = '';\n\n      if (this.global) {\n        result += 'g';\n      }\n\n      if (this.ignoreCase) {\n        result += 'i';\n      }\n\n      if (this.multiline) {\n        result += 'm';\n      }\n\n      if (this.unicode) {\n        result += 'u';\n      }\n\n      if (this.sticky) {\n        result += 'y';\n      }\n\n      return result;\n    };\n\n    Value.getter(RegExp.prototype, 'flags', regExpFlagsGetter);\n  }\n\n  var regExpSupportsFlagsWithRegex = supportsDescriptors && valueOrFalseIfThrows(function () {\n    return String(new RegExp(/a/g, 'i')) === '/a/i';\n  });\n\n  var regExpNeedsToSupportSymbolMatch = hasSymbols && supportsDescriptors && function () {\n    // Edge 0.12 supports flags fully, but does not support Symbol.match\n    var regex = /./;\n    regex[_Symbol.match] = false;\n    return RegExp(regex) === regex;\n  }();\n\n  var regexToStringIsGeneric = valueOrFalseIfThrows(function () {\n    return RegExp.prototype.toString.call({\n      source: 'abc'\n    }) === '/abc/';\n  });\n  var regexToStringSupportsGenericFlags = regexToStringIsGeneric && valueOrFalseIfThrows(function () {\n    return RegExp.prototype.toString.call({\n      source: 'a',\n      flags: 'b'\n    }) === '/a/b';\n  });\n\n  if (!regexToStringIsGeneric || !regexToStringSupportsGenericFlags) {\n    var origRegExpToString = RegExp.prototype.toString;\n    defineProperty(RegExp.prototype, 'toString', function toString() {\n      var R = ES.RequireObjectCoercible(this);\n\n      if (Type.regex(R)) {\n        return _call(origRegExpToString, R);\n      }\n\n      var pattern = $String(R.source);\n      var flags = $String(R.flags);\n      return '/' + pattern + '/' + flags;\n    }, true);\n    Value.preserveToString(RegExp.prototype.toString, origRegExpToString);\n  }\n\n  if (supportsDescriptors && (!regExpSupportsFlagsWithRegex || regExpNeedsToSupportSymbolMatch)) {\n    var flagsGetter = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get;\n    var sourceDesc = Object.getOwnPropertyDescriptor(RegExp.prototype, 'source') || {};\n\n    var legacySourceGetter = function legacySourceGetter() {\n      // prior to it being a getter, it's own + nonconfigurable\n      return this.source;\n    };\n\n    var sourceGetter = ES.IsCallable(sourceDesc.get) ? sourceDesc.get : legacySourceGetter;\n    var OrigRegExp = RegExp;\n\n    var RegExpShim = function () {\n      return function RegExp(pattern, flags) {\n        var patternIsRegExp = ES.IsRegExp(pattern);\n        var calledWithNew = this instanceof RegExp;\n\n        if (!calledWithNew && patternIsRegExp && typeof flags === 'undefined' && pattern.constructor === RegExp) {\n          return pattern;\n        }\n\n        var P = pattern;\n        var F = flags;\n\n        if (Type.regex(pattern)) {\n          P = ES.Call(sourceGetter, pattern);\n          F = typeof flags === 'undefined' ? ES.Call(flagsGetter, pattern) : flags;\n          return new RegExp(P, F);\n        } else if (patternIsRegExp) {\n          P = pattern.source;\n          F = typeof flags === 'undefined' ? pattern.flags : flags;\n        }\n\n        return new OrigRegExp(pattern, flags);\n      };\n    }();\n\n    wrapConstructor(OrigRegExp, RegExpShim, {\n      $input: true // Chrome < v39 & Opera < 26 have a nonstandard \"$input\" property\n\n    });\n    /* globals RegExp: true */\n\n    /* eslint-disable no-undef, no-global-assign */\n\n    RegExp = RegExpShim;\n    Value.redefine(globals, 'RegExp', RegExpShim);\n    /* eslint-enable no-undef, no-global-assign */\n\n    /* globals RegExp: false */\n  }\n\n  if (supportsDescriptors) {\n    var regexGlobals = {\n      input: '$_',\n      lastMatch: '$&',\n      lastParen: '$+',\n      leftContext: '$`',\n      rightContext: '$\\''\n    };\n\n    _forEach(keys(regexGlobals), function (prop) {\n      if (prop in RegExp && !(regexGlobals[prop] in RegExp)) {\n        Value.getter(RegExp, regexGlobals[prop], function get() {\n          return RegExp[prop];\n        });\n      }\n    });\n  }\n\n  addDefaultSpecies(RegExp);\n  var inverseEpsilon = 1 / Number.EPSILON;\n\n  var roundTiesToEven = function roundTiesToEven(n) {\n    // Even though this reduces down to `return n`, it takes advantage of built-in rounding.\n    return n + inverseEpsilon - inverseEpsilon;\n  };\n\n  var BINARY_32_EPSILON = Math.pow(2, -23);\n  var BINARY_32_MAX_VALUE = Math.pow(2, 127) * (2 - BINARY_32_EPSILON);\n  var BINARY_32_MIN_VALUE = Math.pow(2, -126);\n  var E = Math.E;\n  var LOG2E = Math.LOG2E;\n  var LOG10E = Math.LOG10E;\n  var numberCLZ = Number.prototype.clz;\n  delete Number.prototype.clz; // Safari 8 has Number#clz\n\n  var MathShims = {\n    acosh: function acosh(value) {\n      var x = Number(value);\n\n      if (numberIsNaN(x) || value < 1) {\n        return NaN;\n      }\n\n      if (x === 1) {\n        return 0;\n      }\n\n      if (x === Infinity) {\n        return x;\n      }\n\n      var xInvSquared = 1 / (x * x);\n\n      if (x < 2) {\n        return _log1p(x - 1 + _sqrt(1 - xInvSquared) * x);\n      }\n\n      var halfX = x / 2;\n      return _log1p(halfX + _sqrt(1 - xInvSquared) * halfX - 1) + 1 / LOG2E;\n    },\n    asinh: function asinh(value) {\n      var x = Number(value);\n\n      if (x === 0 || !globalIsFinite(x)) {\n        return x;\n      }\n\n      var a = _abs(x);\n\n      var aSquared = a * a;\n\n      var s = _sign(x);\n\n      if (a < 1) {\n        return s * _log1p(a + aSquared / (_sqrt(aSquared + 1) + 1));\n      }\n\n      return s * (_log1p(a / 2 + _sqrt(1 + 1 / aSquared) * a / 2 - 1) + 1 / LOG2E);\n    },\n    atanh: function atanh(value) {\n      var x = Number(value);\n\n      if (x === 0) {\n        return x;\n      }\n\n      if (x === -1) {\n        return -Infinity;\n      }\n\n      if (x === 1) {\n        return Infinity;\n      }\n\n      if (numberIsNaN(x) || x < -1 || x > 1) {\n        return NaN;\n      }\n\n      var a = _abs(x);\n\n      return _sign(x) * _log1p(2 * a / (1 - a)) / 2;\n    },\n    cbrt: function cbrt(value) {\n      var x = Number(value);\n\n      if (x === 0) {\n        return x;\n      }\n\n      var negate = x < 0;\n      var result;\n\n      if (negate) {\n        x = -x;\n      }\n\n      if (x === Infinity) {\n        result = Infinity;\n      } else {\n        result = _exp(_log(x) / 3); // from http://en.wikipedia.org/wiki/Cube_root#Numerical_methods\n\n        result = (x / (result * result) + 2 * result) / 3;\n      }\n\n      return negate ? -result : result;\n    },\n    clz32: function clz32(value) {\n      // See https://bugs.ecmascript.org/show_bug.cgi?id=2465\n      var x = Number(value);\n      var number = ES.ToUint32(x);\n\n      if (number === 0) {\n        return 32;\n      }\n\n      return numberCLZ ? ES.Call(numberCLZ, number) : 31 - _floor(_log(number + 0.5) * LOG2E);\n    },\n    cosh: function cosh(value) {\n      var x = Number(value);\n\n      if (x === 0) {\n        return 1;\n      } // +0 or -0\n\n\n      if (numberIsNaN(x)) {\n        return NaN;\n      }\n\n      if (!globalIsFinite(x)) {\n        return Infinity;\n      }\n\n      var t = _exp(_abs(x) - 1);\n\n      return (t + 1 / (t * E * E)) * (E / 2);\n    },\n    expm1: function expm1(value) {\n      var x = Number(value);\n\n      if (x === -Infinity) {\n        return -1;\n      }\n\n      if (!globalIsFinite(x) || x === 0) {\n        return x;\n      }\n\n      if (_abs(x) > 0.5) {\n        return _exp(x) - 1;\n      } // A more precise approximation using Taylor series expansion\n      // from https://github.com/paulmillr/es6-shim/issues/314#issuecomment-70293986\n\n\n      var t = x;\n      var sum = 0;\n      var n = 1;\n\n      while (sum + t !== sum) {\n        sum += t;\n        n += 1;\n        t *= x / n;\n      }\n\n      return sum;\n    },\n    hypot: function hypot(x, y) {\n      var result = 0;\n      var largest = 0;\n\n      for (var i = 0; i < arguments.length; ++i) {\n        var value = _abs(Number(arguments[i]));\n\n        if (largest < value) {\n          result *= largest / value * (largest / value);\n          result += 1;\n          largest = value;\n        } else {\n          result += value > 0 ? value / largest * (value / largest) : value;\n        }\n      }\n\n      return largest === Infinity ? Infinity : largest * _sqrt(result);\n    },\n    log2: function log2(value) {\n      return _log(value) * LOG2E;\n    },\n    log10: function log10(value) {\n      return _log(value) * LOG10E;\n    },\n    log1p: _log1p,\n    sign: _sign,\n    sinh: function sinh(value) {\n      var x = Number(value);\n\n      if (!globalIsFinite(x) || x === 0) {\n        return x;\n      }\n\n      var a = _abs(x);\n\n      if (a < 1) {\n        var u = Math.expm1(a);\n        return _sign(x) * u * (1 + 1 / (u + 1)) / 2;\n      }\n\n      var t = _exp(a - 1);\n\n      return _sign(x) * (t - 1 / (t * E * E)) * (E / 2);\n    },\n    tanh: function tanh(value) {\n      var x = Number(value);\n\n      if (numberIsNaN(x) || x === 0) {\n        return x;\n      } // can exit early at +-20 as JS loses precision for true value at this integer\n\n\n      if (x >= 20) {\n        return 1;\n      }\n\n      if (x <= -20) {\n        return -1;\n      }\n\n      return (Math.expm1(x) - Math.expm1(-x)) / (_exp(x) + _exp(-x));\n    },\n    trunc: function trunc(value) {\n      var x = Number(value);\n      return x < 0 ? -_floor(-x) : _floor(x);\n    },\n    imul: function imul(x, y) {\n      // taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul\n      var a = ES.ToUint32(x);\n      var b = ES.ToUint32(y);\n      var ah = a >>> 16 & 0xffff;\n      var al = a & 0xffff;\n      var bh = b >>> 16 & 0xffff;\n      var bl = b & 0xffff; // the shift by 0 fixes the sign on the high part\n      // the final |0 converts the unsigned value into a signed value\n\n      return al * bl + (ah * bl + al * bh << 16 >>> 0) | 0;\n    },\n    fround: function fround(x) {\n      var v = Number(x);\n\n      if (v === 0 || v === Infinity || v === -Infinity || numberIsNaN(v)) {\n        return v;\n      }\n\n      var sign = _sign(v);\n\n      var abs = _abs(v);\n\n      if (abs < BINARY_32_MIN_VALUE) {\n        return sign * roundTiesToEven(abs / BINARY_32_MIN_VALUE / BINARY_32_EPSILON) * BINARY_32_MIN_VALUE * BINARY_32_EPSILON;\n      } // Veltkamp's splitting (?)\n\n\n      var a = (1 + BINARY_32_EPSILON / Number.EPSILON) * abs;\n      var result = a - (a - abs);\n\n      if (result > BINARY_32_MAX_VALUE || numberIsNaN(result)) {\n        return sign * Infinity;\n      }\n\n      return sign * result;\n    }\n  };\n\n  var withinULPDistance = function withinULPDistance(result, expected, distance) {\n    return _abs(1 - result / expected) / Number.EPSILON < (distance || 8);\n  };\n\n  defineProperties(Math, MathShims); // Chrome < 40 sinh returns ∞ for large numbers\n\n  defineProperty(Math, 'sinh', MathShims.sinh, Math.sinh(710) === Infinity); // Chrome < 40 cosh returns ∞ for large numbers\n\n  defineProperty(Math, 'cosh', MathShims.cosh, Math.cosh(710) === Infinity); // IE 11 TP has an imprecise log1p: reports Math.log1p(-1e-17) as 0\n\n  defineProperty(Math, 'log1p', MathShims.log1p, Math.log1p(-1e-17) !== -1e-17); // IE 11 TP has an imprecise asinh: reports Math.asinh(-1e7) as not exactly equal to -Math.asinh(1e7)\n\n  defineProperty(Math, 'asinh', MathShims.asinh, Math.asinh(-1e7) !== -Math.asinh(1e7)); // Chrome < 54 asinh returns ∞ for large numbers and should not\n\n  defineProperty(Math, 'asinh', MathShims.asinh, Math.asinh(1e+300) === Infinity); // Chrome < 54 atanh incorrectly returns 0 for large numbers\n\n  defineProperty(Math, 'atanh', MathShims.atanh, Math.atanh(1e-300) === 0); // Chrome 40 has an imprecise Math.tanh with very small numbers\n\n  defineProperty(Math, 'tanh', MathShims.tanh, Math.tanh(-2e-17) !== -2e-17); // Chrome 40 loses Math.acosh precision with high numbers\n\n  defineProperty(Math, 'acosh', MathShims.acosh, Math.acosh(Number.MAX_VALUE) === Infinity); // Chrome < 54 has an inaccurate acosh for EPSILON deltas\n\n  defineProperty(Math, 'acosh', MathShims.acosh, !withinULPDistance(Math.acosh(1 + Number.EPSILON), Math.sqrt(2 * Number.EPSILON))); // Firefox 38 on Windows\n\n  defineProperty(Math, 'cbrt', MathShims.cbrt, !withinULPDistance(Math.cbrt(1e-300), 1e-100)); // node 0.11 has an imprecise Math.sinh with very small numbers\n\n  defineProperty(Math, 'sinh', MathShims.sinh, Math.sinh(-2e-17) !== -2e-17); // FF 35 on Linux reports 22025.465794806725 for Math.expm1(10)\n\n  var expm1OfTen = Math.expm1(10);\n  defineProperty(Math, 'expm1', MathShims.expm1, expm1OfTen > 22025.465794806719 || expm1OfTen < 22025.4657948067165168);\n  var origMathRound = Math.round; // breaks in e.g. Safari 8, Internet Explorer 11, Opera 12\n\n  var roundHandlesBoundaryConditions = Math.round(0.5 - Number.EPSILON / 4) === 0 && Math.round(-0.5 + Number.EPSILON / 3.99) === 1; // When engines use Math.floor(x + 0.5) internally, Math.round can be buggy for large integers.\n  // This behavior should be governed by \"round to nearest, ties to even mode\"\n  // see http://www.ecma-international.org/ecma-262/6.0/#sec-terms-and-definitions-number-type\n  // These are the boundary cases where it breaks.\n\n  var smallestPositiveNumberWhereRoundBreaks = inverseEpsilon + 1;\n  var largestPositiveNumberWhereRoundBreaks = 2 * inverseEpsilon - 1;\n  var roundDoesNotIncreaseIntegers = [smallestPositiveNumberWhereRoundBreaks, largestPositiveNumberWhereRoundBreaks].every(function (num) {\n    return Math.round(num) === num;\n  });\n  defineProperty(Math, 'round', function round(x) {\n    var floor = _floor(x);\n\n    var ceil = floor === -1 ? -0 : floor + 1;\n    return x - floor < 0.5 ? floor : ceil;\n  }, !roundHandlesBoundaryConditions || !roundDoesNotIncreaseIntegers);\n  Value.preserveToString(Math.round, origMathRound);\n  var origImul = Math.imul;\n\n  if (Math.imul(0xffffffff, 5) !== -5) {\n    // Safari 6.1, at least, reports \"0\" for this value\n    Math.imul = MathShims.imul;\n    Value.preserveToString(Math.imul, origImul);\n  }\n\n  if (Math.imul.length !== 2) {\n    // Safari 8.0.4 has a length of 1\n    // fixed in https://bugs.webkit.org/show_bug.cgi?id=143658\n    overrideNative(Math, 'imul', function imul(x, y) {\n      return ES.Call(origImul, Math, arguments);\n    });\n  } // Promises\n  // Simplest possible implementation; use a 3rd-party library if you\n  // want the best possible speed and/or long stack traces.\n\n\n  var PromiseShim = function () {\n    var setTimeout = globals.setTimeout; // some environments don't have setTimeout - no way to shim here.\n\n    if (typeof setTimeout !== 'function' && _typeof(setTimeout) !== 'object') {\n      return;\n    }\n\n    ES.IsPromise = function (promise) {\n      if (!ES.TypeIsObject(promise)) {\n        return false;\n      }\n\n      if (typeof promise._promise === 'undefined') {\n        return false; // uninitialized, or missing our hidden field.\n      }\n\n      return true;\n    }; // \"PromiseCapability\" in the spec is what most promise implementations\n    // call a \"deferred\".\n\n\n    var PromiseCapability = function PromiseCapability(C) {\n      if (!ES.IsConstructor(C)) {\n        throw new TypeError('Bad promise constructor');\n      }\n\n      var capability = this;\n\n      var resolver = function resolver(resolve, reject) {\n        if (capability.resolve !== void 0 || capability.reject !== void 0) {\n          throw new TypeError('Bad Promise implementation!');\n        }\n\n        capability.resolve = resolve;\n        capability.reject = reject;\n      }; // Initialize fields to inform optimizers about the object shape.\n\n\n      capability.resolve = void 0;\n      capability.reject = void 0;\n      capability.promise = new C(resolver);\n\n      if (!(ES.IsCallable(capability.resolve) && ES.IsCallable(capability.reject))) {\n        throw new TypeError('Bad promise constructor');\n      }\n    }; // find an appropriate setImmediate-alike\n\n\n    var makeZeroTimeout;\n    /*global window */\n\n    if (typeof window !== 'undefined' && ES.IsCallable(window.postMessage)) {\n      makeZeroTimeout = function makeZeroTimeout() {\n        // from http://dbaron.org/log/20100309-faster-timeouts\n        var timeouts = [];\n        var messageName = 'zero-timeout-message';\n\n        var setZeroTimeout = function setZeroTimeout(fn) {\n          _push(timeouts, fn);\n\n          window.postMessage(messageName, '*');\n        };\n\n        var handleMessage = function handleMessage(event) {\n          if (event.source === window && event.data === messageName) {\n            event.stopPropagation();\n\n            if (timeouts.length === 0) {\n              return;\n            }\n\n            var fn = _shift(timeouts);\n\n            fn();\n          }\n        };\n\n        window.addEventListener('message', handleMessage, true);\n        return setZeroTimeout;\n      };\n    }\n\n    var makePromiseAsap = function makePromiseAsap() {\n      // An efficient task-scheduler based on a pre-existing Promise\n      // implementation, which we can use even if we override the\n      // global Promise below (in order to workaround bugs)\n      // https://github.com/Raynos/observ-hash/issues/2#issuecomment-35857671\n      var P = globals.Promise;\n      var pr = P && P.resolve && P.resolve();\n      return pr && function (task) {\n        return pr.then(task);\n      };\n    };\n    /*global process */\n\n\n    var enqueue = ES.IsCallable(globals.setImmediate) ? globals.setImmediate : (typeof process === \"undefined\" ? \"undefined\" : _typeof(process)) === 'object' && process.nextTick ? process.nextTick : makePromiseAsap() || (ES.IsCallable(makeZeroTimeout) ? makeZeroTimeout() : function (task) {\n      setTimeout(task, 0);\n    }); // fallback\n    // Constants for Promise implementation\n\n    var PROMISE_IDENTITY = function PROMISE_IDENTITY(x) {\n      return x;\n    };\n\n    var PROMISE_THROWER = function PROMISE_THROWER(e) {\n      throw e;\n    };\n\n    var PROMISE_PENDING = 0;\n    var PROMISE_FULFILLED = 1;\n    var PROMISE_REJECTED = 2; // We store fulfill/reject handlers and capabilities in a single array.\n\n    var PROMISE_FULFILL_OFFSET = 0;\n    var PROMISE_REJECT_OFFSET = 1;\n    var PROMISE_CAPABILITY_OFFSET = 2; // This is used in an optimization for chaining promises via then.\n\n    var PROMISE_FAKE_CAPABILITY = {};\n\n    var enqueuePromiseReactionJob = function enqueuePromiseReactionJob(handler, capability, argument) {\n      enqueue(function () {\n        promiseReactionJob(handler, capability, argument);\n      });\n    };\n\n    var promiseReactionJob = function promiseReactionJob(handler, promiseCapability, argument) {\n      var handlerResult, f;\n\n      if (promiseCapability === PROMISE_FAKE_CAPABILITY) {\n        // Fast case, when we don't actually need to chain through to a\n        // (real) promiseCapability.\n        return handler(argument);\n      }\n\n      try {\n        handlerResult = handler(argument);\n        f = promiseCapability.resolve;\n      } catch (e) {\n        handlerResult = e;\n        f = promiseCapability.reject;\n      }\n\n      f(handlerResult);\n    };\n\n    var fulfillPromise = function fulfillPromise(promise, value) {\n      var _promise = promise._promise;\n      var length = _promise.reactionLength;\n\n      if (length > 0) {\n        enqueuePromiseReactionJob(_promise.fulfillReactionHandler0, _promise.reactionCapability0, value);\n        _promise.fulfillReactionHandler0 = void 0;\n        _promise.rejectReactions0 = void 0;\n        _promise.reactionCapability0 = void 0;\n\n        if (length > 1) {\n          for (var i = 1, idx = 0; i < length; i++, idx += 3) {\n            enqueuePromiseReactionJob(_promise[idx + PROMISE_FULFILL_OFFSET], _promise[idx + PROMISE_CAPABILITY_OFFSET], value);\n            promise[idx + PROMISE_FULFILL_OFFSET] = void 0;\n            promise[idx + PROMISE_REJECT_OFFSET] = void 0;\n            promise[idx + PROMISE_CAPABILITY_OFFSET] = void 0;\n          }\n        }\n      }\n\n      _promise.result = value;\n      _promise.state = PROMISE_FULFILLED;\n      _promise.reactionLength = 0;\n    };\n\n    var rejectPromise = function rejectPromise(promise, reason) {\n      var _promise = promise._promise;\n      var length = _promise.reactionLength;\n\n      if (length > 0) {\n        enqueuePromiseReactionJob(_promise.rejectReactionHandler0, _promise.reactionCapability0, reason);\n        _promise.fulfillReactionHandler0 = void 0;\n        _promise.rejectReactions0 = void 0;\n        _promise.reactionCapability0 = void 0;\n\n        if (length > 1) {\n          for (var i = 1, idx = 0; i < length; i++, idx += 3) {\n            enqueuePromiseReactionJob(_promise[idx + PROMISE_REJECT_OFFSET], _promise[idx + PROMISE_CAPABILITY_OFFSET], reason);\n            promise[idx + PROMISE_FULFILL_OFFSET] = void 0;\n            promise[idx + PROMISE_REJECT_OFFSET] = void 0;\n            promise[idx + PROMISE_CAPABILITY_OFFSET] = void 0;\n          }\n        }\n      }\n\n      _promise.result = reason;\n      _promise.state = PROMISE_REJECTED;\n      _promise.reactionLength = 0;\n    };\n\n    var createResolvingFunctions = function createResolvingFunctions(promise) {\n      var alreadyResolved = false;\n\n      var resolve = function resolve(resolution) {\n        var then;\n\n        if (alreadyResolved) {\n          return;\n        }\n\n        alreadyResolved = true;\n\n        if (resolution === promise) {\n          return rejectPromise(promise, new TypeError('Self resolution'));\n        }\n\n        if (!ES.TypeIsObject(resolution)) {\n          return fulfillPromise(promise, resolution);\n        }\n\n        try {\n          then = resolution.then;\n        } catch (e) {\n          return rejectPromise(promise, e);\n        }\n\n        if (!ES.IsCallable(then)) {\n          return fulfillPromise(promise, resolution);\n        }\n\n        enqueue(function () {\n          promiseResolveThenableJob(promise, resolution, then);\n        });\n      };\n\n      var reject = function reject(reason) {\n        if (alreadyResolved) {\n          return;\n        }\n\n        alreadyResolved = true;\n        return rejectPromise(promise, reason);\n      };\n\n      return {\n        resolve: resolve,\n        reject: reject\n      };\n    };\n\n    var optimizedThen = function optimizedThen(then, thenable, resolve, reject) {\n      // Optimization: since we discard the result, we can pass our\n      // own then implementation a special hint to let it know it\n      // doesn't have to create it.  (The PROMISE_FAKE_CAPABILITY\n      // object is local to this implementation and unforgeable outside.)\n      if (then === Promise$prototype$then) {\n        _call(then, thenable, resolve, reject, PROMISE_FAKE_CAPABILITY);\n      } else {\n        _call(then, thenable, resolve, reject);\n      }\n    };\n\n    var promiseResolveThenableJob = function promiseResolveThenableJob(promise, thenable, then) {\n      var resolvingFunctions = createResolvingFunctions(promise);\n      var resolve = resolvingFunctions.resolve;\n      var reject = resolvingFunctions.reject;\n\n      try {\n        optimizedThen(then, thenable, resolve, reject);\n      } catch (e) {\n        reject(e);\n      }\n    };\n\n    var Promise$prototype, Promise$prototype$then;\n\n    var Promise = function () {\n      var PromiseShim = function Promise(resolver) {\n        if (!(this instanceof PromiseShim)) {\n          throw new TypeError('Constructor Promise requires \"new\"');\n        }\n\n        if (this && this._promise) {\n          throw new TypeError('Bad construction');\n        } // see https://bugs.ecmascript.org/show_bug.cgi?id=2482\n\n\n        if (!ES.IsCallable(resolver)) {\n          throw new TypeError('not a valid resolver');\n        }\n\n        var promise = emulateES6construct(this, PromiseShim, Promise$prototype, {\n          _promise: {\n            result: void 0,\n            state: PROMISE_PENDING,\n            // The first member of the \"reactions\" array is inlined here,\n            // since most promises only have one reaction.\n            // We've also exploded the 'reaction' object to inline the\n            // \"handler\" and \"capability\" fields, since both fulfill and\n            // reject reactions share the same capability.\n            reactionLength: 0,\n            fulfillReactionHandler0: void 0,\n            rejectReactionHandler0: void 0,\n            reactionCapability0: void 0\n          }\n        });\n        var resolvingFunctions = createResolvingFunctions(promise);\n        var reject = resolvingFunctions.reject;\n\n        try {\n          resolver(resolvingFunctions.resolve, reject);\n        } catch (e) {\n          reject(e);\n        }\n\n        return promise;\n      };\n\n      return PromiseShim;\n    }();\n\n    Promise$prototype = Promise.prototype;\n\n    var _promiseAllResolver = function _promiseAllResolver(index, values, capability, remaining) {\n      var alreadyCalled = false;\n      return function (x) {\n        if (alreadyCalled) {\n          return;\n        }\n\n        alreadyCalled = true;\n        values[index] = x;\n\n        if (--remaining.count === 0) {\n          var resolve = capability.resolve;\n          resolve(values); // call w/ this===undefined\n        }\n      };\n    };\n\n    var performPromiseAll = function performPromiseAll(iteratorRecord, C, resultCapability) {\n      var it = iteratorRecord.iterator;\n      var values = [];\n      var remaining = {\n        count: 1\n      };\n      var next, nextValue;\n      var index = 0;\n\n      while (true) {\n        try {\n          next = ES.IteratorStep(it);\n\n          if (next === false) {\n            iteratorRecord.done = true;\n            break;\n          }\n\n          nextValue = next.value;\n        } catch (e) {\n          iteratorRecord.done = true;\n          throw e;\n        }\n\n        values[index] = void 0;\n        var nextPromise = C.resolve(nextValue);\n\n        var resolveElement = _promiseAllResolver(index, values, resultCapability, remaining);\n\n        remaining.count += 1;\n        optimizedThen(nextPromise.then, nextPromise, resolveElement, resultCapability.reject);\n        index += 1;\n      }\n\n      if (--remaining.count === 0) {\n        var resolve = resultCapability.resolve;\n        resolve(values); // call w/ this===undefined\n      }\n\n      return resultCapability.promise;\n    };\n\n    var performPromiseRace = function performPromiseRace(iteratorRecord, C, resultCapability) {\n      var it = iteratorRecord.iterator;\n      var next, nextValue, nextPromise;\n\n      while (true) {\n        try {\n          next = ES.IteratorStep(it);\n\n          if (next === false) {\n            // NOTE: If iterable has no items, resulting promise will never\n            // resolve; see:\n            // https://github.com/domenic/promises-unwrapping/issues/75\n            // https://bugs.ecmascript.org/show_bug.cgi?id=2515\n            iteratorRecord.done = true;\n            break;\n          }\n\n          nextValue = next.value;\n        } catch (e) {\n          iteratorRecord.done = true;\n          throw e;\n        }\n\n        nextPromise = C.resolve(nextValue);\n        optimizedThen(nextPromise.then, nextPromise, resultCapability.resolve, resultCapability.reject);\n      }\n\n      return resultCapability.promise;\n    };\n\n    defineProperties(Promise, {\n      all: function all(iterable) {\n        var C = this;\n\n        if (!ES.TypeIsObject(C)) {\n          throw new TypeError('Promise is not object');\n        }\n\n        var capability = new PromiseCapability(C);\n        var iterator, iteratorRecord;\n\n        try {\n          iterator = ES.GetIterator(iterable);\n          iteratorRecord = {\n            iterator: iterator,\n            done: false\n          };\n          return performPromiseAll(iteratorRecord, C, capability);\n        } catch (e) {\n          var exception = e;\n\n          if (iteratorRecord && !iteratorRecord.done) {\n            try {\n              ES.IteratorClose(iterator, true);\n            } catch (ee) {\n              exception = ee;\n            }\n          }\n\n          var reject = capability.reject;\n          reject(exception);\n          return capability.promise;\n        }\n      },\n      race: function race(iterable) {\n        var C = this;\n\n        if (!ES.TypeIsObject(C)) {\n          throw new TypeError('Promise is not object');\n        }\n\n        var capability = new PromiseCapability(C);\n        var iterator, iteratorRecord;\n\n        try {\n          iterator = ES.GetIterator(iterable);\n          iteratorRecord = {\n            iterator: iterator,\n            done: false\n          };\n          return performPromiseRace(iteratorRecord, C, capability);\n        } catch (e) {\n          var exception = e;\n\n          if (iteratorRecord && !iteratorRecord.done) {\n            try {\n              ES.IteratorClose(iterator, true);\n            } catch (ee) {\n              exception = ee;\n            }\n          }\n\n          var reject = capability.reject;\n          reject(exception);\n          return capability.promise;\n        }\n      },\n      reject: function reject(reason) {\n        var C = this;\n\n        if (!ES.TypeIsObject(C)) {\n          throw new TypeError('Bad promise constructor');\n        }\n\n        var capability = new PromiseCapability(C);\n        var rejectFunc = capability.reject;\n        rejectFunc(reason); // call with this===undefined\n\n        return capability.promise;\n      },\n      resolve: function resolve(v) {\n        // See https://esdiscuss.org/topic/fixing-promise-resolve for spec\n        var C = this;\n\n        if (!ES.TypeIsObject(C)) {\n          throw new TypeError('Bad promise constructor');\n        }\n\n        if (ES.IsPromise(v)) {\n          var constructor = v.constructor;\n\n          if (constructor === C) {\n            return v;\n          }\n        }\n\n        var capability = new PromiseCapability(C);\n        var resolveFunc = capability.resolve;\n        resolveFunc(v); // call with this===undefined\n\n        return capability.promise;\n      }\n    });\n    defineProperties(Promise$prototype, {\n      'catch': function _catch(onRejected) {\n        return this.then(null, onRejected);\n      },\n      then: function then(onFulfilled, onRejected) {\n        var promise = this;\n\n        if (!ES.IsPromise(promise)) {\n          throw new TypeError('not a promise');\n        }\n\n        var C = ES.SpeciesConstructor(promise, Promise);\n        var resultCapability;\n        var returnValueIsIgnored = arguments.length > 2 && arguments[2] === PROMISE_FAKE_CAPABILITY;\n\n        if (returnValueIsIgnored && C === Promise) {\n          resultCapability = PROMISE_FAKE_CAPABILITY;\n        } else {\n          resultCapability = new PromiseCapability(C);\n        } // PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability)\n        // Note that we've split the 'reaction' object into its two\n        // components, \"capabilities\" and \"handler\"\n        // \"capabilities\" is always equal to `resultCapability`\n\n\n        var fulfillReactionHandler = ES.IsCallable(onFulfilled) ? onFulfilled : PROMISE_IDENTITY;\n        var rejectReactionHandler = ES.IsCallable(onRejected) ? onRejected : PROMISE_THROWER;\n        var _promise = promise._promise;\n        var value;\n\n        if (_promise.state === PROMISE_PENDING) {\n          if (_promise.reactionLength === 0) {\n            _promise.fulfillReactionHandler0 = fulfillReactionHandler;\n            _promise.rejectReactionHandler0 = rejectReactionHandler;\n            _promise.reactionCapability0 = resultCapability;\n          } else {\n            var idx = 3 * (_promise.reactionLength - 1);\n            _promise[idx + PROMISE_FULFILL_OFFSET] = fulfillReactionHandler;\n            _promise[idx + PROMISE_REJECT_OFFSET] = rejectReactionHandler;\n            _promise[idx + PROMISE_CAPABILITY_OFFSET] = resultCapability;\n          }\n\n          _promise.reactionLength += 1;\n        } else if (_promise.state === PROMISE_FULFILLED) {\n          value = _promise.result;\n          enqueuePromiseReactionJob(fulfillReactionHandler, resultCapability, value);\n        } else if (_promise.state === PROMISE_REJECTED) {\n          value = _promise.result;\n          enqueuePromiseReactionJob(rejectReactionHandler, resultCapability, value);\n        } else {\n          throw new TypeError('unexpected Promise state');\n        }\n\n        return resultCapability.promise;\n      }\n    }); // This helps the optimizer by ensuring that methods which take\n    // capabilities aren't polymorphic.\n\n    PROMISE_FAKE_CAPABILITY = new PromiseCapability(Promise);\n    Promise$prototype$then = Promise$prototype.then;\n    return Promise;\n  }(); // Chrome's native Promise has extra methods that it shouldn't have. Let's remove them.\n\n\n  if (globals.Promise) {\n    delete globals.Promise.accept;\n    delete globals.Promise.defer;\n    delete globals.Promise.prototype.chain;\n  }\n\n  if (typeof PromiseShim === 'function') {\n    // export the Promise constructor.\n    defineProperties(globals, {\n      Promise: PromiseShim\n    }); // In Chrome 33 (and thereabouts) Promise is defined, but the\n    // implementation is buggy in a number of ways.  Let's check subclassing\n    // support to see if we have a buggy implementation.\n\n    var promiseSupportsSubclassing = supportsSubclassing(globals.Promise, function (S) {\n      return S.resolve(42).then(function () {}) instanceof S;\n    });\n    var promiseIgnoresNonFunctionThenCallbacks = !throwsError(function () {\n      return globals.Promise.reject(42).then(null, 5).then(null, noop);\n    });\n    var promiseRequiresObjectContext = throwsError(function () {\n      return globals.Promise.call(3, noop);\n    }); // Promise.resolve() was errata'ed late in the ES6 process.\n    // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1170742\n    //      https://code.google.com/p/v8/issues/detail?id=4161\n    // It serves as a proxy for a number of other bugs in early Promise\n    // implementations.\n\n    var promiseResolveBroken = function (Promise) {\n      var p = Promise.resolve(5);\n      p.constructor = {};\n      var p2 = Promise.resolve(p);\n\n      try {\n        p2.then(null, noop).then(null, noop); // avoid \"uncaught rejection\" warnings in console\n      } catch (e) {\n        return true; // v8 native Promises break here https://code.google.com/p/chromium/issues/detail?id=575314\n      }\n\n      return p === p2; // This *should* be false!\n    }(globals.Promise); // Chrome 46 (probably older too) does not retrieve a thenable's .then synchronously\n\n\n    var getsThenSynchronously = supportsDescriptors && function () {\n      var count = 0; // eslint-disable-next-line getter-return\n\n      var thenable = Object.defineProperty({}, 'then', {\n        get: function get() {\n          count += 1;\n        }\n      });\n      Promise.resolve(thenable);\n      return count === 1;\n    }();\n\n    var BadResolverPromise = function BadResolverPromise(executor) {\n      var p = new Promise(executor);\n      executor(3, function () {});\n      this.then = p.then;\n      this.constructor = BadResolverPromise;\n    };\n\n    BadResolverPromise.prototype = Promise.prototype;\n    BadResolverPromise.all = Promise.all; // Chrome Canary 49 (probably older too) has some implementation bugs\n\n    var hasBadResolverPromise = valueOrFalseIfThrows(function () {\n      return !!BadResolverPromise.all([1, 2]);\n    });\n\n    if (!promiseSupportsSubclassing || !promiseIgnoresNonFunctionThenCallbacks || !promiseRequiresObjectContext || promiseResolveBroken || !getsThenSynchronously || hasBadResolverPromise) {\n      /* globals Promise: true */\n\n      /* eslint-disable no-undef, no-global-assign */\n      Promise = PromiseShim;\n      /* eslint-enable no-undef, no-global-assign */\n\n      /* globals Promise: false */\n\n      overrideNative(globals, 'Promise', PromiseShim);\n    }\n\n    if (Promise.all.length !== 1) {\n      var origAll = Promise.all;\n      overrideNative(Promise, 'all', function all(iterable) {\n        return ES.Call(origAll, this, arguments);\n      });\n    }\n\n    if (Promise.race.length !== 1) {\n      var origRace = Promise.race;\n      overrideNative(Promise, 'race', function race(iterable) {\n        return ES.Call(origRace, this, arguments);\n      });\n    }\n\n    if (Promise.resolve.length !== 1) {\n      var origResolve = Promise.resolve;\n      overrideNative(Promise, 'resolve', function resolve(x) {\n        return ES.Call(origResolve, this, arguments);\n      });\n    }\n\n    if (Promise.reject.length !== 1) {\n      var origReject = Promise.reject;\n      overrideNative(Promise, 'reject', function reject(r) {\n        return ES.Call(origReject, this, arguments);\n      });\n    }\n\n    ensureEnumerable(Promise, 'all');\n    ensureEnumerable(Promise, 'race');\n    ensureEnumerable(Promise, 'resolve');\n    ensureEnumerable(Promise, 'reject');\n    addDefaultSpecies(Promise);\n  } // Map and Set require a true ES5 environment\n  // Their fast path also requires that the environment preserve\n  // property insertion order, which is not guaranteed by the spec.\n\n\n  var testOrder = function testOrder(a) {\n    var b = keys(_reduce(a, function (o, k) {\n      o[k] = true;\n      return o;\n    }, {}));\n    return a.join(':') === b.join(':');\n  };\n\n  var preservesInsertionOrder = testOrder(['z', 'a', 'bb']); // some engines (eg, Chrome) only preserve insertion order for string keys\n\n  var preservesNumericInsertionOrder = testOrder(['z', 1, 'a', '3', 2]);\n\n  if (supportsDescriptors) {\n    var fastkey = function fastkey(key, skipInsertionOrderCheck) {\n      if (!skipInsertionOrderCheck && !preservesInsertionOrder) {\n        return null;\n      }\n\n      if (isNullOrUndefined(key)) {\n        return '^' + ES.ToString(key);\n      } else if (typeof key === 'string') {\n        return '$' + key;\n      } else if (typeof key === 'number') {\n        // note that -0 will get coerced to \"0\" when used as a property key\n        if (!preservesNumericInsertionOrder) {\n          return 'n' + key;\n        }\n\n        return key;\n      } else if (typeof key === 'boolean') {\n        return 'b' + key;\n      }\n\n      return null;\n    };\n\n    var emptyObject = function emptyObject() {\n      // accomodate some older not-quite-ES5 browsers\n      return Object.create ? Object.create(null) : {};\n    };\n\n    var addIterableToMap = function addIterableToMap(MapConstructor, map, iterable) {\n      if (isArray(iterable) || Type.string(iterable)) {\n        _forEach(iterable, function (entry) {\n          if (!ES.TypeIsObject(entry)) {\n            throw new TypeError('Iterator value ' + entry + ' is not an entry object');\n          }\n\n          map.set(entry[0], entry[1]);\n        });\n      } else if (iterable instanceof MapConstructor) {\n        _call(MapConstructor.prototype.forEach, iterable, function (value, key) {\n          map.set(key, value);\n        });\n      } else {\n        var iter, adder;\n\n        if (!isNullOrUndefined(iterable)) {\n          adder = map.set;\n\n          if (!ES.IsCallable(adder)) {\n            throw new TypeError('bad map');\n          }\n\n          iter = ES.GetIterator(iterable);\n        }\n\n        if (typeof iter !== 'undefined') {\n          while (true) {\n            var next = ES.IteratorStep(iter);\n\n            if (next === false) {\n              break;\n            }\n\n            var nextItem = next.value;\n\n            try {\n              if (!ES.TypeIsObject(nextItem)) {\n                throw new TypeError('Iterator value ' + nextItem + ' is not an entry object');\n              }\n\n              _call(adder, map, nextItem[0], nextItem[1]);\n            } catch (e) {\n              ES.IteratorClose(iter, true);\n              throw e;\n            }\n          }\n        }\n      }\n    };\n\n    var addIterableToSet = function addIterableToSet(SetConstructor, set, iterable) {\n      if (isArray(iterable) || Type.string(iterable)) {\n        _forEach(iterable, function (value) {\n          set.add(value);\n        });\n      } else if (iterable instanceof SetConstructor) {\n        _call(SetConstructor.prototype.forEach, iterable, function (value) {\n          set.add(value);\n        });\n      } else {\n        var iter, adder;\n\n        if (!isNullOrUndefined(iterable)) {\n          adder = set.add;\n\n          if (!ES.IsCallable(adder)) {\n            throw new TypeError('bad set');\n          }\n\n          iter = ES.GetIterator(iterable);\n        }\n\n        if (typeof iter !== 'undefined') {\n          while (true) {\n            var next = ES.IteratorStep(iter);\n\n            if (next === false) {\n              break;\n            }\n\n            var nextValue = next.value;\n\n            try {\n              _call(adder, set, nextValue);\n            } catch (e) {\n              ES.IteratorClose(iter, true);\n              throw e;\n            }\n          }\n        }\n      }\n    };\n\n    var collectionShims = {\n      Map: function () {\n        var empty = {};\n\n        var MapEntry = function MapEntry(key, value) {\n          this.key = key;\n          this.value = value;\n          this.next = null;\n          this.prev = null;\n        };\n\n        MapEntry.prototype.isRemoved = function isRemoved() {\n          return this.key === empty;\n        };\n\n        var isMap = function isMap(map) {\n          return !!map._es6map;\n        };\n\n        var requireMapSlot = function requireMapSlot(map, method) {\n          if (!ES.TypeIsObject(map) || !isMap(map)) {\n            throw new TypeError('Method Map.prototype.' + method + ' called on incompatible receiver ' + ES.ToString(map));\n          }\n        };\n\n        var MapIterator = function MapIterator(map, kind) {\n          requireMapSlot(map, '[[MapIterator]]');\n          this.head = map._head;\n          this.i = this.head;\n          this.kind = kind;\n        };\n\n        MapIterator.prototype = {\n          isMapIterator: true,\n          next: function next() {\n            if (!this.isMapIterator) {\n              throw new TypeError('Not a MapIterator');\n            }\n\n            var i = this.i;\n            var kind = this.kind;\n            var head = this.head;\n\n            if (typeof this.i === 'undefined') {\n              return iteratorResult();\n            }\n\n            while (i.isRemoved() && i !== head) {\n              // back up off of removed entries\n              i = i.prev;\n            } // advance to next unreturned element.\n\n\n            var result;\n\n            while (i.next !== head) {\n              i = i.next;\n\n              if (!i.isRemoved()) {\n                if (kind === 'key') {\n                  result = i.key;\n                } else if (kind === 'value') {\n                  result = i.value;\n                } else {\n                  result = [i.key, i.value];\n                }\n\n                this.i = i;\n                return iteratorResult(result);\n              }\n            } // once the iterator is done, it is done forever.\n\n\n            this.i = void 0;\n            return iteratorResult();\n          }\n        };\n        addIterator(MapIterator.prototype);\n        var Map$prototype;\n\n        var MapShim = function Map() {\n          if (!(this instanceof Map)) {\n            throw new TypeError('Constructor Map requires \"new\"');\n          }\n\n          if (this && this._es6map) {\n            throw new TypeError('Bad construction');\n          }\n\n          var map = emulateES6construct(this, Map, Map$prototype, {\n            _es6map: true,\n            _head: null,\n            _map: OrigMap ? new OrigMap() : null,\n            _size: 0,\n            _storage: emptyObject()\n          });\n          var head = new MapEntry(null, null); // circular doubly-linked list.\n\n          /* eslint no-multi-assign: 1 */\n\n          head.next = head.prev = head;\n          map._head = head; // Optionally initialize map from iterable\n\n          if (arguments.length > 0) {\n            addIterableToMap(Map, map, arguments[0]);\n          }\n\n          return map;\n        };\n\n        Map$prototype = MapShim.prototype;\n        Value.getter(Map$prototype, 'size', function () {\n          if (typeof this._size === 'undefined') {\n            throw new TypeError('size method called on incompatible Map');\n          }\n\n          return this._size;\n        });\n        defineProperties(Map$prototype, {\n          get: function get(key) {\n            requireMapSlot(this, 'get');\n            var entry;\n            var fkey = fastkey(key, true);\n\n            if (fkey !== null) {\n              // fast O(1) path\n              entry = this._storage[fkey];\n\n              if (entry) {\n                return entry.value;\n              } else {\n                return;\n              }\n            }\n\n            if (this._map) {\n              // fast object key path\n              entry = origMapGet.call(this._map, key);\n\n              if (entry) {\n                return entry.value;\n              } else {\n                return;\n              }\n            }\n\n            var head = this._head;\n            var i = head;\n\n            while ((i = i.next) !== head) {\n              if (ES.SameValueZero(i.key, key)) {\n                return i.value;\n              }\n            }\n          },\n          has: function has(key) {\n            requireMapSlot(this, 'has');\n            var fkey = fastkey(key, true);\n\n            if (fkey !== null) {\n              // fast O(1) path\n              return typeof this._storage[fkey] !== 'undefined';\n            }\n\n            if (this._map) {\n              // fast object key path\n              return origMapHas.call(this._map, key);\n            }\n\n            var head = this._head;\n            var i = head;\n\n            while ((i = i.next) !== head) {\n              if (ES.SameValueZero(i.key, key)) {\n                return true;\n              }\n            }\n\n            return false;\n          },\n          set: function set(key, value) {\n            requireMapSlot(this, 'set');\n            var head = this._head;\n            var i = head;\n            var entry;\n            var fkey = fastkey(key, true);\n\n            if (fkey !== null) {\n              // fast O(1) path\n              if (typeof this._storage[fkey] !== 'undefined') {\n                this._storage[fkey].value = value;\n                return this;\n              } else {\n                entry = this._storage[fkey] = new MapEntry(key, value);\n                /* eslint no-multi-assign: 1 */\n\n                i = head.prev; // fall through\n              }\n            } else if (this._map) {\n              // fast object key path\n              if (origMapHas.call(this._map, key)) {\n                origMapGet.call(this._map, key).value = value;\n              } else {\n                entry = new MapEntry(key, value);\n                origMapSet.call(this._map, key, entry);\n                i = head.prev; // fall through\n              }\n            }\n\n            while ((i = i.next) !== head) {\n              if (ES.SameValueZero(i.key, key)) {\n                i.value = value;\n                return this;\n              }\n            }\n\n            entry = entry || new MapEntry(key, value);\n\n            if (ES.SameValue(-0, key)) {\n              entry.key = +0; // coerce -0 to +0 in entry\n            }\n\n            entry.next = this._head;\n            entry.prev = this._head.prev;\n            entry.prev.next = entry;\n            entry.next.prev = entry;\n            this._size += 1;\n            return this;\n          },\n          'delete': function _delete(key) {\n            requireMapSlot(this, 'delete');\n            var head = this._head;\n            var i = head;\n            var fkey = fastkey(key, true);\n\n            if (fkey !== null) {\n              // fast O(1) path\n              if (typeof this._storage[fkey] === 'undefined') {\n                return false;\n              }\n\n              i = this._storage[fkey].prev;\n              delete this._storage[fkey]; // fall through\n            } else if (this._map) {\n              // fast object key path\n              if (!origMapHas.call(this._map, key)) {\n                return false;\n              }\n\n              i = origMapGet.call(this._map, key).prev;\n              origMapDelete.call(this._map, key); // fall through\n            }\n\n            while ((i = i.next) !== head) {\n              if (ES.SameValueZero(i.key, key)) {\n                i.key = empty;\n                i.value = empty;\n                i.prev.next = i.next;\n                i.next.prev = i.prev;\n                this._size -= 1;\n                return true;\n              }\n            }\n\n            return false;\n          },\n          clear: function clear() {\n            /* eslint no-multi-assign: 1 */\n            requireMapSlot(this, 'clear');\n            this._map = OrigMap ? new OrigMap() : null;\n            this._size = 0;\n            this._storage = emptyObject();\n            var head = this._head;\n            var i = head;\n            var p = i.next;\n\n            while ((i = p) !== head) {\n              i.key = empty;\n              i.value = empty;\n              p = i.next;\n              i.next = i.prev = head;\n            }\n\n            head.next = head.prev = head;\n          },\n          keys: function keys() {\n            requireMapSlot(this, 'keys');\n            return new MapIterator(this, 'key');\n          },\n          values: function values() {\n            requireMapSlot(this, 'values');\n            return new MapIterator(this, 'value');\n          },\n          entries: function entries() {\n            requireMapSlot(this, 'entries');\n            return new MapIterator(this, 'key+value');\n          },\n          forEach: function forEach(callback) {\n            requireMapSlot(this, 'forEach');\n            var context = arguments.length > 1 ? arguments[1] : null;\n            var it = this.entries();\n\n            for (var entry = it.next(); !entry.done; entry = it.next()) {\n              if (context) {\n                _call(callback, context, entry.value[1], entry.value[0], this);\n              } else {\n                callback(entry.value[1], entry.value[0], this);\n              }\n            }\n          }\n        });\n        addIterator(Map$prototype, Map$prototype.entries);\n        return MapShim;\n      }(),\n      Set: function () {\n        var isSet = function isSet(set) {\n          return set._es6set && typeof set._storage !== 'undefined';\n        };\n\n        var requireSetSlot = function requireSetSlot(set, method) {\n          if (!ES.TypeIsObject(set) || !isSet(set)) {\n            // https://github.com/paulmillr/es6-shim/issues/176\n            throw new TypeError('Set.prototype.' + method + ' called on incompatible receiver ' + ES.ToString(set));\n          }\n        }; // Creating a Map is expensive.  To speed up the common case of\n        // Sets containing only string or numeric keys, we use an object\n        // as backing storage and lazily create a full Map only when\n        // required.\n\n\n        var Set$prototype;\n\n        var SetShim = function Set() {\n          if (!(this instanceof Set)) {\n            throw new TypeError('Constructor Set requires \"new\"');\n          }\n\n          if (this && this._es6set) {\n            throw new TypeError('Bad construction');\n          }\n\n          var set = emulateES6construct(this, Set, Set$prototype, {\n            _es6set: true,\n            '[[SetData]]': null,\n            _storage: emptyObject()\n          });\n\n          if (!set._es6set) {\n            throw new TypeError('bad set');\n          } // Optionally initialize Set from iterable\n\n\n          if (arguments.length > 0) {\n            addIterableToSet(Set, set, arguments[0]);\n          }\n\n          return set;\n        };\n\n        Set$prototype = SetShim.prototype;\n\n        var decodeKey = function decodeKey(key) {\n          var k = key;\n\n          if (k === '^null') {\n            return null;\n          } else if (k === '^undefined') {\n            return void 0;\n          } else {\n            var first = k.charAt(0);\n\n            if (first === '$') {\n              return _strSlice(k, 1);\n            } else if (first === 'n') {\n              return +_strSlice(k, 1);\n            } else if (first === 'b') {\n              return k === 'btrue';\n            }\n          }\n\n          return +k;\n        }; // Switch from the object backing storage to a full Map.\n\n\n        var ensureMap = function ensureMap(set) {\n          if (!set['[[SetData]]']) {\n            var m = new collectionShims.Map();\n            set['[[SetData]]'] = m;\n\n            _forEach(keys(set._storage), function (key) {\n              var k = decodeKey(key);\n              m.set(k, k);\n            });\n\n            set['[[SetData]]'] = m;\n          }\n\n          set._storage = null; // free old backing storage\n        };\n\n        Value.getter(SetShim.prototype, 'size', function () {\n          requireSetSlot(this, 'size');\n\n          if (this._storage) {\n            return keys(this._storage).length;\n          }\n\n          ensureMap(this);\n          return this['[[SetData]]'].size;\n        });\n        defineProperties(SetShim.prototype, {\n          has: function has(key) {\n            requireSetSlot(this, 'has');\n            var fkey;\n\n            if (this._storage && (fkey = fastkey(key)) !== null) {\n              return !!this._storage[fkey];\n            }\n\n            ensureMap(this);\n            return this['[[SetData]]'].has(key);\n          },\n          add: function add(key) {\n            requireSetSlot(this, 'add');\n            var fkey;\n\n            if (this._storage && (fkey = fastkey(key)) !== null) {\n              this._storage[fkey] = true;\n              return this;\n            }\n\n            ensureMap(this);\n            this['[[SetData]]'].set(key, key);\n            return this;\n          },\n          'delete': function _delete(key) {\n            requireSetSlot(this, 'delete');\n            var fkey;\n\n            if (this._storage && (fkey = fastkey(key)) !== null) {\n              var hasFKey = _hasOwnProperty(this._storage, fkey);\n\n              return delete this._storage[fkey] && hasFKey;\n            }\n\n            ensureMap(this);\n            return this['[[SetData]]']['delete'](key);\n          },\n          clear: function clear() {\n            requireSetSlot(this, 'clear');\n\n            if (this._storage) {\n              this._storage = emptyObject();\n            }\n\n            if (this['[[SetData]]']) {\n              this['[[SetData]]'].clear();\n            }\n          },\n          values: function values() {\n            requireSetSlot(this, 'values');\n            ensureMap(this);\n            return new SetIterator(this['[[SetData]]'].values());\n          },\n          entries: function entries() {\n            requireSetSlot(this, 'entries');\n            ensureMap(this);\n            return new SetIterator(this['[[SetData]]'].entries());\n          },\n          forEach: function forEach(callback) {\n            requireSetSlot(this, 'forEach');\n            var context = arguments.length > 1 ? arguments[1] : null;\n            var entireSet = this;\n            ensureMap(entireSet);\n            this['[[SetData]]'].forEach(function (value, key) {\n              if (context) {\n                _call(callback, context, key, key, entireSet);\n              } else {\n                callback(key, key, entireSet);\n              }\n            });\n          }\n        });\n        defineProperty(SetShim.prototype, 'keys', SetShim.prototype.values, true);\n        addIterator(SetShim.prototype, SetShim.prototype.values);\n\n        var SetIterator = function SetIterator(it) {\n          this.it = it;\n        };\n\n        SetIterator.prototype = {\n          isSetIterator: true,\n          next: function next() {\n            if (!this.isSetIterator) {\n              throw new TypeError('Not a SetIterator');\n            }\n\n            return this.it.next();\n          }\n        };\n        addIterator(SetIterator.prototype);\n        return SetShim;\n      }()\n    };\n    var isGoogleTranslate = globals.Set && !Set.prototype['delete'] && Set.prototype.remove && Set.prototype.items && Set.prototype.map && Array.isArray(new Set().keys);\n\n    if (isGoogleTranslate) {\n      // special-case force removal of wildly invalid Set implementation in Google Translate iframes\n      // see https://github.com/paulmillr/es6-shim/issues/438 / https://twitter.com/ljharb/status/849335573114363904\n      globals.Set = collectionShims.Set;\n    }\n\n    if (globals.Map || globals.Set) {\n      // Safari 8, for example, doesn't accept an iterable.\n      var mapAcceptsArguments = valueOrFalseIfThrows(function () {\n        return new Map([[1, 2]]).get(1) === 2;\n      });\n\n      if (!mapAcceptsArguments) {\n        globals.Map = function Map() {\n          if (!(this instanceof Map)) {\n            throw new TypeError('Constructor Map requires \"new\"');\n          }\n\n          var m = new OrigMap();\n\n          if (arguments.length > 0) {\n            addIterableToMap(Map, m, arguments[0]);\n          }\n\n          delete m.constructor;\n          Object.setPrototypeOf(m, globals.Map.prototype);\n          return m;\n        };\n\n        globals.Map.prototype = create(OrigMap.prototype);\n        defineProperty(globals.Map.prototype, 'constructor', globals.Map, true);\n        Value.preserveToString(globals.Map, OrigMap);\n      }\n\n      var testMap = new Map();\n\n      var mapUsesSameValueZero = function () {\n        // Chrome 38-42, node 0.11/0.12, iojs 1/2 also have a bug when the Map has a size > 4\n        var m = new Map([[1, 0], [2, 0], [3, 0], [4, 0]]);\n        m.set(-0, m);\n        return m.get(0) === m && m.get(-0) === m && m.has(0) && m.has(-0);\n      }();\n\n      var mapSupportsChaining = testMap.set(1, 2) === testMap;\n\n      if (!mapUsesSameValueZero || !mapSupportsChaining) {\n        overrideNative(Map.prototype, 'set', function set(k, v) {\n          _call(origMapSet, this, k === 0 ? 0 : k, v);\n\n          return this;\n        });\n      }\n\n      if (!mapUsesSameValueZero) {\n        defineProperties(Map.prototype, {\n          get: function get(k) {\n            return _call(origMapGet, this, k === 0 ? 0 : k);\n          },\n          has: function has(k) {\n            return _call(origMapHas, this, k === 0 ? 0 : k);\n          }\n        }, true);\n        Value.preserveToString(Map.prototype.get, origMapGet);\n        Value.preserveToString(Map.prototype.has, origMapHas);\n      }\n\n      var testSet = new Set();\n\n      var setUsesSameValueZero = Set.prototype['delete'] && Set.prototype.add && Set.prototype.has && function (s) {\n        s['delete'](0);\n        s.add(-0);\n        return !s.has(0);\n      }(testSet);\n\n      var setSupportsChaining = testSet.add(1) === testSet;\n\n      if (!setUsesSameValueZero || !setSupportsChaining) {\n        var origSetAdd = Set.prototype.add;\n\n        Set.prototype.add = function add(v) {\n          _call(origSetAdd, this, v === 0 ? 0 : v);\n\n          return this;\n        };\n\n        Value.preserveToString(Set.prototype.add, origSetAdd);\n      }\n\n      if (!setUsesSameValueZero) {\n        var origSetHas = Set.prototype.has;\n\n        Set.prototype.has = function has(v) {\n          return _call(origSetHas, this, v === 0 ? 0 : v);\n        };\n\n        Value.preserveToString(Set.prototype.has, origSetHas);\n        var origSetDel = Set.prototype['delete'];\n\n        Set.prototype['delete'] = function SetDelete(v) {\n          return _call(origSetDel, this, v === 0 ? 0 : v);\n        };\n\n        Value.preserveToString(Set.prototype['delete'], origSetDel);\n      }\n\n      var mapSupportsSubclassing = supportsSubclassing(globals.Map, function (M) {\n        var m = new M([]); // Firefox 32 is ok with the instantiating the subclass but will\n        // throw when the map is used.\n\n        m.set(42, 42);\n        return m instanceof M;\n      }); // without Object.setPrototypeOf, subclassing is not possible\n\n      var mapFailsToSupportSubclassing = Object.setPrototypeOf && !mapSupportsSubclassing;\n\n      var mapRequiresNew = function () {\n        try {\n          return !(globals.Map() instanceof globals.Map);\n        } catch (e) {\n          return e instanceof TypeError;\n        }\n      }();\n\n      if (globals.Map.length !== 0 || mapFailsToSupportSubclassing || !mapRequiresNew) {\n        globals.Map = function Map() {\n          if (!(this instanceof Map)) {\n            throw new TypeError('Constructor Map requires \"new\"');\n          }\n\n          var m = new OrigMap();\n\n          if (arguments.length > 0) {\n            addIterableToMap(Map, m, arguments[0]);\n          }\n\n          delete m.constructor;\n          Object.setPrototypeOf(m, Map.prototype);\n          return m;\n        };\n\n        globals.Map.prototype = OrigMap.prototype;\n        defineProperty(globals.Map.prototype, 'constructor', globals.Map, true);\n        Value.preserveToString(globals.Map, OrigMap);\n      }\n\n      var setSupportsSubclassing = supportsSubclassing(globals.Set, function (S) {\n        var s = new S([]);\n        s.add(42, 42);\n        return s instanceof S;\n      }); // without Object.setPrototypeOf, subclassing is not possible\n\n      var setFailsToSupportSubclassing = Object.setPrototypeOf && !setSupportsSubclassing;\n\n      var setRequiresNew = function () {\n        try {\n          return !(globals.Set() instanceof globals.Set);\n        } catch (e) {\n          return e instanceof TypeError;\n        }\n      }();\n\n      if (globals.Set.length !== 0 || setFailsToSupportSubclassing || !setRequiresNew) {\n        var OrigSet = globals.Set;\n\n        globals.Set = function Set() {\n          if (!(this instanceof Set)) {\n            throw new TypeError('Constructor Set requires \"new\"');\n          }\n\n          var s = new OrigSet();\n\n          if (arguments.length > 0) {\n            addIterableToSet(Set, s, arguments[0]);\n          }\n\n          delete s.constructor;\n          Object.setPrototypeOf(s, Set.prototype);\n          return s;\n        };\n\n        globals.Set.prototype = OrigSet.prototype;\n        defineProperty(globals.Set.prototype, 'constructor', globals.Set, true);\n        Value.preserveToString(globals.Set, OrigSet);\n      }\n\n      var newMap = new globals.Map();\n      var mapIterationThrowsStopIterator = !valueOrFalseIfThrows(function () {\n        return newMap.keys().next().done;\n      });\n      /*\n        - In Firefox < 23, Map#size is a function.\n        - In all current Firefox, Set#entries/keys/values & Map#clear do not exist\n        - https://bugzilla.mozilla.org/show_bug.cgi?id=869996\n        - In Firefox 24, Map and Set do not implement forEach\n        - In Firefox 25 at least, Map and Set are callable without \"new\"\n      */\n\n      if (typeof globals.Map.prototype.clear !== 'function' || new globals.Set().size !== 0 || newMap.size !== 0 || typeof globals.Map.prototype.keys !== 'function' || typeof globals.Set.prototype.keys !== 'function' || typeof globals.Map.prototype.forEach !== 'function' || typeof globals.Set.prototype.forEach !== 'function' || isCallableWithoutNew(globals.Map) || isCallableWithoutNew(globals.Set) || typeof newMap.keys().next !== 'function' || // Safari 8\n      mapIterationThrowsStopIterator || // Firefox 25\n      !mapSupportsSubclassing) {\n        defineProperties(globals, {\n          Map: collectionShims.Map,\n          Set: collectionShims.Set\n        }, true);\n      }\n\n      if (globals.Set.prototype.keys !== globals.Set.prototype.values) {\n        // Fixed in WebKit with https://bugs.webkit.org/show_bug.cgi?id=144190\n        defineProperty(globals.Set.prototype, 'keys', globals.Set.prototype.values, true);\n      } // Shim incomplete iterator implementations.\n\n\n      addIterator(Object.getPrototypeOf(new globals.Map().keys()));\n      addIterator(Object.getPrototypeOf(new globals.Set().keys()));\n\n      if (functionsHaveNames && globals.Set.prototype.has.name !== 'has') {\n        // Microsoft Edge v0.11.10074.0 is missing a name on Set#has\n        var anonymousSetHas = globals.Set.prototype.has;\n        overrideNative(globals.Set.prototype, 'has', function has(key) {\n          return _call(anonymousSetHas, this, key);\n        });\n      }\n    }\n\n    defineProperties(globals, collectionShims);\n    addDefaultSpecies(globals.Map);\n    addDefaultSpecies(globals.Set);\n  }\n\n  var throwUnlessTargetIsObject = function throwUnlessTargetIsObject(target) {\n    if (!ES.TypeIsObject(target)) {\n      throw new TypeError('target must be an object');\n    }\n  }; // Some Reflect methods are basically the same as\n  // those on the Object global, except that a TypeError is thrown if\n  // target isn't an object. As well as returning a boolean indicating\n  // the success of the operation.\n\n\n  var ReflectShims = {\n    // Apply method in a functional form.\n    apply: function apply() {\n      return ES.Call(ES.Call, null, arguments);\n    },\n    // New operator in a functional form.\n    construct: function construct(constructor, args) {\n      if (!ES.IsConstructor(constructor)) {\n        throw new TypeError('First argument must be a constructor.');\n      }\n\n      var newTarget = arguments.length > 2 ? arguments[2] : constructor;\n\n      if (!ES.IsConstructor(newTarget)) {\n        throw new TypeError('new.target must be a constructor.');\n      }\n\n      return ES.Construct(constructor, args, newTarget, 'internal');\n    },\n    // When deleting a non-existent or configurable property,\n    // true is returned.\n    // When attempting to delete a non-configurable property,\n    // it will return false.\n    deleteProperty: function deleteProperty(target, key) {\n      throwUnlessTargetIsObject(target);\n\n      if (supportsDescriptors) {\n        var desc = Object.getOwnPropertyDescriptor(target, key);\n\n        if (desc && !desc.configurable) {\n          return false;\n        }\n      } // Will return true.\n\n\n      return delete target[key];\n    },\n    has: function has(target, key) {\n      throwUnlessTargetIsObject(target);\n      return key in target;\n    }\n  };\n\n  if (Object.getOwnPropertyNames) {\n    Object.assign(ReflectShims, {\n      // Basically the result of calling the internal [[OwnPropertyKeys]].\n      // Concatenating propertyNames and propertySymbols should do the trick.\n      // This should continue to work together with a Symbol shim\n      // which overrides Object.getOwnPropertyNames and implements\n      // Object.getOwnPropertySymbols.\n      ownKeys: function ownKeys(target) {\n        throwUnlessTargetIsObject(target);\n        var keys = Object.getOwnPropertyNames(target);\n\n        if (ES.IsCallable(Object.getOwnPropertySymbols)) {\n          _pushApply(keys, Object.getOwnPropertySymbols(target));\n        }\n\n        return keys;\n      }\n    });\n  }\n\n  var callAndCatchException = function ConvertExceptionToBoolean(func) {\n    return !throwsError(func);\n  };\n\n  if (Object.preventExtensions) {\n    Object.assign(ReflectShims, {\n      isExtensible: function isExtensible(target) {\n        throwUnlessTargetIsObject(target);\n        return Object.isExtensible(target);\n      },\n      preventExtensions: function preventExtensions(target) {\n        throwUnlessTargetIsObject(target);\n        return callAndCatchException(function () {\n          return Object.preventExtensions(target);\n        });\n      }\n    });\n  }\n\n  if (supportsDescriptors) {\n    var internalGet = function get(target, key, receiver) {\n      var desc = Object.getOwnPropertyDescriptor(target, key);\n\n      if (!desc) {\n        var parent = Object.getPrototypeOf(target);\n\n        if (parent === null) {\n          return void 0;\n        }\n\n        return internalGet(parent, key, receiver);\n      }\n\n      if ('value' in desc) {\n        return desc.value;\n      }\n\n      if (desc.get) {\n        return ES.Call(desc.get, receiver);\n      }\n\n      return void 0;\n    };\n\n    var internalSet = function set(target, key, value, receiver) {\n      var desc = Object.getOwnPropertyDescriptor(target, key);\n\n      if (!desc) {\n        var parent = Object.getPrototypeOf(target);\n\n        if (parent !== null) {\n          return internalSet(parent, key, value, receiver);\n        }\n\n        desc = {\n          value: void 0,\n          writable: true,\n          enumerable: true,\n          configurable: true\n        };\n      }\n\n      if ('value' in desc) {\n        if (!desc.writable) {\n          return false;\n        }\n\n        if (!ES.TypeIsObject(receiver)) {\n          return false;\n        }\n\n        var existingDesc = Object.getOwnPropertyDescriptor(receiver, key);\n\n        if (existingDesc) {\n          return Reflect.defineProperty(receiver, key, {\n            value: value\n          });\n        } else {\n          return Reflect.defineProperty(receiver, key, {\n            value: value,\n            writable: true,\n            enumerable: true,\n            configurable: true\n          });\n        }\n      }\n\n      if (desc.set) {\n        _call(desc.set, receiver, value);\n\n        return true;\n      }\n\n      return false;\n    };\n\n    Object.assign(ReflectShims, {\n      defineProperty: function defineProperty(target, propertyKey, attributes) {\n        throwUnlessTargetIsObject(target);\n        return callAndCatchException(function () {\n          return Object.defineProperty(target, propertyKey, attributes);\n        });\n      },\n      getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) {\n        throwUnlessTargetIsObject(target);\n        return Object.getOwnPropertyDescriptor(target, propertyKey);\n      },\n      // Syntax in a functional form.\n      get: function get(target, key) {\n        throwUnlessTargetIsObject(target);\n        var receiver = arguments.length > 2 ? arguments[2] : target;\n        return internalGet(target, key, receiver);\n      },\n      set: function set(target, key, value) {\n        throwUnlessTargetIsObject(target);\n        var receiver = arguments.length > 3 ? arguments[3] : target;\n        return internalSet(target, key, value, receiver);\n      }\n    });\n  }\n\n  if (Object.getPrototypeOf) {\n    var objectDotGetPrototypeOf = Object.getPrototypeOf;\n\n    ReflectShims.getPrototypeOf = function getPrototypeOf(target) {\n      throwUnlessTargetIsObject(target);\n      return objectDotGetPrototypeOf(target);\n    };\n  }\n\n  if (Object.setPrototypeOf && ReflectShims.getPrototypeOf) {\n    var willCreateCircularPrototype = function willCreateCircularPrototype(object, lastProto) {\n      var proto = lastProto;\n\n      while (proto) {\n        if (object === proto) {\n          return true;\n        }\n\n        proto = ReflectShims.getPrototypeOf(proto);\n      }\n\n      return false;\n    };\n\n    Object.assign(ReflectShims, {\n      // Sets the prototype of the given object.\n      // Returns true on success, otherwise false.\n      setPrototypeOf: function setPrototypeOf(object, proto) {\n        throwUnlessTargetIsObject(object);\n\n        if (proto !== null && !ES.TypeIsObject(proto)) {\n          throw new TypeError('proto must be an object or null');\n        } // If they already are the same, we're done.\n\n\n        if (proto === Reflect.getPrototypeOf(object)) {\n          return true;\n        } // Cannot alter prototype if object not extensible.\n\n\n        if (Reflect.isExtensible && !Reflect.isExtensible(object)) {\n          return false;\n        } // Ensure that we do not create a circular prototype chain.\n\n\n        if (willCreateCircularPrototype(object, proto)) {\n          return false;\n        }\n\n        Object.setPrototypeOf(object, proto);\n        return true;\n      }\n    });\n  }\n\n  var defineOrOverrideReflectProperty = function defineOrOverrideReflectProperty(key, shim) {\n    if (!ES.IsCallable(globals.Reflect[key])) {\n      defineProperty(globals.Reflect, key, shim);\n    } else {\n      var acceptsPrimitives = valueOrFalseIfThrows(function () {\n        globals.Reflect[key](1);\n        globals.Reflect[key](NaN);\n        globals.Reflect[key](true);\n        return true;\n      });\n\n      if (acceptsPrimitives) {\n        overrideNative(globals.Reflect, key, shim);\n      }\n    }\n  };\n\n  Object.keys(ReflectShims).forEach(function (key) {\n    defineOrOverrideReflectProperty(key, ReflectShims[key]);\n  });\n  var originalReflectGetProto = globals.Reflect.getPrototypeOf;\n\n  if (functionsHaveNames && originalReflectGetProto && originalReflectGetProto.name !== 'getPrototypeOf') {\n    overrideNative(globals.Reflect, 'getPrototypeOf', function getPrototypeOf(target) {\n      return _call(originalReflectGetProto, globals.Reflect, target);\n    });\n  }\n\n  if (globals.Reflect.setPrototypeOf) {\n    if (valueOrFalseIfThrows(function () {\n      globals.Reflect.setPrototypeOf(1, {});\n      return true;\n    })) {\n      overrideNative(globals.Reflect, 'setPrototypeOf', ReflectShims.setPrototypeOf);\n    }\n  }\n\n  if (globals.Reflect.defineProperty) {\n    if (!valueOrFalseIfThrows(function () {\n      var basic = !globals.Reflect.defineProperty(1, 'test', {\n        value: 1\n      }); // \"extensible\" fails on Edge 0.12\n\n      var extensible = typeof Object.preventExtensions !== 'function' || !globals.Reflect.defineProperty(Object.preventExtensions({}), 'test', {});\n      return basic && extensible;\n    })) {\n      overrideNative(globals.Reflect, 'defineProperty', ReflectShims.defineProperty);\n    }\n  }\n\n  if (globals.Reflect.construct) {\n    if (!valueOrFalseIfThrows(function () {\n      var F = function F() {};\n\n      return globals.Reflect.construct(function () {}, [], F) instanceof F;\n    })) {\n      overrideNative(globals.Reflect, 'construct', ReflectShims.construct);\n    }\n  }\n\n  if (String(new Date(NaN)) !== 'Invalid Date') {\n    var dateToString = Date.prototype.toString;\n\n    var shimmedDateToString = function toString() {\n      var valueOf = +this;\n\n      if (valueOf !== valueOf) {\n        return 'Invalid Date';\n      }\n\n      return ES.Call(dateToString, this);\n    };\n\n    overrideNative(Date.prototype, 'toString', shimmedDateToString);\n  } // Annex B HTML methods\n  // http://www.ecma-international.org/ecma-262/6.0/#sec-additional-properties-of-the-string.prototype-object\n\n\n  var stringHTMLshims = {\n    anchor: function anchor(name) {\n      return ES.CreateHTML(this, 'a', 'name', name);\n    },\n    big: function big() {\n      return ES.CreateHTML(this, 'big', '', '');\n    },\n    blink: function blink() {\n      return ES.CreateHTML(this, 'blink', '', '');\n    },\n    bold: function bold() {\n      return ES.CreateHTML(this, 'b', '', '');\n    },\n    fixed: function fixed() {\n      return ES.CreateHTML(this, 'tt', '', '');\n    },\n    fontcolor: function fontcolor(color) {\n      return ES.CreateHTML(this, 'font', 'color', color);\n    },\n    fontsize: function fontsize(size) {\n      return ES.CreateHTML(this, 'font', 'size', size);\n    },\n    italics: function italics() {\n      return ES.CreateHTML(this, 'i', '', '');\n    },\n    link: function link(url) {\n      return ES.CreateHTML(this, 'a', 'href', url);\n    },\n    small: function small() {\n      return ES.CreateHTML(this, 'small', '', '');\n    },\n    strike: function strike() {\n      return ES.CreateHTML(this, 'strike', '', '');\n    },\n    sub: function sub() {\n      return ES.CreateHTML(this, 'sub', '', '');\n    },\n    sup: function sub() {\n      return ES.CreateHTML(this, 'sup', '', '');\n    }\n  };\n\n  _forEach(Object.keys(stringHTMLshims), function (key) {\n    var method = String.prototype[key];\n    var shouldOverwrite = false;\n\n    if (ES.IsCallable(method)) {\n      var output = _call(method, '', ' \" ');\n\n      var quotesCount = _concat([], output.match(/\"/g)).length;\n\n      shouldOverwrite = output !== output.toLowerCase() || quotesCount > 2;\n    } else {\n      shouldOverwrite = true;\n    }\n\n    if (shouldOverwrite) {\n      overrideNative(String.prototype, key, stringHTMLshims[key]);\n    }\n  });\n\n  var JSONstringifiesSymbols = function () {\n    // Microsoft Edge v0.12 stringifies Symbols incorrectly\n    if (!hasSymbols) {\n      return false;\n    } // Symbols are not supported\n\n\n    var stringify = (typeof JSON === \"undefined\" ? \"undefined\" : _typeof(JSON)) === 'object' && typeof JSON.stringify === 'function' ? JSON.stringify : null;\n\n    if (!stringify) {\n      return false;\n    } // JSON.stringify is not supported\n\n\n    if (typeof stringify(_Symbol()) !== 'undefined') {\n      return true;\n    } // Symbols should become `undefined`\n\n\n    if (stringify([_Symbol()]) !== '[null]') {\n      return true;\n    } // Symbols in arrays should become `null`\n\n\n    var obj = {\n      a: _Symbol()\n    };\n    obj[_Symbol()] = true;\n\n    if (stringify(obj) !== '{}') {\n      return true;\n    } // Symbol-valued keys *and* Symbol-valued properties should be omitted\n\n\n    return false;\n  }();\n\n  var JSONstringifyAcceptsObjectSymbol = valueOrFalseIfThrows(function () {\n    // Chrome 45 throws on stringifying object symbols\n    if (!hasSymbols) {\n      return true;\n    } // Symbols are not supported\n\n\n    return JSON.stringify(Object(_Symbol())) === '{}' && JSON.stringify([Object(_Symbol())]) === '[{}]';\n  });\n\n  if (JSONstringifiesSymbols || !JSONstringifyAcceptsObjectSymbol) {\n    var origStringify = JSON.stringify;\n    overrideNative(JSON, 'stringify', function stringify(value) {\n      if (_typeof(value) === 'symbol') {\n        return;\n      }\n\n      var replacer;\n\n      if (arguments.length > 1) {\n        replacer = arguments[1];\n      }\n\n      var args = [value];\n\n      if (!isArray(replacer)) {\n        var replaceFn = ES.IsCallable(replacer) ? replacer : null;\n\n        var wrappedReplacer = function wrappedReplacer(key, val) {\n          var parsedValue = replaceFn ? _call(replaceFn, this, key, val) : val;\n\n          if (_typeof(parsedValue) !== 'symbol') {\n            if (Type.symbol(parsedValue)) {\n              return assignTo({})(parsedValue);\n            } else {\n              return parsedValue;\n            }\n          }\n        };\n\n        args.push(wrappedReplacer);\n      } else {\n        // create wrapped replacer that handles an array replacer?\n        args.push(replacer);\n      }\n\n      if (arguments.length > 2) {\n        args.push(arguments[2]);\n      }\n\n      return origStringify.apply(this, args);\n    });\n  }\n\n  return globals;\n});","// shim for using process in browser\nvar process = module.exports = {}; // cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n  throw new Error('setTimeout has not been defined');\n}\n\nfunction defaultClearTimeout() {\n  throw new Error('clearTimeout has not been defined');\n}\n\n(function () {\n  try {\n    if (typeof setTimeout === 'function') {\n      cachedSetTimeout = setTimeout;\n    } else {\n      cachedSetTimeout = defaultSetTimout;\n    }\n  } catch (e) {\n    cachedSetTimeout = defaultSetTimout;\n  }\n\n  try {\n    if (typeof clearTimeout === 'function') {\n      cachedClearTimeout = clearTimeout;\n    } else {\n      cachedClearTimeout = defaultClearTimeout;\n    }\n  } catch (e) {\n    cachedClearTimeout = defaultClearTimeout;\n  }\n})();\n\nfunction runTimeout(fun) {\n  if (cachedSetTimeout === setTimeout) {\n    //normal enviroments in sane situations\n    return setTimeout(fun, 0);\n  } // if setTimeout wasn't available but was latter defined\n\n\n  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n    cachedSetTimeout = setTimeout;\n    return setTimeout(fun, 0);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedSetTimeout(fun, 0);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n      return cachedSetTimeout.call(null, fun, 0);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n      return cachedSetTimeout.call(this, fun, 0);\n    }\n  }\n}\n\nfunction runClearTimeout(marker) {\n  if (cachedClearTimeout === clearTimeout) {\n    //normal enviroments in sane situations\n    return clearTimeout(marker);\n  } // if clearTimeout wasn't available but was latter defined\n\n\n  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n    cachedClearTimeout = clearTimeout;\n    return clearTimeout(marker);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedClearTimeout(marker);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n      return cachedClearTimeout.call(null, marker);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n      // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n      return cachedClearTimeout.call(this, marker);\n    }\n  }\n}\n\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n\n  draining = false;\n\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n\n  if (queue.length) {\n    drainQueue();\n  }\n}\n\nfunction drainQueue() {\n  if (draining) {\n    return;\n  }\n\n  var timeout = runTimeout(cleanUpNextTick);\n  draining = true;\n  var len = queue.length;\n\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n\n    while (++queueIndex < len) {\n      if (currentQueue) {\n        currentQueue[queueIndex].run();\n      }\n    }\n\n    queueIndex = -1;\n    len = queue.length;\n  }\n\n  currentQueue = null;\n  draining = false;\n  runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n  var args = new Array(arguments.length - 1);\n\n  if (arguments.length > 1) {\n    for (var i = 1; i < arguments.length; i++) {\n      args[i - 1] = arguments[i];\n    }\n  }\n\n  queue.push(new Item(fun, args));\n\n  if (queue.length === 1 && !draining) {\n    runTimeout(drainQueue);\n  }\n}; // v8 likes predictible objects\n\n\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\n\nItem.prototype.run = function () {\n  this.fun.apply(null, this.array);\n};\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\n\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) {\n  return [];\n};\n\nprocess.binding = function (name) {\n  throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () {\n  return '/';\n};\n\nprocess.chdir = function (dir) {\n  throw new Error('process.chdir is not supported');\n};\n\nprocess.umask = function () {\n  return 0;\n};","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nvar g; // This works in non-strict mode\n\ng = function () {\n  return this;\n}();\n\ntry {\n  // This works if eval is allowed (see CSP)\n  g = g || new Function(\"return this\")();\n} catch (e) {\n  // This works if the window reference is available\n  if ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\n} // g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\n\nmodule.exports = g;"],"sourceRoot":""}