From 355c690c2b294a1fe4e6f944d0ea7782a6a53b31 Mon Sep 17 00:00:00 2001 From: Lukas Taegert-Atkinson Date: Tue, 11 Jun 2019 06:36:45 +0200 Subject: [PATCH] Deoptimize try-catch less radically (#2918) * Test against polyfill regressions * Make try-statement deoptimization less aggressive by not following variables * Update docs --- docs/999-big-list-of-options.md | 38 +- package-lock.json | 18 + package.json | 3 + src/ast/nodes/CallExpression.ts | 6 +- src/ast/nodes/TryStatement.ts | 4 +- src/ast/nodes/shared/Node.ts | 4 +- src/ast/scopes/ParameterScope.ts | 13 +- src/ast/variables/LocalVariable.ts | 11 +- src/ast/variables/Variable.ts | 2 +- test/form/samples/supports-core-js/_config.js | 8 + .../samples/supports-core-js/_expected.js | 9869 +++++++++++++++++ test/form/samples/supports-core-js/main.js | 1 + .../form/samples/supports-es5-shim/_config.js | 14 + .../samples/supports-es5-shim/_expected.js | 2103 ++++ test/form/samples/supports-es5-shim/main.js | 1 + .../form/samples/supports-es6-shim/_config.js | 13 + .../samples/supports-es6-shim/_expected.js | 3890 +++++++ test/form/samples/supports-es6-shim/main.js | 1 + .../follow-parameters/_expected.js | 12 +- .../follow-parameters/main.js | 19 +- .../follow-pattern-parameters/_expected.js | 4 +- .../follow-pattern-parameters/main.js | 9 +- .../follow-variables/_config.js | 2 +- .../follow-variables/_expected.js | 9 +- .../follow-variables/main.js | 14 +- 25 files changed, 15964 insertions(+), 104 deletions(-) create mode 100644 test/form/samples/supports-core-js/_config.js create mode 100644 test/form/samples/supports-core-js/_expected.js create mode 100644 test/form/samples/supports-core-js/main.js create mode 100644 test/form/samples/supports-es5-shim/_config.js create mode 100644 test/form/samples/supports-es5-shim/_expected.js create mode 100644 test/form/samples/supports-es5-shim/main.js create mode 100644 test/form/samples/supports-es6-shim/_config.js create mode 100644 test/form/samples/supports-es6-shim/_expected.js create mode 100644 test/form/samples/supports-es6-shim/main.js diff --git a/docs/999-big-list-of-options.md b/docs/999-big-list-of-options.md index 80307972708..888e44685f2 100755 --- a/docs/999-big-list-of-options.md +++ b/docs/999-big-list-of-options.md @@ -855,25 +855,12 @@ Type: `boolean`
CLI: `--treeshake.tryCatchDeoptimization`/`--no-treeshake.tryCatchDeoptimization`
Default: `true` -By default, Rollup assumes that many builtin globals of the runtime behave according to the latest specs when tree-shaking and do not throw unexpected errors. In order to support e.g. feature detection workflows that rely on those errors being thrown, Rollup will by default deactivate tree-shaking inside try-statements. Furthermore, it will also deactivate tree-shaking inside functions that are called directly from a try-statement if Rollup can resolve the function. Set `treeshake.tryCatchDeoptimization` to `false` if you do not need this feature and want to have tree-shaking inside try-statements as well as inside functions called from those statements. +By default, Rollup assumes that many builtin globals of the runtime behave according to the latest specs when tree-shaking and do not throw unexpected errors. In order to support e.g. feature detection workflows that rely on those errors being thrown, Rollup will by default deactivate tree-shaking inside try-statements. If a function parameter is called from within a try-statement, this parameter will be deoptimized as well. Set `treeshake.tryCatchDeoptimization` to `false` if you do not need this feature and want to have tree-shaking inside try-statements. ```js -function directlyCalled1() { - // as this function is directly called from a try-statement, it will be - // retained unmodified for tryCatchDeoptimization: true including staements - // that would usually be removed - Object.create(null); - notDirectlyCalled(); -} - -function directlyCalled2() { - Object.create(null); - notDirectlyCalled(); -} - -function notDirectlyCalled() { - // even if this function is retained, this will be removed as the function is - // never directly called from a try-statement +function otherFn() { + // even though this function is called from a try-statement, the next line + // will be removed as side-effect-free Object.create(null); } @@ -883,20 +870,23 @@ function test(callback) { // inside try-statements for tryCatchDeoptimization: true Object.create(null); - // directly resolvable calls will also be deoptimized - directlyCalled1(); + // calls to other function are retained as well but the body of this + // function may again be subject to tree-shaking + otherFn(); // if a parameter is called, then all arguments passed to that function // parameter will be deoptimized callback(); - - // all calls will be retained but only calls of the form - // "identifier(someArguments)" will also deoptimize the target - (notDirectlyCalled && notDirectlyCalled)(); } catch {} } -test(directlyCalled2); +test(() => { + // will be ratained + Object.create(null) +}); + +// call will be retained but again, otherFn is not deoptimized +test(otherFn); ``` diff --git a/package-lock.json b/package-lock.json index 8527c283c18..15479f3380c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -880,6 +880,12 @@ "integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=", "dev": true }, + "core-js": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.1.3.tgz", + "integrity": "sha512-PWZ+ZfuaKf178BIAg+CRsljwjIMRV8MY00CbZczkR6Zk5LfkSkjGoaab3+bqRQWVITNZxQB7TFYz+CFcyuamvA==", + "dev": true + }, "core-util-is": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", @@ -1139,12 +1145,24 @@ "is-symbol": "^1.0.2" } }, + "es5-shim": { + "version": "4.5.13", + "resolved": "https://registry.npmjs.org/es5-shim/-/es5-shim-4.5.13.tgz", + "integrity": "sha512-xi6hh6gsvDE0MaW4Vp1lgNEBpVcCXRWfPXj5egDvtgLz4L9MEvNwYEMdJH+JJinWkwa8c3c3o5HduV7dB/e1Hw==", + "dev": true + }, "es6-object-assign": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/es6-object-assign/-/es6-object-assign-1.1.0.tgz", "integrity": "sha1-wsNYJlYkfDnqEHyx5mUrb58kUjw=", "dev": true }, + "es6-shim": { + "version": "0.35.5", + "resolved": "https://registry.npmjs.org/es6-shim/-/es6-shim-0.35.5.tgz", + "integrity": "sha512-E9kK/bjtCQRpN1K28Xh4BlmP8egvZBGJJ+9GtnzOwt7mdqtrjHFuVGr7QJfdjBIKqrlU5duPf3pCBoDrkjVYFg==", + "dev": true + }, "escape-string-regexp": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", diff --git a/package.json b/package.json index 19764e42377..840de7c702e 100644 --- a/package.json +++ b/package.json @@ -76,7 +76,10 @@ "buble": "^0.19.7", "chokidar": "^2.1.6", "console-group": "^0.3.3", + "core-js": "^3.1.3", "date-time": "^3.1.0", + "es5-shim": "^4.5.13", + "es6-shim": "^0.35.5", "eslint": "^5.16.0", "eslint-plugin-import": "^2.17.3", "execa": "^1.0.0", diff --git a/src/ast/nodes/CallExpression.ts b/src/ast/nodes/CallExpression.ts index b2b06bfb1d3..7786e29aff6 100644 --- a/src/ast/nodes/CallExpression.ts +++ b/src/ast/nodes/CallExpression.ts @@ -23,7 +23,7 @@ import { import Identifier from './Identifier'; import * as NodeType from './NodeType'; import { ExpressionEntity } from './shared/Expression'; -import { ExpressionNode, INCLUDE_VARIABLES, IncludeChildren, NodeBase } from './shared/Node'; +import { ExpressionNode, INCLUDE_PARAMETERS, IncludeChildren, NodeBase } from './shared/Node'; import SpreadElement from './SpreadElement'; export default class CallExpression extends NodeBase implements DeoptimizableEntity { @@ -204,11 +204,11 @@ export default class CallExpression extends NodeBase implements DeoptimizableEnt if (includeChildrenRecursively) { super.include(includeChildrenRecursively); if ( - includeChildrenRecursively === INCLUDE_VARIABLES && + includeChildrenRecursively === INCLUDE_PARAMETERS && this.callee instanceof Identifier && this.callee.variable ) { - this.callee.variable.includeInitRecursively(); + this.callee.variable.markCalledFromTryStatement(); } } else { this.included = true; diff --git a/src/ast/nodes/TryStatement.ts b/src/ast/nodes/TryStatement.ts index 3b0df7e1207..c71da45c81b 100644 --- a/src/ast/nodes/TryStatement.ts +++ b/src/ast/nodes/TryStatement.ts @@ -2,7 +2,7 @@ import { ExecutionPathOptions } from '../ExecutionPathOptions'; import BlockStatement from './BlockStatement'; import CatchClause from './CatchClause'; import * as NodeType from './NodeType'; -import { INCLUDE_VARIABLES, IncludeChildren, StatementBase } from './shared/Node'; +import { INCLUDE_PARAMETERS, IncludeChildren, StatementBase } from './shared/Node'; export default class TryStatement extends StatementBase { block!: BlockStatement; @@ -25,7 +25,7 @@ export default class TryStatement extends StatementBase { this.included = true; this.directlyIncluded = true; this.block.include( - this.context.tryCatchDeoptimization ? INCLUDE_VARIABLES : includeChildrenRecursively + this.context.tryCatchDeoptimization ? INCLUDE_PARAMETERS : includeChildrenRecursively ); } if (this.handler !== null) { diff --git a/src/ast/nodes/shared/Node.ts b/src/ast/nodes/shared/Node.ts index 323b3fa62c6..24409790dc2 100644 --- a/src/ast/nodes/shared/Node.ts +++ b/src/ast/nodes/shared/Node.ts @@ -20,8 +20,8 @@ export interface GenericEsTreeNode { [key: string]: any; } -export const INCLUDE_VARIABLES: 'variables' = 'variables'; -export type IncludeChildren = boolean | typeof INCLUDE_VARIABLES; +export const INCLUDE_PARAMETERS: 'variables' = 'variables'; +export type IncludeChildren = boolean | typeof INCLUDE_PARAMETERS; export interface Node extends Entity { annotations?: CommentDescription[]; diff --git a/src/ast/scopes/ParameterScope.ts b/src/ast/scopes/ParameterScope.ts index 98f15d2a02a..4e29d59f6b8 100644 --- a/src/ast/scopes/ParameterScope.ts +++ b/src/ast/scopes/ParameterScope.ts @@ -42,30 +42,27 @@ export default class ParameterScope extends ChildScope { } includeCallArguments(args: (ExpressionNode | SpreadElement)[]): void { - let hasInitBeenForceIncluded = false; + let calledFromTryStatement = false; let argIncluded = false; const restParam = this.hasRest && this.parameters[this.parameters.length - 1]; for (let index = args.length - 1; index >= 0; index--) { const paramVars = this.parameters[index] || restParam; const arg = args[index]; if (paramVars) { - hasInitBeenForceIncluded = false; + calledFromTryStatement = false; for (const variable of paramVars) { if (variable.included) { argIncluded = true; } - if (variable.hasInitBeenForceIncluded) { - hasInitBeenForceIncluded = true; + if (variable.calledFromTryStatement) { + calledFromTryStatement = true; } } } else if (!argIncluded && arg.shouldBeIncluded()) { argIncluded = true; } if (argIncluded) { - arg.include(hasInitBeenForceIncluded); - if (hasInitBeenForceIncluded && arg instanceof Identifier && arg.variable) { - arg.variable.includeInitRecursively(); - } + arg.include(calledFromTryStatement); } } } diff --git a/src/ast/variables/LocalVariable.ts b/src/ast/variables/LocalVariable.ts index b9453112fc8..24a01bdbf07 100644 --- a/src/ast/variables/LocalVariable.ts +++ b/src/ast/variables/LocalVariable.ts @@ -25,8 +25,8 @@ const MAX_PATH_DEPTH = 7; export default class LocalVariable extends Variable { additionalInitializers: ExpressionEntity[] | null = null; + calledFromTryStatement = false; declarations: (Identifier | ExportDefaultDeclaration)[]; - hasInitBeenForceIncluded = false; init: ExpressionEntity | null; module: Module; @@ -203,12 +203,7 @@ export default class LocalVariable extends Variable { } } - includeInitRecursively() { - if (!this.hasInitBeenForceIncluded) { - this.hasInitBeenForceIncluded = true; - if (this.init && this.init !== UNKNOWN_EXPRESSION) { - this.init.include(true); - } - } + markCalledFromTryStatement() { + this.calledFromTryStatement = true; } } diff --git a/src/ast/variables/Variable.ts b/src/ast/variables/Variable.ts index 08da2ae91d1..a6dc7b74695 100644 --- a/src/ast/variables/Variable.ts +++ b/src/ast/variables/Variable.ts @@ -91,7 +91,7 @@ export default class Variable implements ExpressionEntity { } } - includeInitRecursively() {} + markCalledFromTryStatement() {} setRenderNames(baseName: string | null, name: string | null) { this.renderBaseName = baseName; diff --git a/test/form/samples/supports-core-js/_config.js b/test/form/samples/supports-core-js/_config.js new file mode 100644 index 00000000000..c479ac2a0a2 --- /dev/null +++ b/test/form/samples/supports-core-js/_config.js @@ -0,0 +1,8 @@ +module.exports = { + description: 'supports core-js', + options: { + // check against tree-shake: false when updating the polyfill + treeshake: true, + plugins: [require('rollup-plugin-node-resolve')(), require('rollup-plugin-commonjs')()] + } +}; diff --git a/test/form/samples/supports-core-js/_expected.js b/test/form/samples/supports-core-js/_expected.js new file mode 100644 index 00000000000..2a7808db658 --- /dev/null +++ b/test/form/samples/supports-core-js/_expected.js @@ -0,0 +1,9869 @@ +var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +function createCommonjsModule(fn, module) { + return module = { exports: {} }, fn(module, module.exports), module.exports; +} + +var O = 'object'; +var check = function (it) { + return it && it.Math == Math && it; +}; + +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +var global_1 = + // eslint-disable-next-line no-undef + check(typeof globalThis == O && globalThis) || + check(typeof window == O && window) || + check(typeof self == O && self) || + check(typeof commonjsGlobal == O && commonjsGlobal) || + // eslint-disable-next-line no-new-func + Function('return this')(); + +var fails = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } +}; + +// Thank's IE8 for his funny defineProperty +var descriptors = !fails(function () { + return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7; +}); + +var nativePropertyIsEnumerable = {}.propertyIsEnumerable; +var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// Nashorn ~ JDK8 bug +var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1); + +var f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor(this, V); + return !!descriptor && descriptor.enumerable; +} : nativePropertyIsEnumerable; + +var objectPropertyIsEnumerable = { + f: f +}; + +var createPropertyDescriptor = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + +var toString = {}.toString; + +var classofRaw = function (it) { + return toString.call(it).slice(8, -1); +}; + +// fallback for non-array-like ES3 and non-enumerable old V8 strings + + + +var split = ''.split; + +var indexedObject = fails(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins + return !Object('z').propertyIsEnumerable(0); +}) ? function (it) { + return classofRaw(it) == 'String' ? split.call(it, '') : Object(it); +} : Object; + +// `RequireObjectCoercible` abstract operation +// https://tc39.github.io/ecma262/#sec-requireobjectcoercible +var requireObjectCoercible = function (it) { + if (it == undefined) throw TypeError("Can't call method on " + it); + return it; +}; + +// toObject with fallback for non-array-like ES3 strings + + + +var toIndexedObject = function (it) { + return indexedObject(requireObjectCoercible(it)); +}; + +var isObject = function (it) { + return typeof it === 'object' ? it !== null : typeof it === 'function'; +}; + +// 7.1.1 ToPrimitive(input [, PreferredType]) +// instead of the ES6 spec version, we didn't implement @@toPrimitive case +// and the second argument - flag - preferred type is a string +var toPrimitive = function (it, S) { + if (!isObject(it)) return it; + var fn, val; + if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; + if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val; + if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; + throw TypeError("Can't convert object to primitive value"); +}; + +var hasOwnProperty = {}.hasOwnProperty; + +var has = function (it, key) { + return hasOwnProperty.call(it, key); +}; + +var document$1 = global_1.document; +// typeof document.createElement is 'object' in old IE +var exist = isObject(document$1) && isObject(document$1.createElement); + +var documentCreateElement = function (it) { + return exist ? document$1.createElement(it) : {}; +}; + +// Thank's IE8 for his funny defineProperty +var ie8DomDefine = !descriptors && !fails(function () { + return Object.defineProperty(documentCreateElement('div'), 'a', { + get: function () { return 7; } + }).a != 7; +}); + +var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +var f$1 = descriptors ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject(O); + P = toPrimitive(P, true); + if (ie8DomDefine) try { + return nativeGetOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (has(O, P)) return createPropertyDescriptor(!objectPropertyIsEnumerable.f.call(O, P), O[P]); +}; + +var objectGetOwnPropertyDescriptor = { + f: f$1 +}; + +var anObject = function (it) { + if (!isObject(it)) { + throw TypeError(String(it) + ' is not an object'); + } return it; +}; + +var nativeDefineProperty = Object.defineProperty; + +var f$2 = descriptors ? nativeDefineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if (ie8DomDefine) try { + return nativeDefineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + +var objectDefineProperty = { + f: f$2 +}; + +var hide = descriptors ? function (object, key, value) { + return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + +var setGlobal = function (key, value) { + try { + hide(global_1, key, value); + } catch (error) { + global_1[key] = value; + } return value; +}; + +var isPure = false; + +var shared = createCommonjsModule(function (module) { +var SHARED = '__core-js_shared__'; +var store = global_1[SHARED] || setGlobal(SHARED, {}); + +(module.exports = function (key, value) { + return store[key] || (store[key] = value !== undefined ? value : {}); +})('versions', []).push({ + version: '3.1.3', + mode: 'global', + copyright: '© 2019 Denis Pushkarev (zloirock.ru)' +}); +}); + +var functionToString = shared('native-function-to-string', Function.toString); + +var WeakMap = global_1.WeakMap; + +var nativeWeakMap = typeof WeakMap === 'function' && /native code/.test(functionToString.call(WeakMap)); + +var id = 0; +var postfix = Math.random(); + +var uid = function (key) { + return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + postfix).toString(36)); +}; + +var keys = shared('keys'); + +var sharedKey = function (key) { + return keys[key] || (keys[key] = uid(key)); +}; + +var hiddenKeys = {}; + +var WeakMap$1 = global_1.WeakMap; +var set, get, has$1; + +var enforce = function (it) { + return has$1(it) ? get(it) : set(it, {}); +}; + +var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject(it) || (state = get(it)).type !== TYPE) { + throw TypeError('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; +}; + +if (nativeWeakMap) { + var store = new WeakMap$1(); + var wmget = store.get; + var wmhas = store.has; + var wmset = store.set; + set = function (it, metadata) { + wmset.call(store, it, metadata); + return metadata; + }; + get = function (it) { + return wmget.call(store, it) || {}; + }; + has$1 = function (it) { + return wmhas.call(store, it); + }; +} else { + var STATE = sharedKey('state'); + hiddenKeys[STATE] = true; + set = function (it, metadata) { + hide(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return has(it, STATE) ? it[STATE] : {}; + }; + has$1 = function (it) { + return has(it, STATE); + }; +} + +var internalState = { + set: set, + get: get, + has: has$1, + enforce: enforce, + getterFor: getterFor +}; + +var redefine = createCommonjsModule(function (module) { +var getInternalState = internalState.get; +var enforceInternalState = internalState.enforce; +var TEMPLATE = String(functionToString).split('toString'); + +shared('inspectSource', function (it) { + return functionToString.call(it); +}); + +(module.exports = function (O, key, value, options) { + var unsafe = options ? !!options.unsafe : false; + var simple = options ? !!options.enumerable : false; + var noTargetGet = options ? !!options.noTargetGet : false; + if (typeof value == 'function') { + if (typeof key == 'string' && !has(value, 'name')) hide(value, 'name', key); + enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : ''); + } + if (O === global_1) { + if (simple) O[key] = value; + else setGlobal(key, value); + return; + } else if (!unsafe) { + delete O[key]; + } else if (!noTargetGet && O[key]) { + simple = true; + } + if (simple) O[key] = value; + else hide(O, key, value); +// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative +})(Function.prototype, 'toString', function toString() { + return typeof this == 'function' && getInternalState(this).source || functionToString.call(this); +}); +}); + +var ceil = Math.ceil; +var floor = Math.floor; + +// `ToInteger` abstract operation +// https://tc39.github.io/ecma262/#sec-tointeger +var toInteger = function (argument) { + return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument); +}; + +var min = Math.min; + +// `ToLength` abstract operation +// https://tc39.github.io/ecma262/#sec-tolength +var toLength = function (argument) { + return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 +}; + +var max = Math.max; +var min$1 = Math.min; + +// Helper for a popular repeating case of the spec: +// Let integer be ? ToInteger(index). +// If integer < 0, let result be max((length + integer), 0); else let result be min(length, length). +var toAbsoluteIndex = function (index, length) { + var integer = toInteger(index); + return integer < 0 ? max(integer + length, 0) : min$1(integer, length); +}; + +// `Array.prototype.{ indexOf, includes }` methods implementation +// false -> Array#indexOf +// https://tc39.github.io/ecma262/#sec-array.prototype.indexof +// true -> Array#includes +// https://tc39.github.io/ecma262/#sec-array.prototype.includes +var arrayIncludes = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject($this); + var length = toLength(O.length); + var index = toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare + if (IS_INCLUDES && el != el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare + if (value != value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) if (IS_INCLUDES || index in O) { + if (O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +var arrayIndexOf = arrayIncludes(false); + +var objectKeysInternal = function (object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key; + for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key); + // Don't enum bug & hidden keys + while (names.length > i) if (has(O, key = names[i++])) { + ~arrayIndexOf(result, key) || result.push(key); + } + return result; +}; + +// IE8- don't enum bug keys +var enumBugKeys = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + +// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O) + + + +var hiddenKeys$1 = enumBugKeys.concat('length', 'prototype'); + +var f$3 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return objectKeysInternal(O, hiddenKeys$1); +}; + +var objectGetOwnPropertyNames = { + f: f$3 +}; + +var f$4 = Object.getOwnPropertySymbols; + +var objectGetOwnPropertySymbols = { + f: f$4 +}; + +var Reflect$1 = global_1.Reflect; + +// all object keys, includes non-enumerable and symbols +var ownKeys = Reflect$1 && Reflect$1.ownKeys || function ownKeys(it) { + var keys = objectGetOwnPropertyNames.f(anObject(it)); + var getOwnPropertySymbols = objectGetOwnPropertySymbols.f; + return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; +}; + +var copyConstructorProperties = function (target, source) { + var keys = ownKeys(source); + var defineProperty = objectDefineProperty.f; + var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } +}; + +var replacement = /#|\.prototype\./; + +var isForced = function (feature, detection) { + var value = data[normalize(feature)]; + return value == POLYFILL ? true + : value == NATIVE ? false + : typeof detection == 'function' ? fails(detection) + : !!detection; +}; + +var normalize = isForced.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; + +var data = isForced.data = {}; +var NATIVE = isForced.NATIVE = 'N'; +var POLYFILL = isForced.POLYFILL = 'P'; + +var isForced_1 = isForced; + +var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; + + + + + + +/* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.noTargetGet - prevent calling a getter on target +*/ +var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global_1; + } else if (STATIC) { + target = global_1[TARGET] || setGlobal(TARGET, {}); + } else { + target = (global_1[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.noTargetGet) { + descriptor = getOwnPropertyDescriptor$1(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty === typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + hide(sourceProperty, 'sham', true); + } + // extend global + redefine(target, key, sourceProperty, options); + } +}; + +var nativeSymbol = !!Object.getOwnPropertySymbols && !fails(function () { + // Chrome 38 Symbol has incorrect toString conversion + // eslint-disable-next-line no-undef + return !String(Symbol()); +}); + +var Symbol$1 = global_1.Symbol; +var store$1 = shared('wks'); + +var wellKnownSymbol = function (name) { + return store$1[name] || (store$1[name] = nativeSymbol && Symbol$1[name] + || (nativeSymbol ? Symbol$1 : uid)('Symbol.' + name)); +}; + +var defineProperty = objectDefineProperty.f; + + + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); + +var setToStringTag = function (it, TAG, STATIC) { + if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) { + defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG }); + } +}; + +var f$5 = wellKnownSymbol; + +var wrappedWellKnownSymbol = { + f: f$5 +}; + +var path = global_1; + +var defineProperty$1 = objectDefineProperty.f; + +var defineWellKnownSymbol = function (NAME) { + var Symbol = path.Symbol || (path.Symbol = {}); + if (!has(Symbol, NAME)) defineProperty$1(Symbol, NAME, { + value: wrappedWellKnownSymbol.f(NAME) + }); +}; + +// 19.1.2.14 / 15.2.3.14 Object.keys(O) +var objectKeys = Object.keys || function keys(O) { + return objectKeysInternal(O, enumBugKeys); +}; + +// all enumerable object keys, includes symbols +var enumKeys = function (it) { + var result = objectKeys(it); + var getOwnPropertySymbols = objectGetOwnPropertySymbols.f; + if (getOwnPropertySymbols) { + var symbols = getOwnPropertySymbols(it); + var propertyIsEnumerable = objectPropertyIsEnumerable.f; + var i = 0; + var key; + while (symbols.length > i) if (propertyIsEnumerable.call(it, key = symbols[i++])) result.push(key); + } return result; +}; + +// `IsArray` abstract operation +// https://tc39.github.io/ecma262/#sec-isarray +var isArray = Array.isArray || function isArray(arg) { + return classofRaw(arg) == 'Array'; +}; + +// `ToObject` abstract operation +// https://tc39.github.io/ecma262/#sec-toobject +var toObject = function (argument) { + return Object(requireObjectCoercible(argument)); +}; + +var objectDefineProperties = descriptors ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var keys = objectKeys(Properties); + var length = keys.length; + var i = 0; + var key; + while (length > i) objectDefineProperty.f(O, key = keys[i++], Properties[key]); + return O; +}; + +var document$2 = global_1.document; + +var html = document$2 && document$2.documentElement; + +var IE_PROTO = sharedKey('IE_PROTO'); + +var PROTOTYPE = 'prototype'; +var Empty = function () { /* empty */ }; + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var createDict = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement('iframe'); + var length = enumBugKeys.length; + var lt = '<'; + var script = 'script'; + var gt = '>'; + var js = 'java' + script + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + iframe.src = String(js); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(lt + script + gt + 'document.F=Object' + lt + '/' + script + gt); + iframeDocument.close(); + createDict = iframeDocument.F; + while (length--) delete createDict[PROTOTYPE][enumBugKeys[length]]; + return createDict(); +}; + +// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) +var objectCreate = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + Empty[PROTOTYPE] = anObject(O); + result = new Empty(); + Empty[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO] = O; + } else result = createDict(); + return Properties === undefined ? result : objectDefineProperties(result, Properties); +}; + +hiddenKeys[IE_PROTO] = true; + +var nativeGetOwnPropertyNames = objectGetOwnPropertyNames.f; + +var toString$1 = {}.toString; + +var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +var getWindowNames = function (it) { + try { + return nativeGetOwnPropertyNames(it); + } catch (error) { + return windowNames.slice(); + } +}; + +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +var f$6 = function getOwnPropertyNames(it) { + return windowNames && toString$1.call(it) == '[object Window]' + ? getWindowNames(it) + : nativeGetOwnPropertyNames(toIndexedObject(it)); +}; + +var objectGetOwnPropertyNamesExternal = { + f: f$6 +}; + +var HIDDEN = sharedKey('hidden'); +var SYMBOL = 'Symbol'; +var setInternalState = internalState.set; +var getInternalState = internalState.getterFor(SYMBOL); +var nativeGetOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; +var nativeDefineProperty$1 = objectDefineProperty.f; +var nativeGetOwnPropertyNames$1 = objectGetOwnPropertyNamesExternal.f; +var $Symbol = global_1.Symbol; +var JSON = global_1.JSON; +var nativeJSONStringify = JSON && JSON.stringify; +var PROTOTYPE$1 = 'prototype'; +var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); +var nativePropertyIsEnumerable$1 = objectPropertyIsEnumerable.f; +var SymbolRegistry = shared('symbol-registry'); +var AllSymbols = shared('symbols'); +var ObjectPrototypeSymbols = shared('op-symbols'); +var WellKnownSymbolsStore = shared('wks'); +var ObjectPrototype = Object[PROTOTYPE$1]; +var QObject = global_1.QObject; +// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 +var USE_SETTER = !QObject || !QObject[PROTOTYPE$1] || !QObject[PROTOTYPE$1].findChild; + +// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 +var setSymbolDescriptor = descriptors && fails(function () { + return objectCreate(nativeDefineProperty$1({}, 'a', { + get: function () { return nativeDefineProperty$1(this, 'a', { value: 7 }).a; } + })).a != 7; +}) ? function (it, key, D) { + var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor$1(ObjectPrototype, key); + if (ObjectPrototypeDescriptor) delete ObjectPrototype[key]; + nativeDefineProperty$1(it, key, D); + if (ObjectPrototypeDescriptor && it !== ObjectPrototype) { + nativeDefineProperty$1(ObjectPrototype, key, ObjectPrototypeDescriptor); + } +} : nativeDefineProperty$1; + +var wrap = function (tag, description) { + var symbol = AllSymbols[tag] = objectCreate($Symbol[PROTOTYPE$1]); + setInternalState(symbol, { + type: SYMBOL, + tag: tag, + description: description + }); + if (!descriptors) symbol.description = description; + return symbol; +}; + +var isSymbol = nativeSymbol && typeof $Symbol.iterator == 'symbol' ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + return Object(it) instanceof $Symbol; +}; + +var $defineProperty = function defineProperty(it, key, D) { + if (it === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, key, D); + anObject(it); + key = toPrimitive(key, true); + anObject(D); + if (has(AllSymbols, key)) { + if (!D.enumerable) { + if (!has(it, HIDDEN)) nativeDefineProperty$1(it, HIDDEN, createPropertyDescriptor(1, {})); + it[HIDDEN][key] = true; + } else { + if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false; + D = objectCreate(D, { enumerable: createPropertyDescriptor(0, false) }); + } return setSymbolDescriptor(it, key, D); + } return nativeDefineProperty$1(it, key, D); +}; + +var $defineProperties = function defineProperties(it, P) { + anObject(it); + var keys = enumKeys(P = toIndexedObject(P)); + var i = 0; + var l = keys.length; + var key; + while (l > i) $defineProperty(it, key = keys[i++], P[key]); + return it; +}; + +var $create = function create(it, P) { + return P === undefined ? objectCreate(it) : $defineProperties(objectCreate(it), P); +}; + +var $propertyIsEnumerable = function propertyIsEnumerable(key) { + var E = nativePropertyIsEnumerable$1.call(this, key = toPrimitive(key, true)); + if (this === ObjectPrototype && has(AllSymbols, key) && !has(ObjectPrototypeSymbols, key)) return false; + return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true; +}; + +var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) { + it = toIndexedObject(it); + key = toPrimitive(key, true); + if (it === ObjectPrototype && has(AllSymbols, key) && !has(ObjectPrototypeSymbols, key)) return; + var D = nativeGetOwnPropertyDescriptor$1(it, key); + if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true; + return D; +}; + +var $getOwnPropertyNames = function getOwnPropertyNames(it) { + var names = nativeGetOwnPropertyNames$1(toIndexedObject(it)); + var result = []; + var i = 0; + var key; + while (names.length > i) { + if (!has(AllSymbols, key = names[i++]) && !has(hiddenKeys, key)) result.push(key); + } return result; +}; + +var $getOwnPropertySymbols = function getOwnPropertySymbols(it) { + var IS_OP = it === ObjectPrototype; + var names = nativeGetOwnPropertyNames$1(IS_OP ? ObjectPrototypeSymbols : toIndexedObject(it)); + var result = []; + var i = 0; + var key; + while (names.length > i) { + if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectPrototype, key) : true)) result.push(AllSymbols[key]); + } return result; +}; + +// `Symbol` constructor +// https://tc39.github.io/ecma262/#sec-symbol-constructor +if (!nativeSymbol) { + $Symbol = function Symbol() { + if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor'); + var description = arguments[0] === undefined ? undefined : String(arguments[0]); + var tag = uid(description); + var setter = function (value) { + if (this === ObjectPrototype) setter.call(ObjectPrototypeSymbols, value); + if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false; + setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value)); + }; + if (descriptors && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter }); + return wrap(tag, description); + }; + redefine($Symbol[PROTOTYPE$1], 'toString', function toString() { + return getInternalState(this).tag; + }); + + objectPropertyIsEnumerable.f = $propertyIsEnumerable; + objectDefineProperty.f = $defineProperty; + objectGetOwnPropertyDescriptor.f = $getOwnPropertyDescriptor; + objectGetOwnPropertyNames.f = objectGetOwnPropertyNamesExternal.f = $getOwnPropertyNames; + objectGetOwnPropertySymbols.f = $getOwnPropertySymbols; + + if (descriptors) { + // https://github.com/tc39/proposal-Symbol-description + nativeDefineProperty$1($Symbol[PROTOTYPE$1], 'description', { + configurable: true, + get: function description() { + return getInternalState(this).description; + } + }); + { + redefine(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true }); + } + } + + wrappedWellKnownSymbol.f = function (name) { + return wrap(wellKnownSymbol(name), name); + }; +} + +_export({ global: true, wrap: true, forced: !nativeSymbol, sham: !nativeSymbol }, { + Symbol: $Symbol +}); + +for (var wellKnownSymbols = objectKeys(WellKnownSymbolsStore), k = 0; wellKnownSymbols.length > k;) { + defineWellKnownSymbol(wellKnownSymbols[k++]); +} + +_export({ target: SYMBOL, stat: true, forced: !nativeSymbol }, { + // `Symbol.for` method + // https://tc39.github.io/ecma262/#sec-symbol.for + 'for': function (key) { + return has(SymbolRegistry, key += '') + ? SymbolRegistry[key] + : SymbolRegistry[key] = $Symbol(key); + }, + // `Symbol.keyFor` method + // https://tc39.github.io/ecma262/#sec-symbol.keyfor + keyFor: function keyFor(sym) { + if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol'); + for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key; + }, + useSetter: function () { USE_SETTER = true; }, + useSimple: function () { USE_SETTER = false; } +}); + +_export({ target: 'Object', stat: true, forced: !nativeSymbol, sham: !descriptors }, { + // `Object.create` method + // https://tc39.github.io/ecma262/#sec-object.create + create: $create, + // `Object.defineProperty` method + // https://tc39.github.io/ecma262/#sec-object.defineproperty + defineProperty: $defineProperty, + // `Object.defineProperties` method + // https://tc39.github.io/ecma262/#sec-object.defineproperties + defineProperties: $defineProperties, + // `Object.getOwnPropertyDescriptor` method + // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptors + getOwnPropertyDescriptor: $getOwnPropertyDescriptor +}); + +_export({ target: 'Object', stat: true, forced: !nativeSymbol }, { + // `Object.getOwnPropertyNames` method + // https://tc39.github.io/ecma262/#sec-object.getownpropertynames + getOwnPropertyNames: $getOwnPropertyNames, + // `Object.getOwnPropertySymbols` method + // https://tc39.github.io/ecma262/#sec-object.getownpropertysymbols + getOwnPropertySymbols: $getOwnPropertySymbols +}); + +// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives +// https://bugs.chromium.org/p/v8/issues/detail?id=3443 +_export({ target: 'Object', stat: true, forced: fails(function () { objectGetOwnPropertySymbols.f(1); }) }, { + getOwnPropertySymbols: function getOwnPropertySymbols(it) { + return objectGetOwnPropertySymbols.f(toObject(it)); + } +}); + +// `JSON.stringify` method behavior with symbols +// https://tc39.github.io/ecma262/#sec-json.stringify +JSON && _export({ target: 'JSON', stat: true, forced: !nativeSymbol || fails(function () { + var symbol = $Symbol(); + // MS Edge converts symbol values to JSON as {} + return nativeJSONStringify([symbol]) != '[null]' + // WebKit converts symbol values to JSON as null + || nativeJSONStringify({ a: symbol }) != '{}' + // V8 throws on boxed symbols + || nativeJSONStringify(Object(symbol)) != '{}'; +}) }, { + stringify: function stringify(it) { + var args = [it]; + var i = 1; + var replacer, $replacer; + while (arguments.length > i) args.push(arguments[i++]); + $replacer = replacer = args[1]; + if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined + if (!isArray(replacer)) replacer = function (key, value) { + if (typeof $replacer == 'function') value = $replacer.call(this, key, value); + if (!isSymbol(value)) return value; + }; + args[1] = replacer; + return nativeJSONStringify.apply(JSON, args); + } +}); + +// `Symbol.prototype[@@toPrimitive]` method +// https://tc39.github.io/ecma262/#sec-symbol.prototype-@@toprimitive +if (!$Symbol[PROTOTYPE$1][TO_PRIMITIVE]) hide($Symbol[PROTOTYPE$1], TO_PRIMITIVE, $Symbol[PROTOTYPE$1].valueOf); +// `Symbol.prototype[@@toStringTag]` property +// https://tc39.github.io/ecma262/#sec-symbol.prototype-@@tostringtag +setToStringTag($Symbol, SYMBOL); + +hiddenKeys[HIDDEN] = true; + +// `Symbol.asyncIterator` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.asynciterator +defineWellKnownSymbol('asyncIterator'); + +var defineProperty$2 = objectDefineProperty.f; + + +var NativeSymbol = global_1.Symbol; + +if (descriptors && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) || + // Safari 12 bug + NativeSymbol().description !== undefined +)) { + var EmptyStringDescriptionStore = {}; + // wrap Symbol constructor for correct work with undefined description + var SymbolWrapper = function Symbol() { + var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]); + var result = this instanceof SymbolWrapper + ? new NativeSymbol(description) + // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)' + : description === undefined ? NativeSymbol() : NativeSymbol(description); + if (description === '') EmptyStringDescriptionStore[result] = true; + return result; + }; + copyConstructorProperties(SymbolWrapper, NativeSymbol); + var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype; + symbolPrototype.constructor = SymbolWrapper; + + var symbolToString = symbolPrototype.toString; + var native = String(NativeSymbol('test')) == 'Symbol(test)'; + var regexp = /^Symbol\((.*)\)[^)]+$/; + defineProperty$2(symbolPrototype, 'description', { + configurable: true, + get: function description() { + var symbol = isObject(this) ? this.valueOf() : this; + var string = symbolToString.call(symbol); + if (has(EmptyStringDescriptionStore, symbol)) return ''; + var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1'); + return desc === '' ? undefined : desc; + } + }); + + _export({ global: true, forced: true }, { + Symbol: SymbolWrapper + }); +} + +// `Symbol.hasInstance` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.hasinstance +defineWellKnownSymbol('hasInstance'); + +// `Symbol.isConcatSpreadable` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.isconcatspreadable +defineWellKnownSymbol('isConcatSpreadable'); + +// `Symbol.iterator` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.iterator +defineWellKnownSymbol('iterator'); + +// `Symbol.match` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.match +defineWellKnownSymbol('match'); + +// `Symbol.matchAll` well-known symbol +defineWellKnownSymbol('matchAll'); + +// `Symbol.replace` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.replace +defineWellKnownSymbol('replace'); + +// `Symbol.search` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.search +defineWellKnownSymbol('search'); + +// `Symbol.species` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.species +defineWellKnownSymbol('species'); + +// `Symbol.split` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.split +defineWellKnownSymbol('split'); + +// `Symbol.toPrimitive` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.toprimitive +defineWellKnownSymbol('toPrimitive'); + +// `Symbol.toStringTag` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.tostringtag +defineWellKnownSymbol('toStringTag'); + +// `Symbol.unscopables` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.unscopables +defineWellKnownSymbol('unscopables'); + +var nativeAssign = Object.assign; + +// 19.1.2.1 Object.assign(target, source, ...) +// should work with symbols and should have deterministic property order (V8 bug) +var objectAssign = !nativeAssign || fails(function () { + var A = {}; + var B = {}; + // eslint-disable-next-line no-undef + var symbol = Symbol(); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet; +}) ? function assign(target, source) { // eslint-disable-line no-unused-vars + var T = toObject(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = objectGetOwnPropertySymbols.f; + var propertyIsEnumerable = objectPropertyIsEnumerable.f; + while (argumentsLength > index) { + var S = indexedObject(arguments[index++]); + var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!descriptors || propertyIsEnumerable.call(S, key)) T[key] = S[key]; + } + } return T; +} : nativeAssign; + +// `Object.assign` method +// https://tc39.github.io/ecma262/#sec-object.assign +_export({ target: 'Object', stat: true, forced: Object.assign !== objectAssign }, { + assign: objectAssign +}); + +// `Object.create` method +// https://tc39.github.io/ecma262/#sec-object.create +_export({ target: 'Object', stat: true, sham: !descriptors }, { + create: objectCreate +}); + +// `Object.defineProperty` method +// https://tc39.github.io/ecma262/#sec-object.defineproperty +_export({ target: 'Object', stat: true, forced: !descriptors, sham: !descriptors }, { + defineProperty: objectDefineProperty.f +}); + +// `Object.defineProperties` method +// https://tc39.github.io/ecma262/#sec-object.defineproperties +_export({ target: 'Object', stat: true, forced: !descriptors, sham: !descriptors }, { + defineProperties: objectDefineProperties +}); + +var propertyIsEnumerable = objectPropertyIsEnumerable.f; + +// TO_ENTRIES: true -> Object.entries +// TO_ENTRIES: false -> Object.values +var objectToArray = function (it, TO_ENTRIES) { + var O = toIndexedObject(it); + var keys = objectKeys(O); + var length = keys.length; + var i = 0; + var result = []; + var key; + while (length > i) { + key = keys[i++]; + if (!descriptors || propertyIsEnumerable.call(O, key)) { + result.push(TO_ENTRIES ? [key, O[key]] : O[key]); + } + } + return result; +}; + +// `Object.entries` method +// https://tc39.github.io/ecma262/#sec-object.entries +_export({ target: 'Object', stat: true }, { + entries: function entries(O) { + return objectToArray(O, true); + } +}); + +var freezing = !fails(function () { + return Object.isExtensible(Object.preventExtensions({})); +}); + +var internalMetadata = createCommonjsModule(function (module) { +var defineProperty = objectDefineProperty.f; + + + +var METADATA = uid('meta'); +var id = 0; + +var isExtensible = Object.isExtensible || function () { + return true; +}; + +var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + ++id, // object ID + weakData: {} // weak collections IDs + } }); +}; + +var fastKey = function (it, create) { + // return a primitive with prefix + if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!has(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; +}; + +var getWeakData = function (it, create) { + if (!has(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; +}; + +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (freezing && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it); + return it; +}; + +var meta = module.exports = { + REQUIRED: false, + fastKey: fastKey, + getWeakData: getWeakData, + onFreeze: onFreeze +}; + +hiddenKeys[METADATA] = true; +}); +var internalMetadata_1 = internalMetadata.REQUIRED; +var internalMetadata_2 = internalMetadata.fastKey; +var internalMetadata_3 = internalMetadata.getWeakData; +var internalMetadata_4 = internalMetadata.onFreeze; + +var onFreeze = internalMetadata.onFreeze; + +var nativeFreeze = Object.freeze; +var FAILS_ON_PRIMITIVES = fails(function () { nativeFreeze(1); }); + +// `Object.freeze` method +// https://tc39.github.io/ecma262/#sec-object.freeze +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !freezing }, { + freeze: function freeze(it) { + return nativeFreeze && isObject(it) ? nativeFreeze(onFreeze(it)) : it; + } +}); + +var iterators = {}; + +var ITERATOR = wellKnownSymbol('iterator'); +var ArrayPrototype = Array.prototype; + +// check on default Array iterator +var isArrayIteratorMethod = function (it) { + return it !== undefined && (iterators.Array === it || ArrayPrototype[ITERATOR] === it); +}; + +var aFunction = function (it) { + if (typeof it != 'function') { + throw TypeError(String(it) + ' is not a function'); + } return it; +}; + +// optional / simple context binding +var bindContext = function (fn, that, length) { + aFunction(fn); + if (that === undefined) return fn; + switch (length) { + case 0: return function () { + return fn.call(that); + }; + case 1: return function (a) { + return fn.call(that, a); + }; + case 2: return function (a, b) { + return fn.call(that, a, b); + }; + case 3: return function (a, b, c) { + return fn.call(that, a, b, c); + }; + } + return function (/* ...args */) { + return fn.apply(that, arguments); + }; +}; + +var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag'); +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +var classof = function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw(O) + // ES3 arguments fallback + : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result; +}; + +var ITERATOR$1 = wellKnownSymbol('iterator'); + +var getIteratorMethod = function (it) { + if (it != undefined) return it[ITERATOR$1] + || it['@@iterator'] + || iterators[classof(it)]; +}; + +// call something on iterator step with safe closing on error +var callWithSafeIterationClosing = function (iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value); + // 7.4.6 IteratorClose(iterator, completion) + } catch (error) { + var returnMethod = iterator['return']; + if (returnMethod !== undefined) anObject(returnMethod.call(iterator)); + throw error; + } +}; + +var iterate = createCommonjsModule(function (module) { +var BREAK = {}; + +var exports = module.exports = function (iterable, fn, that, ENTRIES, ITERATOR) { + var boundFunction = bindContext(fn, that, ENTRIES ? 2 : 1); + var iterator, iterFn, index, length, result, step; + + if (ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (typeof iterFn != 'function') throw TypeError('Target is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = toLength(iterable.length); length > index; index++) { + result = ENTRIES ? boundFunction(anObject(step = iterable[index])[0], step[1]) : boundFunction(iterable[index]); + if (result === BREAK) return BREAK; + } return; + } + iterator = iterFn.call(iterable); + } + + while (!(step = iterator.next()).done) { + if (callWithSafeIterationClosing(iterator, boundFunction, step.value, ENTRIES) === BREAK) return BREAK; + } +}; + +exports.BREAK = BREAK; +}); + +var createProperty = function (object, key, value) { + var propertyKey = toPrimitive(key); + if (propertyKey in object) objectDefineProperty.f(object, propertyKey, createPropertyDescriptor(0, value)); + else object[propertyKey] = value; +}; + +// `Object.fromEntries` method +// https://github.com/tc39/proposal-object-from-entries +_export({ target: 'Object', stat: true }, { + fromEntries: function fromEntries(iterable) { + var obj = {}; + iterate(iterable, function (k, v) { + createProperty(obj, k, v); + }, undefined, true); + return obj; + } +}); + +var nativeGetOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f; + + +var FAILS_ON_PRIMITIVES$1 = fails(function () { nativeGetOwnPropertyDescriptor$2(1); }); +var FORCED = !descriptors || FAILS_ON_PRIMITIVES$1; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor +_export({ target: 'Object', stat: true, forced: FORCED, sham: !descriptors }, { + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(it, key) { + return nativeGetOwnPropertyDescriptor$2(toIndexedObject(it), key); + } +}); + +// `Object.getOwnPropertyDescriptors` method +// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptors +_export({ target: 'Object', stat: true, sham: !descriptors }, { + getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) { + var O = toIndexedObject(object); + var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + var keys = ownKeys(O); + var result = {}; + var i = 0; + var key, descriptor; + while (keys.length > i) { + descriptor = getOwnPropertyDescriptor(O, key = keys[i++]); + if (descriptor !== undefined) createProperty(result, key, descriptor); + } + return result; + } +}); + +var nativeGetOwnPropertyNames$2 = objectGetOwnPropertyNamesExternal.f; + +var FAILS_ON_PRIMITIVES$2 = fails(function () { return !Object.getOwnPropertyNames(1); }); + +// `Object.getOwnPropertyNames` method +// https://tc39.github.io/ecma262/#sec-object.getownpropertynames +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$2 }, { + getOwnPropertyNames: nativeGetOwnPropertyNames$2 +}); + +var correctPrototypeGetter = !fails(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + return Object.getPrototypeOf(new F()) !== F.prototype; +}); + +var IE_PROTO$1 = sharedKey('IE_PROTO'); +var ObjectPrototype$1 = Object.prototype; + +// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O) +var objectGetPrototypeOf = correctPrototypeGetter ? Object.getPrototypeOf : function (O) { + O = toObject(O); + if (has(O, IE_PROTO$1)) return O[IE_PROTO$1]; + if (typeof O.constructor == 'function' && O instanceof O.constructor) { + return O.constructor.prototype; + } return O instanceof Object ? ObjectPrototype$1 : null; +}; + +var FAILS_ON_PRIMITIVES$3 = fails(function () { objectGetPrototypeOf(1); }); + +// `Object.getPrototypeOf` method +// https://tc39.github.io/ecma262/#sec-object.getprototypeof +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$3, sham: !correctPrototypeGetter }, { + getPrototypeOf: function getPrototypeOf(it) { + return objectGetPrototypeOf(toObject(it)); + } +}); + +// `SameValue` abstract operation +// https://tc39.github.io/ecma262/#sec-samevalue +var sameValue = Object.is || function is(x, y) { + // eslint-disable-next-line no-self-compare + return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y; +}; + +// `Object.is` method +// https://tc39.github.io/ecma262/#sec-object.is +_export({ target: 'Object', stat: true }, { + is: sameValue +}); + +var nativeIsExtensible = Object.isExtensible; +var FAILS_ON_PRIMITIVES$4 = fails(function () { nativeIsExtensible(1); }); + +// `Object.isExtensible` method +// https://tc39.github.io/ecma262/#sec-object.isextensible +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$4 }, { + isExtensible: function isExtensible(it) { + return isObject(it) ? nativeIsExtensible ? nativeIsExtensible(it) : true : false; + } +}); + +var nativeIsFrozen = Object.isFrozen; +var FAILS_ON_PRIMITIVES$5 = fails(function () { nativeIsFrozen(1); }); + +// `Object.isFrozen` method +// https://tc39.github.io/ecma262/#sec-object.isfrozen +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$5 }, { + isFrozen: function isFrozen(it) { + return isObject(it) ? nativeIsFrozen ? nativeIsFrozen(it) : false : true; + } +}); + +var nativeIsSealed = Object.isSealed; +var FAILS_ON_PRIMITIVES$6 = fails(function () { nativeIsSealed(1); }); + +// `Object.isSealed` method +// https://tc39.github.io/ecma262/#sec-object.issealed +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$6 }, { + isSealed: function isSealed(it) { + return isObject(it) ? nativeIsSealed ? nativeIsSealed(it) : false : true; + } +}); + +var FAILS_ON_PRIMITIVES$7 = fails(function () { objectKeys(1); }); + +// `Object.keys` method +// https://tc39.github.io/ecma262/#sec-object.keys +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$7 }, { + keys: function keys(it) { + return objectKeys(toObject(it)); + } +}); + +var onFreeze$1 = internalMetadata.onFreeze; + + + +var nativePreventExtensions = Object.preventExtensions; +var FAILS_ON_PRIMITIVES$8 = fails(function () { nativePreventExtensions(1); }); + +// `Object.preventExtensions` method +// https://tc39.github.io/ecma262/#sec-object.preventextensions +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$8, sham: !freezing }, { + preventExtensions: function preventExtensions(it) { + return nativePreventExtensions && isObject(it) ? nativePreventExtensions(onFreeze$1(it)) : it; + } +}); + +var onFreeze$2 = internalMetadata.onFreeze; + + + +var nativeSeal = Object.seal; +var FAILS_ON_PRIMITIVES$9 = fails(function () { nativeSeal(1); }); + +// `Object.seal` method +// https://tc39.github.io/ecma262/#sec-object.seal +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$9, sham: !freezing }, { + seal: function seal(it) { + return nativeSeal && isObject(it) ? nativeSeal(onFreeze$2(it)) : it; + } +}); + +var validateSetPrototypeOfArguments = function (O, proto) { + anObject(O); + if (!isObject(proto) && proto !== null) { + throw TypeError("Can't set " + String(proto) + ' as a prototype'); + } +}; + +// Works with __proto__ only. Old v8 can't work with null proto objects. +/* eslint-disable no-proto */ +var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var correctSetter = false; + var test = {}; + var setter; + try { + setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set; + setter.call(test, []); + correctSetter = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + validateSetPrototypeOfArguments(O, proto); + if (correctSetter) setter.call(O, proto); + else O.__proto__ = proto; + return O; + }; +}() : undefined); + +// `Object.setPrototypeOf` method +// https://tc39.github.io/ecma262/#sec-object.setprototypeof +_export({ target: 'Object', stat: true }, { + setPrototypeOf: objectSetPrototypeOf +}); + +// `Object.values` method +// https://tc39.github.io/ecma262/#sec-object.values +_export({ target: 'Object', stat: true }, { + values: function values(O) { + return objectToArray(O); + } +}); + +var TO_STRING_TAG$2 = wellKnownSymbol('toStringTag'); +var test = {}; + +test[TO_STRING_TAG$2] = 'z'; + +// `Object.prototype.toString` method implementation +// https://tc39.github.io/ecma262/#sec-object.prototype.tostring +var objectToString = String(test) !== '[object z]' ? function toString() { + return '[object ' + classof(this) + ']'; +} : test.toString; + +var ObjectPrototype$2 = Object.prototype; + +// `Object.prototype.toString` method +// https://tc39.github.io/ecma262/#sec-object.prototype.tostring +if (objectToString !== ObjectPrototype$2.toString) { + redefine(ObjectPrototype$2, 'toString', objectToString, { unsafe: true }); +} + +// Forced replacement object prototype accessors methods +var forcedObjectPrototypeAccessorsMethods = !fails(function () { + var key = Math.random(); + // In FF throws only define methods + // eslint-disable-next-line no-undef, no-useless-call + __defineSetter__.call(null, key, function () { /* empty */ }); + delete global_1[key]; +}); + +// `Object.prototype.__defineGetter__` method +// https://tc39.github.io/ecma262/#sec-object.prototype.__defineGetter__ +if (descriptors) { + _export({ target: 'Object', proto: true, forced: forcedObjectPrototypeAccessorsMethods }, { + __defineGetter__: function __defineGetter__(P, getter) { + objectDefineProperty.f(toObject(this), P, { get: aFunction(getter), enumerable: true, configurable: true }); + } + }); +} + +// `Object.prototype.__defineSetter__` method +// https://tc39.github.io/ecma262/#sec-object.prototype.__defineSetter__ +if (descriptors) { + _export({ target: 'Object', proto: true, forced: forcedObjectPrototypeAccessorsMethods }, { + __defineSetter__: function __defineSetter__(P, setter) { + objectDefineProperty.f(toObject(this), P, { set: aFunction(setter), enumerable: true, configurable: true }); + } + }); +} + +var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f; + +// `Object.prototype.__lookupGetter__` method +// https://tc39.github.io/ecma262/#sec-object.prototype.__lookupGetter__ +if (descriptors) { + _export({ target: 'Object', proto: true, forced: forcedObjectPrototypeAccessorsMethods }, { + __lookupGetter__: function __lookupGetter__(P) { + var O = toObject(this); + var key = toPrimitive(P, true); + var desc; + do { + if (desc = getOwnPropertyDescriptor$2(O, key)) return desc.get; + } while (O = objectGetPrototypeOf(O)); + } + }); +} + +var getOwnPropertyDescriptor$3 = objectGetOwnPropertyDescriptor.f; + +// `Object.prototype.__lookupSetter__` method +// https://tc39.github.io/ecma262/#sec-object.prototype.__lookupSetter__ +if (descriptors) { + _export({ target: 'Object', proto: true, forced: forcedObjectPrototypeAccessorsMethods }, { + __lookupSetter__: function __lookupSetter__(P) { + var O = toObject(this); + var key = toPrimitive(P, true); + var desc; + do { + if (desc = getOwnPropertyDescriptor$3(O, key)) return desc.set; + } while (O = objectGetPrototypeOf(O)); + } + }); +} + +var arraySlice = [].slice; +var factories = {}; + +var construct = function (C, argsLength, args) { + if (!(argsLength in factories)) { + for (var list = [], i = 0; i < argsLength; i++) list[i] = 'a[' + i + ']'; + // eslint-disable-next-line no-new-func + factories[argsLength] = Function('C,a', 'return new C(' + list.join(',') + ')'); + } return factories[argsLength](C, args); +}; + +// `Function.prototype.bind` method implementation +// https://tc39.github.io/ecma262/#sec-function.prototype.bind +var functionBind = Function.bind || function bind(that /* , ...args */) { + var fn = aFunction(this); + var partArgs = arraySlice.call(arguments, 1); + var boundFunction = function bound(/* args... */) { + var args = partArgs.concat(arraySlice.call(arguments)); + return this instanceof boundFunction ? construct(fn, args.length, args) : fn.apply(that, args); + }; + if (isObject(fn.prototype)) boundFunction.prototype = fn.prototype; + return boundFunction; +}; + +// `Function.prototype.bind` method +// https://tc39.github.io/ecma262/#sec-function.prototype.bind +_export({ target: 'Function', proto: true }, { + bind: functionBind +}); + +var defineProperty$3 = objectDefineProperty.f; + +var FunctionPrototype = Function.prototype; +var FunctionPrototypeToString = FunctionPrototype.toString; +var nameRE = /^\s*function ([^ (]*)/; +var NAME = 'name'; + +// Function instances `.name` property +// https://tc39.github.io/ecma262/#sec-function-instances-name +if (descriptors && !(NAME in FunctionPrototype)) { + defineProperty$3(FunctionPrototype, NAME, { + configurable: true, + get: function () { + try { + return FunctionPrototypeToString.call(this).match(nameRE)[1]; + } catch (error) { + return ''; + } + } + }); +} + +var HAS_INSTANCE = wellKnownSymbol('hasInstance'); +var FunctionPrototype$1 = Function.prototype; + +// `Function.prototype[@@hasInstance]` method +// https://tc39.github.io/ecma262/#sec-function.prototype-@@hasinstance +if (!(HAS_INSTANCE in FunctionPrototype$1)) { + objectDefineProperty.f(FunctionPrototype$1, HAS_INSTANCE, { value: function (O) { + if (typeof this != 'function' || !isObject(O)) return false; + if (!isObject(this.prototype)) return O instanceof this; + // for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this: + while (O = objectGetPrototypeOf(O)) if (this.prototype === O) return true; + return false; + } }); +} + +// `Array.from` method +// https://tc39.github.io/ecma262/#sec-array.from +var arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { + var O = toObject(arrayLike); + var C = typeof this == 'function' ? this : Array; + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + var index = 0; + var iteratorMethod = getIteratorMethod(O); + var length, result, step, iterator; + if (mapping) mapfn = bindContext(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2); + // if the target is not iterable or it's an array with the default iterator - use a simple case + if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) { + iterator = iteratorMethod.call(O); + result = new C(); + for (;!(step = iterator.next()).done; index++) { + createProperty(result, index, mapping + ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) + : step.value + ); + } + } else { + length = toLength(O.length); + result = new C(length); + for (;length > index; index++) { + createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]); + } + } + result.length = index; + return result; +}; + +var ITERATOR$2 = wellKnownSymbol('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR$2] = function () { + return this; + }; + // eslint-disable-next-line no-throw-literal + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +var checkCorrectnessOfIteration = function (exec, SKIP_CLOSING) { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR$2] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + +var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { + Array.from(iterable); +}); + +// `Array.from` method +// https://tc39.github.io/ecma262/#sec-array.from +_export({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { + from: arrayFrom +}); + +// `Array.isArray` method +// https://tc39.github.io/ecma262/#sec-array.isarray +_export({ target: 'Array', stat: true }, { isArray: isArray }); + +var ISNT_GENERIC = fails(function () { + function F() { /* empty */ } + return !(Array.of.call(F) instanceof F); +}); + +// `Array.of` method +// https://tc39.github.io/ecma262/#sec-array.of +// WebKit Array.of isn't generic +_export({ target: 'Array', stat: true, forced: ISNT_GENERIC }, { + of: function of(/* ...args */) { + var index = 0; + var argumentsLength = arguments.length; + var result = new (typeof this == 'function' ? this : Array)(argumentsLength); + while (argumentsLength > index) createProperty(result, index, arguments[index++]); + result.length = argumentsLength; + return result; + } +}); + +var SPECIES = wellKnownSymbol('species'); + +// `ArraySpeciesCreate` abstract operation +// https://tc39.github.io/ecma262/#sec-arrayspeciescreate +var arraySpeciesCreate = function (originalArray, length) { + var C; + if (isArray(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined; + else if (isObject(C)) { + C = C[SPECIES]; + if (C === null) C = undefined; + } + } return new (C === undefined ? Array : C)(length === 0 ? 0 : length); +}; + +var SPECIES$1 = wellKnownSymbol('species'); + +var arrayMethodHasSpeciesSupport = function (METHOD_NAME) { + return !fails(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES$1] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); +}; + +var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable'); +var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; +var MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded'; + +var IS_CONCAT_SPREADABLE_SUPPORT = !fails(function () { + var array = []; + array[IS_CONCAT_SPREADABLE] = false; + return array.concat()[0] !== array; +}); + +var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat'); + +var isConcatSpreadable = function (O) { + if (!isObject(O)) return false; + var spreadable = O[IS_CONCAT_SPREADABLE]; + return spreadable !== undefined ? !!spreadable : isArray(O); +}; + +var FORCED$1 = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT; + +// `Array.prototype.concat` method +// https://tc39.github.io/ecma262/#sec-array.prototype.concat +// with adding support of @@isConcatSpreadable and @@species +_export({ target: 'Array', proto: true, forced: FORCED$1 }, { + concat: function concat(arg) { // eslint-disable-line no-unused-vars + var O = toObject(this); + var A = arraySpeciesCreate(O, 0); + var n = 0; + var i, k, length, len, E; + for (i = -1, length = arguments.length; i < length; i++) { + E = i === -1 ? O : arguments[i]; + if (isConcatSpreadable(E)) { + len = toLength(E.length); + if (n + len > MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); + for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]); + } else { + if (n >= MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); + createProperty(A, n++, E); + } + } + A.length = n; + return A; + } +}); + +// `Array.prototype.copyWithin` method implementation +// https://tc39.github.io/ecma262/#sec-array.prototype.copywithin +var arrayCopyWithin = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) { + var O = toObject(this); + var len = toLength(O.length); + var to = toAbsoluteIndex(target, len); + var from = toAbsoluteIndex(start, len); + var end = arguments.length > 2 ? arguments[2] : undefined; + var count = Math.min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to); + var inc = 1; + if (from < to && to < from + count) { + inc = -1; + from += count - 1; + to += count - 1; + } + while (count-- > 0) { + if (from in O) O[to] = O[from]; + else delete O[to]; + to += inc; + from += inc; + } return O; +}; + +var UNSCOPABLES = wellKnownSymbol('unscopables'); +var ArrayPrototype$1 = Array.prototype; + +// Array.prototype[@@unscopables] +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +if (ArrayPrototype$1[UNSCOPABLES] == undefined) { + hide(ArrayPrototype$1, UNSCOPABLES, objectCreate(null)); +} + +// add a key to Array.prototype[@@unscopables] +var addToUnscopables = function (key) { + ArrayPrototype$1[UNSCOPABLES][key] = true; +}; + +// `Array.prototype.copyWithin` method +// https://tc39.github.io/ecma262/#sec-array.prototype.copywithin +_export({ target: 'Array', proto: true }, { + copyWithin: arrayCopyWithin +}); + +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('copyWithin'); + +// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation +// 0 -> Array#forEach +// https://tc39.github.io/ecma262/#sec-array.prototype.foreach +// 1 -> Array#map +// https://tc39.github.io/ecma262/#sec-array.prototype.map +// 2 -> Array#filter +// https://tc39.github.io/ecma262/#sec-array.prototype.filter +// 3 -> Array#some +// https://tc39.github.io/ecma262/#sec-array.prototype.some +// 4 -> Array#every +// https://tc39.github.io/ecma262/#sec-array.prototype.every +// 5 -> Array#find +// https://tc39.github.io/ecma262/#sec-array.prototype.find +// 6 -> Array#findIndex +// https://tc39.github.io/ecma262/#sec-array.prototype.findIndex +var arrayMethods = function (TYPE, specificCreate) { + var IS_MAP = TYPE == 1; + var IS_FILTER = TYPE == 2; + var IS_SOME = TYPE == 3; + var IS_EVERY = TYPE == 4; + var IS_FIND_INDEX = TYPE == 6; + var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; + var create = specificCreate || arraySpeciesCreate; + return function ($this, callbackfn, that) { + var O = toObject($this); + var self = indexedObject(O); + var boundFunction = bindContext(callbackfn, that, 3); + var length = toLength(self.length); + var index = 0; + var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: target.push(value); // filter + } else if (IS_EVERY) return false; // every + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; + +var sloppyArrayMethod = function (METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !method || !fails(function () { + // eslint-disable-next-line no-useless-call,no-throw-literal + method.call(null, argument || function () { throw 1; }, 1); + }); +}; + +var internalEvery = arrayMethods(4); +var SLOPPY_METHOD = sloppyArrayMethod('every'); + +// `Array.prototype.every` method +// https://tc39.github.io/ecma262/#sec-array.prototype.every +_export({ target: 'Array', proto: true, forced: SLOPPY_METHOD }, { + every: function every(callbackfn /* , thisArg */) { + return internalEvery(this, callbackfn, arguments[1]); + } +}); + +// `Array.prototype.fill` method implementation +// https://tc39.github.io/ecma262/#sec-array.prototype.fill +var arrayFill = function fill(value /* , start = 0, end = @length */) { + var O = toObject(this); + var length = toLength(O.length); + var argumentsLength = arguments.length; + var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length); + var end = argumentsLength > 2 ? arguments[2] : undefined; + var endPos = end === undefined ? length : toAbsoluteIndex(end, length); + while (endPos > index) O[index++] = value; + return O; +}; + +// `Array.prototype.fill` method +// https://tc39.github.io/ecma262/#sec-array.prototype.fill +_export({ target: 'Array', proto: true }, { fill: arrayFill }); + +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('fill'); + +var internalFilter = arrayMethods(2); +var SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport('filter'); + +// `Array.prototype.filter` method +// https://tc39.github.io/ecma262/#sec-array.prototype.filter +// with adding support of @@species +_export({ target: 'Array', proto: true, forced: !SPECIES_SUPPORT$1 }, { + filter: function filter(callbackfn /* , thisArg */) { + return internalFilter(this, callbackfn, arguments[1]); + } +}); + +var internalFind = arrayMethods(5); +var FIND = 'find'; +var SKIPS_HOLES = true; + +// Shouldn't skip holes +if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; }); + +// `Array.prototype.find` method +// https://tc39.github.io/ecma262/#sec-array.prototype.find +_export({ target: 'Array', proto: true, forced: SKIPS_HOLES }, { + find: function find(callbackfn /* , that = undefined */) { + return internalFind(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables(FIND); + +var internalFindIndex = arrayMethods(6); +var FIND_INDEX = 'findIndex'; +var SKIPS_HOLES$1 = true; + +// Shouldn't skip holes +if (FIND_INDEX in []) Array(1)[FIND_INDEX](function () { SKIPS_HOLES$1 = false; }); + +// `Array.prototype.findIndex` method +// https://tc39.github.io/ecma262/#sec-array.prototype.findindex +_export({ target: 'Array', proto: true, forced: SKIPS_HOLES$1 }, { + findIndex: function findIndex(callbackfn /* , that = undefined */) { + return internalFindIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables(FIND_INDEX); + +// `FlattenIntoArray` abstract operation +// https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray +var flattenIntoArray = function (target, original, source, sourceLen, start, depth, mapper, thisArg) { + var targetIndex = start; + var sourceIndex = 0; + var mapFn = mapper ? bindContext(mapper, thisArg, 3) : false; + var element; + + while (sourceIndex < sourceLen) { + if (sourceIndex in source) { + element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex]; + + if (depth > 0 && isArray(element)) { + targetIndex = flattenIntoArray(target, original, element, toLength(element.length), targetIndex, depth - 1) - 1; + } else { + if (targetIndex >= 0x1FFFFFFFFFFFFF) throw TypeError('Exceed the acceptable array length'); + target[targetIndex] = element; + } + + targetIndex++; + } + sourceIndex++; + } + return targetIndex; +}; + +var flattenIntoArray_1 = flattenIntoArray; + +// `Array.prototype.flat` method +// https://github.com/tc39/proposal-flatMap +_export({ target: 'Array', proto: true }, { + flat: function flat(/* depthArg = 1 */) { + var depthArg = arguments[0]; + var O = toObject(this); + var sourceLen = toLength(O.length); + var A = arraySpeciesCreate(O, 0); + A.length = flattenIntoArray_1(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toInteger(depthArg)); + return A; + } +}); + +// `Array.prototype.flatMap` method +// https://github.com/tc39/proposal-flatMap +_export({ target: 'Array', proto: true }, { + flatMap: function flatMap(callbackfn /* , thisArg */) { + var O = toObject(this); + var sourceLen = toLength(O.length); + var A; + aFunction(callbackfn); + A = arraySpeciesCreate(O, 0); + A.length = flattenIntoArray_1(A, O, O, sourceLen, 0, 1, callbackfn, arguments[1]); + return A; + } +}); + +var internalForEach = arrayMethods(0); +var SLOPPY_METHOD$1 = sloppyArrayMethod('forEach'); + +// `Array.prototype.forEach` method implementation +// https://tc39.github.io/ecma262/#sec-array.prototype.foreach +var arrayForEach = SLOPPY_METHOD$1 ? function forEach(callbackfn /* , thisArg */) { + return internalForEach(this, callbackfn, arguments[1]); +} : [].forEach; + +// `Array.prototype.forEach` method +// https://tc39.github.io/ecma262/#sec-array.prototype.foreach +_export({ target: 'Array', proto: true, forced: [].forEach != arrayForEach }, { + forEach: arrayForEach +}); + +var internalIncludes = arrayIncludes(true); + +// `Array.prototype.includes` method +// https://tc39.github.io/ecma262/#sec-array.prototype.includes +_export({ target: 'Array', proto: true }, { + includes: function includes(el /* , fromIndex = 0 */) { + return internalIncludes(this, el, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('includes'); + +var internalIndexOf = arrayIncludes(false); +var nativeIndexOf = [].indexOf; + +var NEGATIVE_ZERO = !!nativeIndexOf && 1 / [1].indexOf(1, -0) < 0; +var SLOPPY_METHOD$2 = sloppyArrayMethod('indexOf'); + +// `Array.prototype.indexOf` method +// https://tc39.github.io/ecma262/#sec-array.prototype.indexof +_export({ target: 'Array', proto: true, forced: NEGATIVE_ZERO || SLOPPY_METHOD$2 }, { + indexOf: function indexOf(searchElement /* , fromIndex = 0 */) { + return NEGATIVE_ZERO + // convert -0 to +0 + ? nativeIndexOf.apply(this, arguments) || 0 + : internalIndexOf(this, searchElement, arguments[1]); + } +}); + +var nativeJoin = [].join; + +var ES3_STRINGS = indexedObject != Object; +var SLOPPY_METHOD$3 = sloppyArrayMethod('join', ','); + +// `Array.prototype.join` method +// https://tc39.github.io/ecma262/#sec-array.prototype.join +_export({ target: 'Array', proto: true, forced: ES3_STRINGS || SLOPPY_METHOD$3 }, { + join: function join(separator) { + return nativeJoin.call(toIndexedObject(this), separator === undefined ? ',' : separator); + } +}); + +var nativeLastIndexOf = [].lastIndexOf; +var NEGATIVE_ZERO$1 = !!nativeLastIndexOf && 1 / [1].lastIndexOf(1, -0) < 0; +var SLOPPY_METHOD$4 = sloppyArrayMethod('lastIndexOf'); + +// `Array.prototype.lastIndexOf` method implementation +// https://tc39.github.io/ecma262/#sec-array.prototype.lastindexof +var arrayLastIndexOf = (NEGATIVE_ZERO$1 || SLOPPY_METHOD$4) ? function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) { + // convert -0 to +0 + if (NEGATIVE_ZERO$1) return nativeLastIndexOf.apply(this, arguments) || 0; + var O = toIndexedObject(this); + var length = toLength(O.length); + var index = length - 1; + if (arguments.length > 1) index = Math.min(index, toInteger(arguments[1])); + if (index < 0) index = length + index; + for (;index >= 0; index--) if (index in O) if (O[index] === searchElement) return index || 0; + return -1; +} : nativeLastIndexOf; + +// `Array.prototype.lastIndexOf` method +// https://tc39.github.io/ecma262/#sec-array.prototype.lastindexof +_export({ target: 'Array', proto: true, forced: arrayLastIndexOf !== [].lastIndexOf }, { + lastIndexOf: arrayLastIndexOf +}); + +var internalMap = arrayMethods(1); +var SPECIES_SUPPORT$2 = arrayMethodHasSpeciesSupport('map'); + +// `Array.prototype.map` method +// https://tc39.github.io/ecma262/#sec-array.prototype.map +// with adding support of @@species +_export({ target: 'Array', proto: true, forced: !SPECIES_SUPPORT$2 }, { + map: function map(callbackfn /* , thisArg */) { + return internalMap(this, callbackfn, arguments[1]); + } +}); + +// `Array.prototype.{ reduce, reduceRight }` methods implementation +// https://tc39.github.io/ecma262/#sec-array.prototype.reduce +// https://tc39.github.io/ecma262/#sec-array.prototype.reduceright +var arrayReduce = function (that, callbackfn, argumentsLength, memo, isRight) { + aFunction(callbackfn); + var O = toObject(that); + var self = indexedObject(O); + var length = toLength(O.length); + var index = isRight ? length - 1 : 0; + var i = isRight ? -1 : 1; + if (argumentsLength < 2) while (true) { + if (index in self) { + memo = self[index]; + index += i; + break; + } + index += i; + if (isRight ? index < 0 : length <= index) { + throw TypeError('Reduce of empty array with no initial value'); + } + } + for (;isRight ? index >= 0 : length > index; index += i) if (index in self) { + memo = callbackfn(memo, self[index], index, O); + } + return memo; +}; + +var SLOPPY_METHOD$5 = sloppyArrayMethod('reduce'); + +// `Array.prototype.reduce` method +// https://tc39.github.io/ecma262/#sec-array.prototype.reduce +_export({ target: 'Array', proto: true, forced: SLOPPY_METHOD$5 }, { + reduce: function reduce(callbackfn /* , initialValue */) { + return arrayReduce(this, callbackfn, arguments.length, arguments[1], false); + } +}); + +var SLOPPY_METHOD$6 = sloppyArrayMethod('reduceRight'); + +// `Array.prototype.reduceRight` method +// https://tc39.github.io/ecma262/#sec-array.prototype.reduceright +_export({ target: 'Array', proto: true, forced: SLOPPY_METHOD$6 }, { + reduceRight: function reduceRight(callbackfn /* , initialValue */) { + return arrayReduce(this, callbackfn, arguments.length, arguments[1], true); + } +}); + +var nativeReverse = [].reverse; +var test$1 = [1, 2]; + +// `Array.prototype.reverse` method +// https://tc39.github.io/ecma262/#sec-array.prototype.reverse +// fix for Safari 12.0 bug +// https://bugs.webkit.org/show_bug.cgi?id=188794 +_export({ target: 'Array', proto: true, forced: String(test$1) === String(test$1.reverse()) }, { + reverse: function reverse() { + if (isArray(this)) this.length = this.length; + return nativeReverse.call(this); + } +}); + +var SPECIES$2 = wellKnownSymbol('species'); +var nativeSlice = [].slice; +var max$1 = Math.max; + +var SPECIES_SUPPORT$3 = arrayMethodHasSpeciesSupport('slice'); + +// `Array.prototype.slice` method +// https://tc39.github.io/ecma262/#sec-array.prototype.slice +// fallback for not array-like ES3 strings and DOM objects +_export({ target: 'Array', proto: true, forced: !SPECIES_SUPPORT$3 }, { + slice: function slice(start, end) { + var O = toIndexedObject(this); + var length = toLength(O.length); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible + var Constructor, result, n; + if (isArray(O)) { + Constructor = O.constructor; + // cross-realm fallback + if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) { + Constructor = undefined; + } else if (isObject(Constructor)) { + Constructor = Constructor[SPECIES$2]; + if (Constructor === null) Constructor = undefined; + } + if (Constructor === Array || Constructor === undefined) { + return nativeSlice.call(O, k, fin); + } + } + result = new (Constructor === undefined ? Array : Constructor)(max$1(fin - k, 0)); + for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]); + result.length = n; + return result; + } +}); + +var internalSome = arrayMethods(3); +var SLOPPY_METHOD$7 = sloppyArrayMethod('some'); + +// `Array.prototype.some` method +// https://tc39.github.io/ecma262/#sec-array.prototype.some +_export({ target: 'Array', proto: true, forced: SLOPPY_METHOD$7 }, { + some: function some(callbackfn /* , thisArg */) { + return internalSome(this, callbackfn, arguments[1]); + } +}); + +var nativeSort = [].sort; +var test$2 = [1, 2, 3]; + +// IE8- +var FAILS_ON_UNDEFINED = fails(function () { + test$2.sort(undefined); +}); +// V8 bug +var FAILS_ON_NULL = fails(function () { + test$2.sort(null); +}); +// Old WebKit +var SLOPPY_METHOD$8 = sloppyArrayMethod('sort'); + +var FORCED$2 = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || SLOPPY_METHOD$8; + +// `Array.prototype.sort` method +// https://tc39.github.io/ecma262/#sec-array.prototype.sort +_export({ target: 'Array', proto: true, forced: FORCED$2 }, { + sort: function sort(comparefn) { + return comparefn === undefined + ? nativeSort.call(toObject(this)) + : nativeSort.call(toObject(this), aFunction(comparefn)); + } +}); + +var max$2 = Math.max; +var min$2 = Math.min; +var MAX_SAFE_INTEGER$1 = 0x1FFFFFFFFFFFFF; +var MAXIMUM_ALLOWED_LENGTH_EXCEEDED = 'Maximum allowed length exceeded'; + +var SPECIES_SUPPORT$4 = arrayMethodHasSpeciesSupport('splice'); + +// `Array.prototype.splice` method +// https://tc39.github.io/ecma262/#sec-array.prototype.splice +// with adding support of @@species +_export({ target: 'Array', proto: true, forced: !SPECIES_SUPPORT$4 }, { + splice: function splice(start, deleteCount /* , ...items */) { + var O = toObject(this); + var len = toLength(O.length); + var actualStart = toAbsoluteIndex(start, len); + var argumentsLength = arguments.length; + var insertCount, actualDeleteCount, A, k, from, to; + if (argumentsLength === 0) { + insertCount = actualDeleteCount = 0; + } else if (argumentsLength === 1) { + insertCount = 0; + actualDeleteCount = len - actualStart; + } else { + insertCount = argumentsLength - 2; + actualDeleteCount = min$2(max$2(toInteger(deleteCount), 0), len - actualStart); + } + if (len + insertCount - actualDeleteCount > MAX_SAFE_INTEGER$1) { + throw TypeError(MAXIMUM_ALLOWED_LENGTH_EXCEEDED); + } + A = arraySpeciesCreate(O, actualDeleteCount); + for (k = 0; k < actualDeleteCount; k++) { + from = actualStart + k; + if (from in O) createProperty(A, k, O[from]); + } + A.length = actualDeleteCount; + if (insertCount < actualDeleteCount) { + for (k = actualStart; k < len - actualDeleteCount; k++) { + from = k + actualDeleteCount; + to = k + insertCount; + if (from in O) O[to] = O[from]; + else delete O[to]; + } + for (k = len; k > len - actualDeleteCount + insertCount; k--) delete O[k - 1]; + } else if (insertCount > actualDeleteCount) { + for (k = len - actualDeleteCount; k > actualStart; k--) { + from = k + actualDeleteCount - 1; + to = k + insertCount - 1; + if (from in O) O[to] = O[from]; + else delete O[to]; + } + } + for (k = 0; k < insertCount; k++) { + O[k + actualStart] = arguments[k + 2]; + } + O.length = len - actualDeleteCount + insertCount; + return A; + } +}); + +var aFunction$1 = function (variable) { + return typeof variable == 'function' ? variable : undefined; +}; + +var getBuiltIn = function (namespace, method) { + return arguments.length < 2 ? aFunction$1(path[namespace]) || aFunction$1(global_1[namespace]) + : path[namespace] && path[namespace][method] || global_1[namespace] && global_1[namespace][method]; +}; + +var SPECIES$3 = wellKnownSymbol('species'); + +var setSpecies = function (CONSTRUCTOR_NAME) { + var C = getBuiltIn(CONSTRUCTOR_NAME); + var defineProperty = objectDefineProperty.f; + if (descriptors && C && !C[SPECIES$3]) defineProperty(C, SPECIES$3, { + configurable: true, + get: function () { return this; } + }); +}; + +// `Array[@@species]` getter +// https://tc39.github.io/ecma262/#sec-get-array-@@species +setSpecies('Array'); + +// this method was added to unscopables after implementation +// in popular engines, so it's moved to a separate module + + +addToUnscopables('flat'); + +// this method was added to unscopables after implementation +// in popular engines, so it's moved to a separate module + + +addToUnscopables('flatMap'); + +var ITERATOR$3 = wellKnownSymbol('iterator'); +var BUGGY_SAFARI_ITERATORS = false; + +var returnThis = function () { return this; }; + +// `%IteratorPrototype%` object +// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object +var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator; + +if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true; + else { + PrototypeOfArrayIteratorPrototype = objectGetPrototypeOf(objectGetPrototypeOf(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype; + } +} + +if (IteratorPrototype == undefined) IteratorPrototype = {}; + +// 25.1.2.1.1 %IteratorPrototype%[@@iterator]() +if (!has(IteratorPrototype, ITERATOR$3)) hide(IteratorPrototype, ITERATOR$3, returnThis); + +var iteratorsCore = { + IteratorPrototype: IteratorPrototype, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS +}; + +var IteratorPrototype$1 = iteratorsCore.IteratorPrototype; + + + + + +var returnThis$1 = function () { return this; }; + +var createIteratorConstructor = function (IteratorConstructor, NAME, next) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = objectCreate(IteratorPrototype$1, { next: createPropertyDescriptor(1, next) }); + setToStringTag(IteratorConstructor, TO_STRING_TAG, false); + iterators[TO_STRING_TAG] = returnThis$1; + return IteratorConstructor; +}; + +var IteratorPrototype$2 = iteratorsCore.IteratorPrototype; +var BUGGY_SAFARI_ITERATORS$1 = iteratorsCore.BUGGY_SAFARI_ITERATORS; +var ITERATOR$4 = wellKnownSymbol('iterator'); +var KEYS = 'keys'; +var VALUES = 'values'; +var ENTRIES = 'entries'; + +var returnThis$2 = function () { return this; }; + +var defineIterator = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS$1 && KIND in IterablePrototype) return IterablePrototype[KIND]; + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR$4] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS$1 && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = objectGetPrototypeOf(anyNativeIterator.call(new Iterable())); + if (IteratorPrototype$2 !== Object.prototype && CurrentIteratorPrototype.next) { + if (objectGetPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype$2) { + if (objectSetPrototypeOf) { + objectSetPrototypeOf(CurrentIteratorPrototype, IteratorPrototype$2); + } else if (typeof CurrentIteratorPrototype[ITERATOR$4] != 'function') { + hide(CurrentIteratorPrototype, ITERATOR$4, returnThis$2); + } + } + // Set @@toStringTag to native iterators + setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true); + } + } + + // fix Array#{values, @@iterator}.name in V8 / FF + if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return nativeIterator.call(this); }; + } + + // define iterator + if (IterablePrototype[ITERATOR$4] !== defaultIterator) { + hide(IterablePrototype, ITERATOR$4, defaultIterator); + } + iterators[NAME] = defaultIterator; + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + redefine(IterablePrototype, KEY, methods[KEY]); + } + } else _export({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME }, methods); + } + + return methods; +}; + +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState$1 = internalState.set; +var getInternalState$1 = internalState.getterFor(ARRAY_ITERATOR); + +// `Array.prototype.entries` method +// https://tc39.github.io/ecma262/#sec-array.prototype.entries +// `Array.prototype.keys` method +// https://tc39.github.io/ecma262/#sec-array.prototype.keys +// `Array.prototype.values` method +// https://tc39.github.io/ecma262/#sec-array.prototype.values +// `Array.prototype[@@iterator]` method +// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator +// `CreateArrayIterator` internal method +// https://tc39.github.io/ecma262/#sec-createarrayiterator +var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) { + setInternalState$1(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject(iterated), // target + index: 0, // next index + kind: kind // kind + }); +// `%ArrayIteratorPrototype%.next` method +// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next +}, function () { + var state = getInternalState$1(this); + var target = state.target; + var kind = state.kind; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return { value: undefined, done: true }; + } + if (kind == 'keys') return { value: index, done: false }; + if (kind == 'values') return { value: target[index], done: false }; + return { value: [index, target[index]], done: false }; +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% +// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject +// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject +iterators.Arguments = iterators.Array; + +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('keys'); +addToUnscopables('values'); +addToUnscopables('entries'); + +var fromCharCode = String.fromCharCode; +var nativeFromCodePoint = String.fromCodePoint; + +// length should be 1, old FF problem +var INCORRECT_LENGTH = !!nativeFromCodePoint && nativeFromCodePoint.length != 1; + +// `String.fromCodePoint` method +// https://tc39.github.io/ecma262/#sec-string.fromcodepoint +_export({ target: 'String', stat: true, forced: INCORRECT_LENGTH }, { + fromCodePoint: function fromCodePoint(x) { // eslint-disable-line no-unused-vars + var elements = []; + var length = arguments.length; + var i = 0; + var code; + while (length > i) { + code = +arguments[i++]; + if (toAbsoluteIndex(code, 0x10FFFF) !== code) throw RangeError(code + ' is not a valid code point'); + elements.push(code < 0x10000 + ? fromCharCode(code) + : fromCharCode(((code -= 0x10000) >> 10) + 0xD800, code % 0x400 + 0xDC00) + ); + } return elements.join(''); + } +}); + +// `String.raw` method +// https://tc39.github.io/ecma262/#sec-string.raw +_export({ target: 'String', stat: true }, { + raw: function raw(template) { + var rawTemplate = toIndexedObject(template.raw); + var literalSegments = toLength(rawTemplate.length); + var argumentsLength = arguments.length; + var elements = []; + var i = 0; + while (literalSegments > i) { + elements.push(String(rawTemplate[i++])); + if (i < argumentsLength) elements.push(String(arguments[i])); + } return elements.join(''); + } +}); + +// CONVERT_TO_STRING: true -> String#at +// CONVERT_TO_STRING: false -> String#codePointAt +var stringAt = function (that, pos, CONVERT_TO_STRING) { + var S = String(requireObjectCoercible(that)); + var position = toInteger(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = S.charCodeAt(position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING ? S.charAt(position) : first + : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; +}; + +// `String.prototype.codePointAt` method +// https://tc39.github.io/ecma262/#sec-string.prototype.codepointat +_export({ target: 'String', proto: true }, { + codePointAt: function codePointAt(pos) { + return stringAt(this, pos); + } +}); + +var MATCH = wellKnownSymbol('match'); + +// `IsRegExp` abstract operation +// https://tc39.github.io/ecma262/#sec-isregexp +var isRegexp = function (it) { + var isRegExp; + return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classofRaw(it) == 'RegExp'); +}; + +// helper for String#{startsWith, endsWith, includes} + + + +var validateStringMethodArguments = function (that, searchString, NAME) { + if (isRegexp(searchString)) { + throw TypeError('String.prototype.' + NAME + " doesn't accept regex"); + } return String(requireObjectCoercible(that)); +}; + +var MATCH$1 = wellKnownSymbol('match'); + +var correctIsRegexpLogic = function (METHOD_NAME) { + var regexp = /./; + try { + '/./'[METHOD_NAME](regexp); + } catch (e) { + try { + regexp[MATCH$1] = false; + return '/./'[METHOD_NAME](regexp); + } catch (f) { /* empty */ } + } return false; +}; + +var ENDS_WITH = 'endsWith'; +var nativeEndsWith = ''[ENDS_WITH]; +var min$3 = Math.min; + +// `String.prototype.endsWith` method +// https://tc39.github.io/ecma262/#sec-string.prototype.endswith +_export({ target: 'String', proto: true, forced: !correctIsRegexpLogic(ENDS_WITH) }, { + endsWith: function endsWith(searchString /* , endPosition = @length */) { + var that = validateStringMethodArguments(this, searchString, ENDS_WITH); + var endPosition = arguments.length > 1 ? arguments[1] : undefined; + var len = toLength(that.length); + var end = endPosition === undefined ? len : min$3(toLength(endPosition), len); + var search = String(searchString); + return nativeEndsWith + ? nativeEndsWith.call(that, search, end) + : that.slice(end - search.length, end) === search; + } +}); + +// `String.prototype.includes` method +// https://tc39.github.io/ecma262/#sec-string.prototype.includes +_export({ target: 'String', proto: true, forced: !correctIsRegexpLogic('includes') }, { + includes: function includes(searchString /* , position = 0 */) { + return !!~validateStringMethodArguments(this, searchString, 'includes') + .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// `RegExp.prototype.flags` getter implementation +// https://tc39.github.io/ecma262/#sec-get-regexp.prototype.flags +var regexpFlags = function () { + var that = anObject(this); + var result = ''; + if (that.global) result += 'g'; + if (that.ignoreCase) result += 'i'; + if (that.multiline) result += 'm'; + if (that.unicode) result += 'u'; + if (that.sticky) result += 'y'; + return result; +}; + +var nativeExec = RegExp.prototype.exec; +// This always refers to the native implementation, because the +// String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js, +// which loads this file before patching the method. +var nativeReplace = String.prototype.replace; + +var patchedExec = nativeExec; + +var UPDATES_LAST_INDEX_WRONG = (function () { + var re1 = /a/; + var re2 = /b*/g; + nativeExec.call(re1, 'a'); + nativeExec.call(re2, 'a'); + return re1.lastIndex !== 0 || re2.lastIndex !== 0; +})(); + +// nonparticipating capturing group, copied from es5-shim's String#split patch. +var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; + +var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED; + +if (PATCH) { + patchedExec = function exec(str) { + var re = this; + var lastIndex, reCopy, match, i; + + if (NPCG_INCLUDED) { + reCopy = new RegExp('^' + re.source + '$(?!\\s)', regexpFlags.call(re)); + } + if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex; + + match = nativeExec.call(re, str); + + if (UPDATES_LAST_INDEX_WRONG && match) { + re.lastIndex = re.global ? match.index + match[0].length : lastIndex; + } + if (NPCG_INCLUDED && match && match.length > 1) { + // Fix browsers whose `exec` methods don't consistently return `undefined` + // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/ + nativeReplace.call(match[0], reCopy, function () { + for (i = 1; i < arguments.length - 2; i++) { + if (arguments[i] === undefined) match[i] = undefined; + } + }); + } + + return match; + }; +} + +var regexpExec = patchedExec; + +var SPECIES$4 = wellKnownSymbol('species'); + +var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () { + // #replace needs built-in support for named groups. + // #match works fine because it just return the exec results, even if it has + // a "grops" property. + var re = /./; + re.exec = function () { + var result = []; + result.groups = { a: '7' }; + return result; + }; + return ''.replace(re, '$') !== '7'; +}); + +// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec +// Weex JS has frozen built-in prototypes, so use try / catch wrapper +var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () { + var re = /(?:)/; + var originalExec = re.exec; + re.exec = function () { return originalExec.apply(this, arguments); }; + var result = 'ab'.split(re); + return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b'; +}); + +var fixRegexpWellKnownSymbolLogic = function (KEY, length, exec, sham) { + var SYMBOL = wellKnownSymbol(KEY); + + var DELEGATES_TO_SYMBOL = !fails(function () { + // String methods call symbol-named RegEp methods + var O = {}; + O[SYMBOL] = function () { return 7; }; + return ''[KEY](O) != 7; + }); + + var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () { + // Symbol-named RegExp methods call .exec + var execCalled = false; + var re = /a/; + re.exec = function () { execCalled = true; return null; }; + + if (KEY === 'split') { + // RegExp[@@split] doesn't call the regex's exec method, but first creates + // a new one. We need to return the patched regex when creating the new one. + re.constructor = {}; + re.constructor[SPECIES$4] = function () { return re; }; + } + + re[SYMBOL](''); + return !execCalled; + }); + + if ( + !DELEGATES_TO_SYMBOL || + !DELEGATES_TO_EXEC || + (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) || + (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC) + ) { + var nativeRegExpMethod = /./[SYMBOL]; + var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) { + if (regexp.exec === regexpExec) { + if (DELEGATES_TO_SYMBOL && !forceStringMethod) { + // The native String method already delegates to @@method (this + // polyfilled function), leasing to infinite recursion. + // We avoid it by directly calling the native @@method method. + return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) }; + } + return { done: true, value: nativeMethod.call(str, regexp, arg2) }; + } + return { done: false }; + }); + var stringMethod = methods[0]; + var regexMethod = methods[1]; + + redefine(String.prototype, KEY, stringMethod); + redefine(RegExp.prototype, SYMBOL, length == 2 + // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue) + // 21.2.5.11 RegExp.prototype[@@split](string, limit) + ? function (string, arg) { return regexMethod.call(string, this, arg); } + // 21.2.5.6 RegExp.prototype[@@match](string) + // 21.2.5.9 RegExp.prototype[@@search](string) + : function (string) { return regexMethod.call(string, this); } + ); + if (sham) hide(RegExp.prototype[SYMBOL], 'sham', true); + } +}; + +// `AdvanceStringIndex` abstract operation +// https://tc39.github.io/ecma262/#sec-advancestringindex +var advanceStringIndex = function (S, index, unicode) { + return index + (unicode ? stringAt(S, index, true).length : 1); +}; + +// `RegExpExec` abstract operation +// https://tc39.github.io/ecma262/#sec-regexpexec +var regexpExecAbstract = function (R, S) { + var exec = R.exec; + if (typeof exec === 'function') { + var result = exec.call(R, S); + if (typeof result !== 'object') { + throw TypeError('RegExp exec method returned something other than an Object or null'); + } + return result; + } + + if (classofRaw(R) !== 'RegExp') { + throw TypeError('RegExp#exec called on incompatible receiver'); + } + + return regexpExec.call(R, S); +}; + +// @@match logic +fixRegexpWellKnownSymbolLogic('match', 1, function (MATCH, nativeMatch, maybeCallNative) { + return [ + // `String.prototype.match` method + // https://tc39.github.io/ecma262/#sec-string.prototype.match + function match(regexp) { + var O = requireObjectCoercible(this); + var matcher = regexp == undefined ? undefined : regexp[MATCH]; + return matcher !== undefined ? matcher.call(regexp, O) : new RegExp(regexp)[MATCH](String(O)); + }, + // `RegExp.prototype[@@match]` method + // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@match + function (regexp) { + var res = maybeCallNative(nativeMatch, regexp, this); + if (res.done) return res.value; + + var rx = anObject(regexp); + var S = String(this); + + if (!rx.global) return regexpExecAbstract(rx, S); + + var fullUnicode = rx.unicode; + rx.lastIndex = 0; + var A = []; + var n = 0; + var result; + while ((result = regexpExecAbstract(rx, S)) !== null) { + var matchStr = String(result[0]); + A[n] = matchStr; + if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); + n++; + } + return n === 0 ? null : A; + } + ]; +}); + +var SPECIES$5 = wellKnownSymbol('species'); + +// `SpeciesConstructor` abstract operation +// https://tc39.github.io/ecma262/#sec-speciesconstructor +var speciesConstructor = function (O, defaultConstructor) { + var C = anObject(O).constructor; + var S; + return C === undefined || (S = anObject(C)[SPECIES$5]) == undefined ? defaultConstructor : aFunction(S); +}; + +var MATCH_ALL = wellKnownSymbol('matchAll'); +var REGEXP_STRING = 'RegExp String'; +var REGEXP_STRING_ITERATOR = REGEXP_STRING + ' Iterator'; +var setInternalState$2 = internalState.set; +var getInternalState$2 = internalState.getterFor(REGEXP_STRING_ITERATOR); +var RegExpPrototype = RegExp.prototype; +var regExpBuiltinExec = RegExpPrototype.exec; + +var regExpExec = function (R, S) { + var exec = R.exec; + var result; + if (typeof exec == 'function') { + result = exec.call(R, S); + if (typeof result != 'object') throw TypeError('Incorrect exec result'); + return result; + } return regExpBuiltinExec.call(R, S); +}; + +// eslint-disable-next-line max-len +var $RegExpStringIterator = createIteratorConstructor(function RegExpStringIterator(regexp, string, global, fullUnicode) { + setInternalState$2(this, { + type: REGEXP_STRING_ITERATOR, + regexp: regexp, + string: string, + global: global, + unicode: fullUnicode, + done: false + }); +}, REGEXP_STRING, function next() { + var state = getInternalState$2(this); + if (state.done) return { value: undefined, done: true }; + var R = state.regexp; + var S = state.string; + var match = regExpExec(R, S); + if (match === null) return { value: undefined, done: state.done = true }; + if (state.global) { + if (String(match[0]) == '') R.lastIndex = advanceStringIndex(S, toLength(R.lastIndex), state.unicode); + return { value: match, done: false }; + } + state.done = true; + return { value: match, done: false }; +}); + +var $matchAll = function (string) { + var R = anObject(this); + var S = String(string); + var C, flagsValue, flags, matcher, global, fullUnicode; + C = speciesConstructor(R, RegExp); + flagsValue = R.flags; + if (flagsValue === undefined && R instanceof RegExp && !('flags' in RegExpPrototype)) { + flagsValue = regexpFlags.call(R); + } + flags = flagsValue === undefined ? '' : String(flagsValue); + matcher = new C(C === RegExp ? R.source : R, flags); + global = !!~flags.indexOf('g'); + fullUnicode = !!~flags.indexOf('u'); + matcher.lastIndex = toLength(R.lastIndex); + return new $RegExpStringIterator(matcher, S, global, fullUnicode); +}; + +// `String.prototype.matchAll` method +// https://github.com/tc39/proposal-string-matchall +_export({ target: 'String', proto: true }, { + matchAll: function matchAll(regexp) { + var O = requireObjectCoercible(this); + var S, matcher, rx; + if (regexp != null) { + matcher = regexp[MATCH_ALL]; + if (matcher === undefined && isPure && classof(regexp) == 'RegExp') matcher = $matchAll; + if (matcher != null) return aFunction(matcher).call(regexp, O); + } + S = String(O); + rx = new RegExp(regexp, 'g'); + return rx[MATCH_ALL](S); + } +}); + +MATCH_ALL in RegExpPrototype || hide(RegExpPrototype, MATCH_ALL, $matchAll); + +// `String.prototype.repeat` method implementation +// https://tc39.github.io/ecma262/#sec-string.prototype.repeat +var stringRepeat = ''.repeat || function repeat(count) { + var str = String(requireObjectCoercible(this)); + var result = ''; + var n = toInteger(count); + if (n < 0 || n == Infinity) throw RangeError('Wrong number of repetitions'); + for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) result += str; + return result; +}; + +// https://github.com/tc39/proposal-string-pad-start-end + + + + +var stringPad = function (that, maxLength, fillString, left) { + var S = String(requireObjectCoercible(that)); + var stringLength = S.length; + var fillStr = fillString === undefined ? ' ' : String(fillString); + var intMaxLength = toLength(maxLength); + var fillLen, stringFiller; + if (intMaxLength <= stringLength || fillStr == '') return S; + fillLen = intMaxLength - stringLength; + stringFiller = stringRepeat.call(fillStr, Math.ceil(fillLen / fillStr.length)); + if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen); + return left ? stringFiller + S : S + stringFiller; +}; + +var navigator = global_1.navigator; + +var userAgent = navigator && navigator.userAgent || ''; + +// https://github.com/zloirock/core-js/issues/280 + + +// eslint-disable-next-line unicorn/no-unsafe-regex +var webkitStringPadBug = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent); + +// `String.prototype.padEnd` method +// https://tc39.github.io/ecma262/#sec-string.prototype.padend +_export({ target: 'String', proto: true, forced: webkitStringPadBug }, { + padEnd: function padEnd(maxLength /* , fillString = ' ' */) { + return stringPad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false); + } +}); + +// `String.prototype.padStart` method +// https://tc39.github.io/ecma262/#sec-string.prototype.padstart +_export({ target: 'String', proto: true, forced: webkitStringPadBug }, { + padStart: function padStart(maxLength /* , fillString = ' ' */) { + return stringPad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true); + } +}); + +// `String.prototype.repeat` method +// https://tc39.github.io/ecma262/#sec-string.prototype.repeat +_export({ target: 'String', proto: true }, { + repeat: stringRepeat +}); + +var max$3 = Math.max; +var min$4 = Math.min; +var floor$1 = Math.floor; +var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d\d?|<[^>]*>)/g; +var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d\d?)/g; + +var maybeToString = function (it) { + return it === undefined ? it : String(it); +}; + +// @@replace logic +fixRegexpWellKnownSymbolLogic('replace', 2, function (REPLACE, nativeReplace, maybeCallNative) { + return [ + // `String.prototype.replace` method + // https://tc39.github.io/ecma262/#sec-string.prototype.replace + function replace(searchValue, replaceValue) { + var O = requireObjectCoercible(this); + var replacer = searchValue == undefined ? undefined : searchValue[REPLACE]; + return replacer !== undefined + ? replacer.call(searchValue, O, replaceValue) + : nativeReplace.call(String(O), searchValue, replaceValue); + }, + // `RegExp.prototype[@@replace]` method + // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace + function (regexp, replaceValue) { + var res = maybeCallNative(nativeReplace, regexp, this, replaceValue); + if (res.done) return res.value; + + var rx = anObject(regexp); + var S = String(this); + + var functionalReplace = typeof replaceValue === 'function'; + if (!functionalReplace) replaceValue = String(replaceValue); + + var global = rx.global; + if (global) { + var fullUnicode = rx.unicode; + rx.lastIndex = 0; + } + var results = []; + while (true) { + var result = regexpExecAbstract(rx, S); + if (result === null) break; + + results.push(result); + if (!global) break; + + var matchStr = String(result[0]); + if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); + } + + var accumulatedResult = ''; + var nextSourcePosition = 0; + for (var i = 0; i < results.length; i++) { + result = results[i]; + + var matched = String(result[0]); + var position = max$3(min$4(toInteger(result.index), S.length), 0); + var captures = []; + // NOTE: This is equivalent to + // captures = result.slice(1).map(maybeToString) + // but for some reason `nativeSlice.call(result, 1, result.length)` (called in + // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and + // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. + for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j])); + var namedCaptures = result.groups; + if (functionalReplace) { + var replacerArgs = [matched].concat(captures, position, S); + if (namedCaptures !== undefined) replacerArgs.push(namedCaptures); + var replacement = String(replaceValue.apply(undefined, replacerArgs)); + } else { + replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); + } + if (position >= nextSourcePosition) { + accumulatedResult += S.slice(nextSourcePosition, position) + replacement; + nextSourcePosition = position + matched.length; + } + } + return accumulatedResult + S.slice(nextSourcePosition); + } + ]; + + // https://tc39.github.io/ecma262/#sec-getsubstitution + function getSubstitution(matched, str, position, captures, namedCaptures, replacement) { + var tailPos = position + matched.length; + var m = captures.length; + var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; + if (namedCaptures !== undefined) { + namedCaptures = toObject(namedCaptures); + symbols = SUBSTITUTION_SYMBOLS; + } + return nativeReplace.call(replacement, symbols, function (match, ch) { + var capture; + switch (ch.charAt(0)) { + case '$': return '$'; + case '&': return matched; + case '`': return str.slice(0, position); + case "'": return str.slice(tailPos); + case '<': + capture = namedCaptures[ch.slice(1, -1)]; + break; + default: // \d\d? + var n = +ch; + if (n === 0) return match; + if (n > m) { + var f = floor$1(n / 10); + if (f === 0) return match; + if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1); + return match; + } + capture = captures[n - 1]; + } + return capture === undefined ? '' : capture; + }); + } +}); + +// @@search logic +fixRegexpWellKnownSymbolLogic('search', 1, function (SEARCH, nativeSearch, maybeCallNative) { + return [ + // `String.prototype.search` method + // https://tc39.github.io/ecma262/#sec-string.prototype.search + function search(regexp) { + var O = requireObjectCoercible(this); + var searcher = regexp == undefined ? undefined : regexp[SEARCH]; + return searcher !== undefined ? searcher.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O)); + }, + // `RegExp.prototype[@@search]` method + // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@search + function (regexp) { + var res = maybeCallNative(nativeSearch, regexp, this); + if (res.done) return res.value; + + var rx = anObject(regexp); + var S = String(this); + + var previousLastIndex = rx.lastIndex; + if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0; + var result = regexpExecAbstract(rx, S); + if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex; + return result === null ? -1 : result.index; + } + ]; +}); + +var arrayPush = [].push; +var min$5 = Math.min; +var MAX_UINT32 = 0xFFFFFFFF; + +// babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError +var SUPPORTS_Y = !fails(function () { return !RegExp(MAX_UINT32, 'y'); }); + +// @@split logic +fixRegexpWellKnownSymbolLogic('split', 2, function (SPLIT, nativeSplit, maybeCallNative) { + var internalSplit; + if ( + 'abbc'.split(/(b)*/)[1] == 'c' || + 'test'.split(/(?:)/, -1).length != 4 || + 'ab'.split(/(?:ab)*/).length != 2 || + '.'.split(/(.?)(.?)/).length != 4 || + '.'.split(/()()/).length > 1 || + ''.split(/.?/).length + ) { + // based on es5-shim implementation, need to rework it + internalSplit = function (separator, limit) { + var string = String(requireObjectCoercible(this)); + var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; + if (lim === 0) return []; + if (separator === undefined) return [string]; + // If `separator` is not a regex, use native split + if (!isRegexp(separator)) { + return nativeSplit.call(string, separator, lim); + } + var output = []; + var flags = (separator.ignoreCase ? 'i' : '') + + (separator.multiline ? 'm' : '') + + (separator.unicode ? 'u' : '') + + (separator.sticky ? 'y' : ''); + var lastLastIndex = 0; + // Make `global` and avoid `lastIndex` issues by working with a copy + var separatorCopy = new RegExp(separator.source, flags + 'g'); + var match, lastIndex, lastLength; + while (match = regexpExec.call(separatorCopy, string)) { + lastIndex = separatorCopy.lastIndex; + if (lastIndex > lastLastIndex) { + output.push(string.slice(lastLastIndex, match.index)); + if (match.length > 1 && match.index < string.length) arrayPush.apply(output, match.slice(1)); + lastLength = match[0].length; + lastLastIndex = lastIndex; + if (output.length >= lim) break; + } + if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop + } + if (lastLastIndex === string.length) { + if (lastLength || !separatorCopy.test('')) output.push(''); + } else output.push(string.slice(lastLastIndex)); + return output.length > lim ? output.slice(0, lim) : output; + }; + // Chakra, V8 + } else if ('0'.split(undefined, 0).length) { + internalSplit = function (separator, limit) { + return separator === undefined && limit === 0 ? [] : nativeSplit.call(this, separator, limit); + }; + } else internalSplit = nativeSplit; + + return [ + // `String.prototype.split` method + // https://tc39.github.io/ecma262/#sec-string.prototype.split + function split(separator, limit) { + var O = requireObjectCoercible(this); + var splitter = separator == undefined ? undefined : separator[SPLIT]; + return splitter !== undefined + ? splitter.call(separator, O, limit) + : internalSplit.call(String(O), separator, limit); + }, + // `RegExp.prototype[@@split]` method + // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split + // + // NOTE: This cannot be properly polyfilled in engines that don't support + // the 'y' flag. + function (regexp, limit) { + var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== nativeSplit); + if (res.done) return res.value; + + var rx = anObject(regexp); + var S = String(this); + var C = speciesConstructor(rx, RegExp); + + var unicodeMatching = rx.unicode; + var flags = (rx.ignoreCase ? 'i' : '') + + (rx.multiline ? 'm' : '') + + (rx.unicode ? 'u' : '') + + (SUPPORTS_Y ? 'y' : 'g'); + + // ^(? + rx + ) is needed, in combination with some S slicing, to + // simulate the 'y' flag. + var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags); + var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; + if (lim === 0) return []; + if (S.length === 0) return regexpExecAbstract(splitter, S) === null ? [S] : []; + var p = 0; + var q = 0; + var A = []; + while (q < S.length) { + splitter.lastIndex = SUPPORTS_Y ? q : 0; + var z = regexpExecAbstract(splitter, SUPPORTS_Y ? S : S.slice(q)); + var e; + if ( + z === null || + (e = min$5(toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p + ) { + q = advanceStringIndex(S, q, unicodeMatching); + } else { + A.push(S.slice(p, q)); + if (A.length === lim) return A; + for (var i = 1; i <= z.length - 1; i++) { + A.push(z[i]); + if (A.length === lim) return A; + } + q = p = e; + } + } + A.push(S.slice(p)); + return A; + } + ]; +}, !SUPPORTS_Y); + +var STARTS_WITH = 'startsWith'; +var nativeStartsWith = ''[STARTS_WITH]; + +// `String.prototype.startsWith` method +// https://tc39.github.io/ecma262/#sec-string.prototype.startswith +_export({ target: 'String', proto: true, forced: !correctIsRegexpLogic(STARTS_WITH) }, { + startsWith: function startsWith(searchString /* , position = 0 */) { + var that = validateStringMethodArguments(this, searchString, STARTS_WITH); + var index = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length)); + var search = String(searchString); + return nativeStartsWith + ? nativeStartsWith.call(that, search, index) + : that.slice(index, index + search.length) === search; + } +}); + +// a string of all valid unicode whitespaces +// eslint-disable-next-line max-len +var whitespaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + +var whitespace = '[' + whitespaces + ']'; +var ltrim = RegExp('^' + whitespace + whitespace + '*'); +var rtrim = RegExp(whitespace + whitespace + '*$'); + +// 1 -> String#trimStart +// 2 -> String#trimEnd +// 3 -> String#trim +var stringTrim = function (string, TYPE) { + string = String(requireObjectCoercible(string)); + if (TYPE & 1) string = string.replace(ltrim, ''); + if (TYPE & 2) string = string.replace(rtrim, ''); + return string; +}; + +var non = '\u200B\u0085\u180E'; + +// check that a method works with the correct list +// of whitespaces and has a correct name +var forcedStringTrimMethod = function (METHOD_NAME) { + return fails(function () { + return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME; + }); +}; + +var FORCED$3 = forcedStringTrimMethod('trim'); + +// `String.prototype.trim` method +// https://tc39.github.io/ecma262/#sec-string.prototype.trim +_export({ target: 'String', proto: true, forced: FORCED$3 }, { + trim: function trim() { + return stringTrim(this, 3); + } +}); + +var FORCED$4 = forcedStringTrimMethod('trimStart'); + +var trimStart = FORCED$4 ? function trimStart() { + return stringTrim(this, 1); +} : ''.trimStart; + +// `String.prototype.{ trimStart, trimLeft }` methods +// https://github.com/tc39/ecmascript-string-left-right-trim +_export({ target: 'String', proto: true, forced: FORCED$4 }, { + trimStart: trimStart, + trimLeft: trimStart +}); + +var FORCED$5 = forcedStringTrimMethod('trimEnd'); + +var trimEnd = FORCED$5 ? function trimEnd() { + return stringTrim(this, 2); +} : ''.trimEnd; + +// `String.prototype.{ trimEnd, trimRight }` methods +// https://github.com/tc39/ecmascript-string-left-right-trim +_export({ target: 'String', proto: true, forced: FORCED$5 }, { + trimEnd: trimEnd, + trimRight: trimEnd +}); + +var STRING_ITERATOR = 'String Iterator'; +var setInternalState$3 = internalState.set; +var getInternalState$3 = internalState.getterFor(STRING_ITERATOR); + +// `String.prototype[@@iterator]` method +// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator +defineIterator(String, 'String', function (iterated) { + setInternalState$3(this, { + type: STRING_ITERATOR, + string: String(iterated), + index: 0 + }); +// `%StringIteratorPrototype%.next` method +// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next +}, function next() { + var state = getInternalState$3(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return { value: undefined, done: true }; + point = stringAt(string, index, true); + state.index += point.length; + return { value: point, done: false }; +}); + +var quot = /"/g; + +// B.2.3.2.1 CreateHTML(string, tag, attribute, value) +// https://tc39.github.io/ecma262/#sec-createhtml +var createHtml = function (string, tag, attribute, value) { + var S = String(requireObjectCoercible(string)); + var p1 = '<' + tag; + if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '"') + '"'; + return p1 + '>' + S + ''; +}; + +// check the existence of a method, lowercase +// of a tag and escaping quotes in arguments +var forcedStringHtmlMethod = function (METHOD_NAME) { + return fails(function () { + var test = ''[METHOD_NAME]('"'); + return test !== test.toLowerCase() || test.split('"').length > 3; + }); +}; + +// `String.prototype.anchor` method +// https://tc39.github.io/ecma262/#sec-string.prototype.anchor +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('anchor') }, { + anchor: function anchor(name) { + return createHtml(this, 'a', 'name', name); + } +}); + +// `String.prototype.big` method +// https://tc39.github.io/ecma262/#sec-string.prototype.big +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('big') }, { + big: function big() { + return createHtml(this, 'big', '', ''); + } +}); + +// `String.prototype.blink` method +// https://tc39.github.io/ecma262/#sec-string.prototype.blink +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('blink') }, { + blink: function blink() { + return createHtml(this, 'blink', '', ''); + } +}); + +// `String.prototype.bold` method +// https://tc39.github.io/ecma262/#sec-string.prototype.bold +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('bold') }, { + bold: function bold() { + return createHtml(this, 'b', '', ''); + } +}); + +// `String.prototype.fixed` method +// https://tc39.github.io/ecma262/#sec-string.prototype.fixed +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('fixed') }, { + fixed: function fixed() { + return createHtml(this, 'tt', '', ''); + } +}); + +// `String.prototype.fontcolor` method +// https://tc39.github.io/ecma262/#sec-string.prototype.fontcolor +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('fontcolor') }, { + fontcolor: function fontcolor(color) { + return createHtml(this, 'font', 'color', color); + } +}); + +// `String.prototype.fontsize` method +// https://tc39.github.io/ecma262/#sec-string.prototype.fontsize +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('fontsize') }, { + fontsize: function fontsize(size) { + return createHtml(this, 'font', 'size', size); + } +}); + +// `String.prototype.italics` method +// https://tc39.github.io/ecma262/#sec-string.prototype.italics +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('italics') }, { + italics: function italics() { + return createHtml(this, 'i', '', ''); + } +}); + +// `String.prototype.link` method +// https://tc39.github.io/ecma262/#sec-string.prototype.link +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('link') }, { + link: function link(url) { + return createHtml(this, 'a', 'href', url); + } +}); + +// `String.prototype.small` method +// https://tc39.github.io/ecma262/#sec-string.prototype.small +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('small') }, { + small: function small() { + return createHtml(this, 'small', '', ''); + } +}); + +// `String.prototype.strike` method +// https://tc39.github.io/ecma262/#sec-string.prototype.strike +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('strike') }, { + strike: function strike() { + return createHtml(this, 'strike', '', ''); + } +}); + +// `String.prototype.sub` method +// https://tc39.github.io/ecma262/#sec-string.prototype.sub +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('sub') }, { + sub: function sub() { + return createHtml(this, 'sub', '', ''); + } +}); + +// `String.prototype.sup` method +// https://tc39.github.io/ecma262/#sec-string.prototype.sup +_export({ target: 'String', proto: true, forced: forcedStringHtmlMethod('sup') }, { + sup: function sup() { + return createHtml(this, 'sup', '', ''); + } +}); + +var inheritIfRequired = function (that, target, C) { + var S = target.constructor; + var P; + if (S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && objectSetPrototypeOf) { + objectSetPrototypeOf(that, P); + } return that; +}; + +var defineProperty$4 = objectDefineProperty.f; +var getOwnPropertyNames = objectGetOwnPropertyNames.f; + + + + + + + +var MATCH$2 = wellKnownSymbol('match'); +var NativeRegExp = global_1.RegExp; +var RegExpPrototype$1 = NativeRegExp.prototype; +var re1 = /a/g; +var re2 = /a/g; + +// "new" should create a new object, old webkit bug +var CORRECT_NEW = new NativeRegExp(re1) !== re1; + +var FORCED$6 = isForced_1('RegExp', descriptors && (!CORRECT_NEW || fails(function () { + re2[MATCH$2] = false; + // RegExp constructor can alter flags and IsRegExp works correct with @@match + return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i'; +}))); + +// `RegExp` constructor +// https://tc39.github.io/ecma262/#sec-regexp-constructor +if (FORCED$6) { + var RegExpWrapper = function RegExp(pattern, flags) { + var thisIsRegExp = this instanceof RegExpWrapper; + var patternIsRegExp = isRegexp(pattern); + var flagsAreUndefined = flags === undefined; + return !thisIsRegExp && patternIsRegExp && pattern.constructor === RegExpWrapper && flagsAreUndefined ? pattern + : inheritIfRequired(CORRECT_NEW + ? new NativeRegExp(patternIsRegExp && !flagsAreUndefined ? pattern.source : pattern, flags) + : NativeRegExp((patternIsRegExp = pattern instanceof RegExpWrapper) + ? pattern.source + : pattern, patternIsRegExp && flagsAreUndefined ? regexpFlags.call(pattern) : flags) + , thisIsRegExp ? this : RegExpPrototype$1, RegExpWrapper); + }; + var proxy = function (key) { + key in RegExpWrapper || defineProperty$4(RegExpWrapper, key, { + configurable: true, + get: function () { return NativeRegExp[key]; }, + set: function (it) { NativeRegExp[key] = it; } + }); + }; + var keys$1 = getOwnPropertyNames(NativeRegExp); + var i = 0; + while (i < keys$1.length) proxy(keys$1[i++]); + RegExpPrototype$1.constructor = RegExpWrapper; + RegExpWrapper.prototype = RegExpPrototype$1; + redefine(global_1, 'RegExp', RegExpWrapper); +} + +// https://tc39.github.io/ecma262/#sec-get-regexp-@@species +setSpecies('RegExp'); + +_export({ target: 'RegExp', proto: true, forced: /./.exec !== regexpExec }, { + exec: regexpExec +}); + +// `RegExp.prototype.flags` getter +// https://tc39.github.io/ecma262/#sec-get-regexp.prototype.flags +if (descriptors && /./g.flags != 'g') { + objectDefineProperty.f(RegExp.prototype, 'flags', { + configurable: true, + get: regexpFlags + }); +} + +var TO_STRING = 'toString'; +var nativeToString = /./[TO_STRING]; +var RegExpPrototype$2 = RegExp.prototype; + +var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; }); +// FF44- RegExp#toString has a wrong name +var INCORRECT_NAME = nativeToString.name != TO_STRING; + +// `RegExp.prototype.toString` method +// https://tc39.github.io/ecma262/#sec-regexp.prototype.tostring +if (NOT_GENERIC || INCORRECT_NAME) { + redefine(RegExp.prototype, TO_STRING, function toString() { + var R = anObject(this); + var p = String(R.source); + var rf = R.flags; + var f = String(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype$2) ? regexpFlags.call(R) : rf); + return '/' + p + '/' + f; + }, { unsafe: true }); +} + +var nativeParseInt = global_1.parseInt; +var hex = /^[+-]?0[Xx]/; +var FORCED$7 = nativeParseInt(whitespaces + '08') !== 8 || nativeParseInt(whitespaces + '0x16') !== 22; + +var _parseInt = FORCED$7 ? function parseInt(str, radix) { + var string = stringTrim(String(str), 3); + return nativeParseInt(string, (radix >>> 0) || (hex.test(string) ? 16 : 10)); +} : nativeParseInt; + +// `parseInt` method +// https://tc39.github.io/ecma262/#sec-parseint-string-radix +_export({ global: true, forced: parseInt != _parseInt }, { + parseInt: _parseInt +}); + +var nativeParseFloat = global_1.parseFloat; +var FORCED$8 = 1 / nativeParseFloat(whitespaces + '-0') !== -Infinity; + +var _parseFloat = FORCED$8 ? function parseFloat(str) { + var string = stringTrim(String(str), 3); + var result = nativeParseFloat(string); + return result === 0 && string.charAt(0) == '-' ? -0 : result; +} : nativeParseFloat; + +// `parseFloat` method +// https://tc39.github.io/ecma262/#sec-parsefloat-string +_export({ global: true, forced: parseFloat != _parseFloat }, { + parseFloat: _parseFloat +}); + +var getOwnPropertyNames$1 = objectGetOwnPropertyNames.f; +var getOwnPropertyDescriptor$4 = objectGetOwnPropertyDescriptor.f; +var defineProperty$5 = objectDefineProperty.f; + + +var NUMBER = 'Number'; +var NativeNumber = global_1[NUMBER]; +var NumberPrototype = NativeNumber.prototype; + +// Opera ~12 has broken Object#toString +var BROKEN_CLASSOF = classofRaw(objectCreate(NumberPrototype)) == NUMBER; +var NATIVE_TRIM = 'trim' in String.prototype; + +// `ToNumber` abstract operation +// https://tc39.github.io/ecma262/#sec-tonumber +var toNumber = function (argument) { + var it = toPrimitive(argument, false); + var first, third, radix, maxCode, digits, length, i, code; + if (typeof it == 'string' && it.length > 2) { + it = NATIVE_TRIM ? it.trim() : stringTrim(it, 3); + first = it.charCodeAt(0); + if (first === 43 || first === 45) { + third = it.charCodeAt(2); + if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix + } else if (first === 48) { + switch (it.charCodeAt(1)) { + case 66: case 98: radix = 2; maxCode = 49; break; // fast equal of /^0b[01]+$/i + case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i + default: return +it; + } + digits = it.slice(2); + length = digits.length; + for (i = 0; i < length; i++) { + code = digits.charCodeAt(i); + // parseInt parses a string to a first unavailable symbol + // but ToNumber should return NaN if a string contains unavailable symbols + if (code < 48 || code > maxCode) return NaN; + } return parseInt(digits, radix); + } + } return +it; +}; + +// `Number` constructor +// https://tc39.github.io/ecma262/#sec-number-constructor +if (isForced_1(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) { + var NumberWrapper = function Number(value) { + var it = arguments.length < 1 ? 0 : value; + var that = this; + return that instanceof NumberWrapper + // check on 1..constructor(foo) case + && (BROKEN_CLASSOF ? fails(function () { NumberPrototype.valueOf.call(that); }) : classofRaw(that) != NUMBER) + ? inheritIfRequired(new NativeNumber(toNumber(it)), that, NumberWrapper) : toNumber(it); + }; + for (var keys$2 = descriptors ? getOwnPropertyNames$1(NativeNumber) : ( + // ES3: + 'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + + // ES2015 (in case, if modules with ES2015 Number statics required before): + 'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' + + 'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger' + ).split(','), j = 0, key; keys$2.length > j; j++) { + if (has(NativeNumber, key = keys$2[j]) && !has(NumberWrapper, key)) { + defineProperty$5(NumberWrapper, key, getOwnPropertyDescriptor$4(NativeNumber, key)); + } + } + NumberWrapper.prototype = NumberPrototype; + NumberPrototype.constructor = NumberWrapper; + redefine(global_1, NUMBER, NumberWrapper); +} + +// `Number.EPSILON` constant +// https://tc39.github.io/ecma262/#sec-number.epsilon +_export({ target: 'Number', stat: true }, { + EPSILON: Math.pow(2, -52) +}); + +var globalIsFinite = global_1.isFinite; + +// `Number.isFinite` method +// https://tc39.github.io/ecma262/#sec-number.isfinite +var numberIsFinite = Number.isFinite || function isFinite(it) { + return typeof it == 'number' && globalIsFinite(it); +}; + +// `Number.isFinite` method +// https://tc39.github.io/ecma262/#sec-number.isfinite +_export({ target: 'Number', stat: true }, { isFinite: numberIsFinite }); + +var floor$2 = Math.floor; + +// `Number.isInteger` method implementation +// https://tc39.github.io/ecma262/#sec-number.isinteger +var isInteger = function isInteger(it) { + return !isObject(it) && isFinite(it) && floor$2(it) === it; +}; + +// `Number.isInteger` method +// https://tc39.github.io/ecma262/#sec-number.isinteger +_export({ target: 'Number', stat: true }, { + isInteger: isInteger +}); + +// `Number.isNaN` method +// https://tc39.github.io/ecma262/#sec-number.isnan +_export({ target: 'Number', stat: true }, { + isNaN: function isNaN(number) { + // eslint-disable-next-line no-self-compare + return number != number; + } +}); + +var abs = Math.abs; + +// `Number.isSafeInteger` method +// https://tc39.github.io/ecma262/#sec-number.issafeinteger +_export({ target: 'Number', stat: true }, { + isSafeInteger: function isSafeInteger(number) { + return isInteger(number) && abs(number) <= 0x1FFFFFFFFFFFFF; + } +}); + +// `Number.MAX_SAFE_INTEGER` constant +// https://tc39.github.io/ecma262/#sec-number.max_safe_integer +_export({ target: 'Number', stat: true }, { + MAX_SAFE_INTEGER: 0x1FFFFFFFFFFFFF +}); + +// `Number.MIN_SAFE_INTEGER` constant +// https://tc39.github.io/ecma262/#sec-number.min_safe_integer +_export({ target: 'Number', stat: true }, { + MIN_SAFE_INTEGER: -0x1FFFFFFFFFFFFF +}); + +// `Number.parseFloat` method +// https://tc39.github.io/ecma262/#sec-number.parseFloat +_export({ target: 'Number', stat: true, forced: Number.parseFloat != _parseFloat }, { + parseFloat: _parseFloat +}); + +// `Number.parseInt` method +// https://tc39.github.io/ecma262/#sec-number.parseint +_export({ target: 'Number', stat: true, forced: Number.parseInt != _parseInt }, { + parseInt: _parseInt +}); + +// `thisNumberValue` abstract operation +// https://tc39.github.io/ecma262/#sec-thisnumbervalue +var thisNumberValue = function (value) { + if (typeof value != 'number' && classofRaw(value) != 'Number') { + throw TypeError('Incorrect invocation'); + } + return +value; +}; + +var nativeToFixed = 1.0.toFixed; +var floor$3 = Math.floor; +var data$1 = [0, 0, 0, 0, 0, 0]; + +var multiply = function (n, c) { + var i = -1; + var c2 = c; + while (++i < 6) { + c2 += n * data$1[i]; + data$1[i] = c2 % 1e7; + c2 = floor$3(c2 / 1e7); + } +}; + +var divide = function (n) { + var i = 6; + var c = 0; + while (--i >= 0) { + c += data$1[i]; + data$1[i] = floor$3(c / n); + c = (c % n) * 1e7; + } +}; + +var numToString = function () { + var i = 6; + var s = ''; + while (--i >= 0) { + if (s !== '' || i === 0 || data$1[i] !== 0) { + var t = String(data$1[i]); + s = s === '' ? t : s + stringRepeat.call('0', 7 - t.length) + t; + } + } return s; +}; + +var pow = function (x, n, acc) { + return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc); +}; + +var log = function (x) { + var n = 0; + var x2 = x; + while (x2 >= 4096) { + n += 12; + x2 /= 4096; + } + while (x2 >= 2) { + n += 1; + x2 /= 2; + } return n; +}; + +var FORCED$9 = nativeToFixed && ( + 0.00008.toFixed(3) !== '0.000' || + 0.9.toFixed(0) !== '1' || + 1.255.toFixed(2) !== '1.25' || + 1000000000000000128.0.toFixed(0) !== '1000000000000000128' +) || !fails(function () { + // V8 ~ Android 4.3- + nativeToFixed.call({}); +}); + +// `Number.prototype.toFixed` method +// https://tc39.github.io/ecma262/#sec-number.prototype.tofixed +_export({ target: 'Number', proto: true, forced: FORCED$9 }, { + toFixed: function toFixed(fractionDigits) { + var x = thisNumberValue(this); + var f = toInteger(fractionDigits); + var s = ''; + var m = '0'; + var e, z, j, k; + if (f < 0 || f > 20) throw RangeError('Incorrect fraction digits'); + // eslint-disable-next-line no-self-compare + if (x != x) return 'NaN'; + if (x <= -1e21 || x >= 1e21) return String(x); + if (x < 0) { + s = '-'; + x = -x; + } + if (x > 1e-21) { + e = log(x * pow(2, 69, 1)) - 69; + z = e < 0 ? x * pow(2, -e, 1) : x / pow(2, e, 1); + z *= 0x10000000000000; + e = 52 - e; + if (e > 0) { + multiply(0, z); + j = f; + while (j >= 7) { + multiply(1e7, 0); + j -= 7; + } + multiply(pow(10, j, 1), 0); + j = e - 1; + while (j >= 23) { + divide(1 << 23); + j -= 23; + } + divide(1 << j); + multiply(1, 1); + divide(2); + m = numToString(); + } else { + multiply(0, z); + multiply(1 << -e, 0); + m = numToString() + stringRepeat.call('0', f); + } + } + if (f > 0) { + k = m.length; + m = s + (k <= f ? '0.' + stringRepeat.call('0', f - k) + m : m.slice(0, k - f) + '.' + m.slice(k - f)); + } else { + m = s + m; + } return m; + } +}); + +var nativeToPrecision = 1.0.toPrecision; + +var FORCED$a = fails(function () { + // IE7- + return nativeToPrecision.call(1, undefined) !== '1'; +}) || !fails(function () { + // V8 ~ Android 4.3- + nativeToPrecision.call({}); +}); + +// `Number.prototype.toPrecision` method +// https://tc39.github.io/ecma262/#sec-number.prototype.toprecision +_export({ target: 'Number', proto: true, forced: FORCED$a }, { + toPrecision: function toPrecision(precision) { + return precision === undefined + ? nativeToPrecision.call(thisNumberValue(this)) + : nativeToPrecision.call(thisNumberValue(this), precision); + } +}); + +// `Math.log1p` method implementation +// https://tc39.github.io/ecma262/#sec-math.log1p +var mathLog1p = Math.log1p || function log1p(x) { + return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : Math.log(1 + x); +}; + +var nativeAcosh = Math.acosh; +var log$1 = Math.log; +var sqrt = Math.sqrt; +var LN2 = Math.LN2; + +var FORCED$b = !nativeAcosh + // V8 bug: https://code.google.com/p/v8/issues/detail?id=3509 + || Math.floor(nativeAcosh(Number.MAX_VALUE)) != 710 + // Tor Browser bug: Math.acosh(Infinity) -> NaN + || nativeAcosh(Infinity) != Infinity; + +// `Math.acosh` method +// https://tc39.github.io/ecma262/#sec-math.acosh +_export({ target: 'Math', stat: true, forced: FORCED$b }, { + acosh: function acosh(x) { + return (x = +x) < 1 ? NaN : x > 94906265.62425156 + ? log$1(x) + LN2 + : mathLog1p(x - 1 + sqrt(x - 1) * sqrt(x + 1)); + } +}); + +var nativeAsinh = Math.asinh; +var log$2 = Math.log; +var sqrt$1 = Math.sqrt; + +function asinh(x) { + return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : log$2(x + sqrt$1(x * x + 1)); +} + +// `Math.asinh` method +// https://tc39.github.io/ecma262/#sec-math.asinh +// Tor Browser bug: Math.asinh(0) -> -0 +_export({ target: 'Math', stat: true, forced: !(nativeAsinh && 1 / nativeAsinh(0) > 0) }, { + asinh: asinh +}); + +var nativeAtanh = Math.atanh; +var log$3 = Math.log; + +// `Math.atanh` method +// https://tc39.github.io/ecma262/#sec-math.atanh +// Tor Browser bug: Math.atanh(-0) -> 0 +_export({ target: 'Math', stat: true, forced: !(nativeAtanh && 1 / nativeAtanh(-0) < 0) }, { + atanh: function atanh(x) { + return (x = +x) == 0 ? x : log$3((1 + x) / (1 - x)) / 2; + } +}); + +// `Math.sign` method implementation +// https://tc39.github.io/ecma262/#sec-math.sign +var mathSign = Math.sign || function sign(x) { + // eslint-disable-next-line no-self-compare + return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1; +}; + +var abs$1 = Math.abs; +var pow$1 = Math.pow; + +// `Math.cbrt` method +// https://tc39.github.io/ecma262/#sec-math.cbrt +_export({ target: 'Math', stat: true }, { + cbrt: function cbrt(x) { + return mathSign(x = +x) * pow$1(abs$1(x), 1 / 3); + } +}); + +var floor$4 = Math.floor; +var log$4 = Math.log; +var LOG2E = Math.LOG2E; + +// `Math.clz32` method +// https://tc39.github.io/ecma262/#sec-math.clz32 +_export({ target: 'Math', stat: true }, { + clz32: function clz32(x) { + return (x >>>= 0) ? 31 - floor$4(log$4(x + 0.5) * LOG2E) : 32; + } +}); + +var nativeExpm1 = Math.expm1; + +// `Math.expm1` method implementation +// https://tc39.github.io/ecma262/#sec-math.expm1 +var mathExpm1 = (!nativeExpm1 + // Old FF bug + || nativeExpm1(10) > 22025.465794806719 || nativeExpm1(10) < 22025.4657948067165168 + // Tor Browser bug + || nativeExpm1(-2e-17) != -2e-17 +) ? function expm1(x) { + return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1; +} : nativeExpm1; + +var nativeCosh = Math.cosh; +var abs$2 = Math.abs; +var E = Math.E; + +// `Math.cosh` method +// https://tc39.github.io/ecma262/#sec-math.cosh +_export({ target: 'Math', stat: true, forced: !nativeCosh || nativeCosh(710) === Infinity }, { + cosh: function cosh(x) { + var t = mathExpm1(abs$2(x) - 1) + 1; + return (t + 1 / (t * E * E)) * (E / 2); + } +}); + +// `Math.expm1` method +// https://tc39.github.io/ecma262/#sec-math.expm1 +_export({ target: 'Math', stat: true, forced: mathExpm1 != Math.expm1 }, { expm1: mathExpm1 }); + +var pow$2 = Math.pow; +var EPSILON = pow$2(2, -52); +var EPSILON32 = pow$2(2, -23); +var MAX32 = pow$2(2, 127) * (2 - EPSILON32); +var MIN32 = pow$2(2, -126); + +var roundTiesToEven = function (n) { + return n + 1 / EPSILON - 1 / EPSILON; +}; + +// `Math.fround` method implementation +// https://tc39.github.io/ecma262/#sec-math.fround +var mathFround = Math.fround || function fround(x) { + var $abs = Math.abs(x); + var $sign = mathSign(x); + var a, result; + if ($abs < MIN32) return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32; + a = (1 + EPSILON32 / EPSILON) * $abs; + result = a - (a - $abs); + // eslint-disable-next-line no-self-compare + if (result > MAX32 || result != result) return $sign * Infinity; + return $sign * result; +}; + +// `Math.fround` method +// https://tc39.github.io/ecma262/#sec-math.fround +_export({ target: 'Math', stat: true }, { fround: mathFround }); + +var abs$3 = Math.abs; +var sqrt$2 = Math.sqrt; + +// `Math.hypot` method +// https://tc39.github.io/ecma262/#sec-math.hypot +_export({ target: 'Math', stat: true }, { + hypot: function hypot(value1, value2) { // eslint-disable-line no-unused-vars + var sum = 0; + var i = 0; + var aLen = arguments.length; + var larg = 0; + var arg, div; + while (i < aLen) { + arg = abs$3(arguments[i++]); + if (larg < arg) { + div = larg / arg; + sum = sum * div * div + 1; + larg = arg; + } else if (arg > 0) { + div = arg / larg; + sum += div * div; + } else sum += arg; + } + return larg === Infinity ? Infinity : larg * sqrt$2(sum); + } +}); + +var nativeImul = Math.imul; + +var FORCED$c = fails(function () { + return nativeImul(0xFFFFFFFF, 5) != -5 || nativeImul.length != 2; +}); + +// `Math.imul` method +// https://tc39.github.io/ecma262/#sec-math.imul +// some WebKit versions fails with big numbers, some has wrong arity +_export({ target: 'Math', stat: true, forced: FORCED$c }, { + imul: function imul(x, y) { + var UINT16 = 0xFFFF; + var xn = +x; + var yn = +y; + var xl = UINT16 & xn; + var yl = UINT16 & yn; + return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0); + } +}); + +var log$5 = Math.log; +var LOG10E = Math.LOG10E; + +// `Math.log10` method +// https://tc39.github.io/ecma262/#sec-math.log10 +_export({ target: 'Math', stat: true }, { + log10: function log10(x) { + return log$5(x) * LOG10E; + } +}); + +// `Math.log1p` method +// https://tc39.github.io/ecma262/#sec-math.log1p +_export({ target: 'Math', stat: true }, { log1p: mathLog1p }); + +var log$6 = Math.log; +var LN2$1 = Math.LN2; + +// `Math.log2` method +// https://tc39.github.io/ecma262/#sec-math.log2 +_export({ target: 'Math', stat: true }, { + log2: function log2(x) { + return log$6(x) / LN2$1; + } +}); + +// `Math.sign` method +// https://tc39.github.io/ecma262/#sec-math.sign +_export({ target: 'Math', stat: true }, { + sign: mathSign +}); + +var abs$4 = Math.abs; +var exp = Math.exp; +var E$1 = Math.E; + +var FORCED$d = fails(function () { + return Math.sinh(-2e-17) != -2e-17; +}); + +// `Math.sinh` method +// https://tc39.github.io/ecma262/#sec-math.sinh +// V8 near Chromium 38 has a problem with very small numbers +_export({ target: 'Math', stat: true, forced: FORCED$d }, { + sinh: function sinh(x) { + return abs$4(x = +x) < 1 ? (mathExpm1(x) - mathExpm1(-x)) / 2 : (exp(x - 1) - exp(-x - 1)) * (E$1 / 2); + } +}); + +var exp$1 = Math.exp; + +// `Math.tanh` method +// https://tc39.github.io/ecma262/#sec-math.tanh +_export({ target: 'Math', stat: true }, { + tanh: function tanh(x) { + var a = mathExpm1(x = +x); + var b = mathExpm1(-x); + return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp$1(x) + exp$1(-x)); + } +}); + +// Math[@@toStringTag] property +// https://tc39.github.io/ecma262/#sec-math-@@tostringtag +setToStringTag(Math, 'Math', true); + +var ceil$1 = Math.ceil; +var floor$5 = Math.floor; + +// `Math.trunc` method +// https://tc39.github.io/ecma262/#sec-math.trunc +_export({ target: 'Math', stat: true }, { + trunc: function trunc(it) { + return (it > 0 ? floor$5 : ceil$1)(it); + } +}); + +// `Date.now` method +// https://tc39.github.io/ecma262/#sec-date.now +_export({ target: 'Date', stat: true }, { + now: function now() { + return new Date().getTime(); + } +}); + +var FORCED$e = fails(function () { + return new Date(NaN).toJSON() !== null + || Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) !== 1; +}); + +// `Date.prototype.toJSON` method +// https://tc39.github.io/ecma262/#sec-date.prototype.tojson +_export({ target: 'Date', proto: true, forced: FORCED$e }, { + // eslint-disable-next-line no-unused-vars + toJSON: function toJSON(key) { + var O = toObject(this); + var pv = toPrimitive(O); + return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString(); + } +}); + +var prototype = Date.prototype; +var getTime = prototype.getTime; +var nativeDateToISOString = prototype.toISOString; + +var leadingZero = function (number) { + return number > 9 ? number : '0' + number; +}; + +// `Date.prototype.toISOString` method implementation +// https://tc39.github.io/ecma262/#sec-date.prototype.toisostring +// PhantomJS / old WebKit fails here: +var dateToIsoString = (fails(function () { + return nativeDateToISOString.call(new Date(-5e13 - 1)) != '0385-07-25T07:06:39.999Z'; +}) || !fails(function () { + nativeDateToISOString.call(new Date(NaN)); +})) ? function toISOString() { + if (!isFinite(getTime.call(this))) throw RangeError('Invalid time value'); + var date = this; + var year = date.getUTCFullYear(); + var milliseconds = date.getUTCMilliseconds(); + var sign = year < 0 ? '-' : year > 9999 ? '+' : ''; + return sign + ('00000' + Math.abs(year)).slice(sign ? -6 : -4) + + '-' + leadingZero(date.getUTCMonth() + 1) + + '-' + leadingZero(date.getUTCDate()) + + 'T' + leadingZero(date.getUTCHours()) + + ':' + leadingZero(date.getUTCMinutes()) + + ':' + leadingZero(date.getUTCSeconds()) + + '.' + (milliseconds > 99 ? milliseconds : '0' + leadingZero(milliseconds)) + + 'Z'; +} : nativeDateToISOString; + +// `Date.prototype.toISOString` method +// https://tc39.github.io/ecma262/#sec-date.prototype.toisostring +// PhantomJS / old WebKit has a broken implementations +_export({ target: 'Date', proto: true, forced: Date.prototype.toISOString !== dateToIsoString }, { + toISOString: dateToIsoString +}); + +var DatePrototype = Date.prototype; +var INVALID_DATE = 'Invalid Date'; +var TO_STRING$1 = 'toString'; +var nativeDateToString = DatePrototype[TO_STRING$1]; +var getTime$1 = DatePrototype.getTime; + +// `Date.prototype.toString` method +// https://tc39.github.io/ecma262/#sec-date.prototype.tostring +if (new Date(NaN) + '' != INVALID_DATE) { + redefine(DatePrototype, TO_STRING$1, function toString() { + var value = getTime$1.call(this); + // eslint-disable-next-line no-self-compare + return value === value ? nativeDateToString.call(this) : INVALID_DATE; + }); +} + +var dateToPrimitive = function (hint) { + if (hint !== 'string' && hint !== 'number' && hint !== 'default') { + throw TypeError('Incorrect hint'); + } return toPrimitive(anObject(this), hint !== 'number'); +}; + +var TO_PRIMITIVE$1 = wellKnownSymbol('toPrimitive'); +var DatePrototype$1 = Date.prototype; + +// `Date.prototype[@@toPrimitive]` method +// https://tc39.github.io/ecma262/#sec-date.prototype-@@toprimitive +if (!(TO_PRIMITIVE$1 in DatePrototype$1)) hide(DatePrototype$1, TO_PRIMITIVE$1, dateToPrimitive); + +// JSON[@@toStringTag] property +// https://tc39.github.io/ecma262/#sec-json-@@tostringtag +setToStringTag(global_1.JSON, 'JSON', true); + +var redefineAll = function (target, src, options) { + for (var key in src) redefine(target, key, src[key], options); + return target; +}; + +var anInstance = function (it, Constructor, name) { + if (!(it instanceof Constructor)) { + throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation'); + } return it; +}; + +var location = global_1.location; +var set$1 = global_1.setImmediate; +var clear = global_1.clearImmediate; +var process = global_1.process; +var MessageChannel = global_1.MessageChannel; +var Dispatch = global_1.Dispatch; +var counter = 0; +var queue = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var defer, channel, port; + +var run = function (id) { + // eslint-disable-next-line no-prototype-builtins + if (queue.hasOwnProperty(id)) { + var fn = queue[id]; + delete queue[id]; + fn(); + } +}; + +var runner = function (id) { + return function () { + run(id); + }; +}; + +var listener = function (event) { + run(event.data); +}; + +var post = function (id) { + // old engines have not location.origin + global_1.postMessage(id + '', location.protocol + '//' + location.host); +}; + +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if (!set$1 || !clear) { + set$1 = function setImmediate(fn) { + var args = []; + var i = 1; + while (arguments.length > i) args.push(arguments[i++]); + queue[++counter] = function () { + // eslint-disable-next-line no-new-func + (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue[id]; + }; + // Node.js 0.8- + if (classofRaw(process) == 'process') { + defer = function (id) { + process.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + } else if (MessageChannel) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = listener; + defer = bindContext(port.postMessage, port, 1); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if (global_1.addEventListener && typeof postMessage == 'function' && !global_1.importScripts && !fails(post)) { + defer = post; + global_1.addEventListener('message', listener, false); + // IE8- + } else if (ONREADYSTATECHANGE in documentCreateElement('script')) { + defer = function (id) { + html.appendChild(documentCreateElement('script'))[ONREADYSTATECHANGE] = function () { + html.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } +} + +var task = { + set: set$1, + clear: clear +}; + +var getOwnPropertyDescriptor$5 = objectGetOwnPropertyDescriptor.f; + +var macrotask = task.set; + + +var MutationObserver = global_1.MutationObserver || global_1.WebKitMutationObserver; +var process$1 = global_1.process; +var Promise = global_1.Promise; +var IS_NODE = classofRaw(process$1) == 'process'; +// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` +var queueMicrotaskDescriptor = getOwnPropertyDescriptor$5(global_1, 'queueMicrotask'); +var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; + +var flush, head, last, notify, toggle, node, promise; + +// modern engines have queueMicrotask method +if (!queueMicrotask) { + flush = function () { + var parent, fn; + if (IS_NODE && (parent = process$1.domain)) parent.exit(); + while (head) { + fn = head.fn; + head = head.next; + try { + fn(); + } catch (error) { + if (head) notify(); + else last = undefined; + throw error; + } + } last = undefined; + if (parent) parent.enter(); + }; + + // Node.js + if (IS_NODE) { + notify = function () { + process$1.nextTick(flush); + }; + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + } else if (MutationObserver && !/(iphone|ipod|ipad).*applewebkit/i.test(userAgent)) { + toggle = true; + node = document.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); // eslint-disable-line no-new + notify = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (Promise && Promise.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise.resolve(undefined); + notify = function () { + promise.then(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessag + // - onreadystatechange + // - setTimeout + } else { + notify = function () { + // strange IE + webpack dev server bug - use .call(global) + macrotask.call(global_1, flush); + }; + } +} + +var microtask = queueMicrotask || function (fn) { + var task = { fn: fn, next: undefined }; + if (last) last.next = task; + if (!head) { + head = task; + notify(); + } last = task; +}; + +var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aFunction(resolve); + this.reject = aFunction(reject); +}; + +// 25.4.1.5 NewPromiseCapability(C) +var f$7 = function (C) { + return new PromiseCapability(C); +}; + +var newPromiseCapability = { + f: f$7 +}; + +var promiseResolve = function (C, x) { + anObject(C); + if (isObject(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; +}; + +var hostReportErrors = function (a, b) { + var console = global_1.console; + if (console && console.error) { + arguments.length === 1 ? console.error(a) : console.error(a, b); + } +}; + +var perform = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } +}; + +var task$1 = task.set; + + + + + + + + + + +var SPECIES$6 = wellKnownSymbol('species'); +var PROMISE = 'Promise'; +var getInternalState$4 = internalState.get; +var setInternalState$4 = internalState.set; +var getInternalPromiseState = internalState.getterFor(PROMISE); +var PromiseConstructor = global_1[PROMISE]; +var TypeError$1 = global_1.TypeError; +var document$3 = global_1.document; +var process$2 = global_1.process; +var $fetch = global_1.fetch; +var versions = process$2 && process$2.versions; +var v8 = versions && versions.v8 || ''; +var newPromiseCapability$1 = newPromiseCapability.f; +var newGenericPromiseCapability = newPromiseCapability$1; +var IS_NODE$1 = classofRaw(process$2) == 'process'; +var DISPATCH_EVENT = !!(document$3 && document$3.createEvent && global_1.dispatchEvent); +var UNHANDLED_REJECTION = 'unhandledrejection'; +var REJECTION_HANDLED = 'rejectionhandled'; +var PENDING = 0; +var FULFILLED = 1; +var REJECTED = 2; +var HANDLED = 1; +var UNHANDLED = 2; +var Internal, OwnPromiseCapability, PromiseWrapper; + +var FORCED$f = isForced_1(PROMISE, function () { + // correct subclassing with @@species support + var promise = PromiseConstructor.resolve(1); + var empty = function () { /* empty */ }; + var FakePromise = (promise.constructor = {})[SPECIES$6] = function (exec) { + exec(empty, empty); + }; + // unhandled rejections tracking support, NodeJS Promise without it fails @@species test + return !((IS_NODE$1 || typeof PromiseRejectionEvent == 'function') + && (!isPure || promise['finally']) + && promise.then(empty) instanceof FakePromise + // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // we can't detect it synchronously, so just check versions + && v8.indexOf('6.6') !== 0 + && userAgent.indexOf('Chrome/66') === -1); +}); + +var INCORRECT_ITERATION$1 = FORCED$f || !checkCorrectnessOfIteration(function (iterable) { + PromiseConstructor.all(iterable)['catch'](function () { /* empty */ }); +}); + +// helpers +var isThenable = function (it) { + var then; + return isObject(it) && typeof (then = it.then) == 'function' ? then : false; +}; + +var notify$1 = function (promise, state, isReject) { + if (state.notified) return; + state.notified = true; + var chain = state.reactions; + microtask(function () { + var value = state.value; + var ok = state.state == FULFILLED; + var i = 0; + var run = function (reaction) { + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(promise, state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // may throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(TypeError$1('Promise-chain cycle')); + } else if (then = isThenable(result)) { + then.call(result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } + }; + while (chain.length > i) run(chain[i++]); // variable length - can't use forEach + state.reactions = []; + state.notified = false; + if (isReject && !state.rejection) onUnhandled(promise, state); + }); +}; + +var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document$3.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global_1.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (handler = global_1['on' + name]) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); +}; + +var onUnhandled = function (promise, state) { + task$1.call(global_1, function () { + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform(function () { + if (IS_NODE$1) { + process$2.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE$1 || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); +}; + +var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; +}; + +var onHandleUnhandled = function (promise, state) { + task$1.call(global_1, function () { + if (IS_NODE$1) { + process$2.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); +}; + +var bind = function (fn, promise, state, unwrap) { + return function (value) { + fn(promise, state, value, unwrap); + }; +}; + +var internalReject = function (promise, state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify$1(promise, state, true); +}; + +var internalResolve = function (promise, state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (promise === value) throw TypeError$1("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + then.call(value, + bind(internalResolve, promise, wrapper, state), + bind(internalReject, promise, wrapper, state) + ); + } catch (error) { + internalReject(promise, wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify$1(promise, state, false); + } + } catch (error) { + internalReject(promise, { done: false }, error, state); + } +}; + +// constructor polyfill +if (FORCED$f) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance(this, PromiseConstructor, PROMISE); + aFunction(executor); + Internal.call(this); + var state = getInternalState$4(this); + try { + executor(bind(internalResolve, this, state), bind(internalReject, this, state)); + } catch (error) { + internalReject(this, state, error); + } + }; + // eslint-disable-next-line no-unused-vars + Internal = function Promise(executor) { + setInternalState$4(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: [], + rejection: false, + state: PENDING, + value: undefined + }); + }; + Internal.prototype = redefineAll(PromiseConstructor.prototype, { + // `Promise.prototype.then` method + // https://tc39.github.io/ecma262/#sec-promise.prototype.then + then: function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor)); + reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true; + reaction.fail = typeof onRejected == 'function' && onRejected; + reaction.domain = IS_NODE$1 ? process$2.domain : undefined; + state.parent = true; + state.reactions.push(reaction); + if (state.state != PENDING) notify$1(this, state, false); + return reaction.promise; + }, + // `Promise.prototype.catch` method + // https://tc39.github.io/ecma262/#sec-promise.prototype.catch + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } + }); + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalState$4(promise); + this.promise = promise; + this.resolve = bind(internalResolve, promise, state); + this.reject = bind(internalReject, promise, state); + }; + newPromiseCapability.f = newPromiseCapability$1 = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + // wrap fetch result + if (typeof $fetch == 'function') _export({ global: true, enumerable: true, forced: true }, { + // eslint-disable-next-line no-unused-vars + fetch: function fetch(input) { + return promiseResolve(PromiseConstructor, $fetch.apply(global_1, arguments)); + } + }); +} + +_export({ global: true, wrap: true, forced: FORCED$f }, { + Promise: PromiseConstructor +}); + +setToStringTag(PromiseConstructor, PROMISE, false); +setSpecies(PROMISE); + +PromiseWrapper = path[PROMISE]; + +// statics +_export({ target: PROMISE, stat: true, forced: FORCED$f }, { + // `Promise.reject` method + // https://tc39.github.io/ecma262/#sec-promise.reject + reject: function reject(r) { + var capability = newPromiseCapability$1(this); + capability.reject.call(undefined, r); + return capability.promise; + } +}); + +_export({ target: PROMISE, stat: true, forced: FORCED$f }, { + // `Promise.resolve` method + // https://tc39.github.io/ecma262/#sec-promise.resolve + resolve: function resolve(x) { + return promiseResolve(this, x); + } +}); + +_export({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION$1 }, { + // `Promise.all` method + // https://tc39.github.io/ecma262/#sec-promise.all + all: function all(iterable) { + var C = this; + var capability = newPromiseCapability$1(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aFunction(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + values.push(undefined); + remaining++; + $promiseResolve.call(C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + }, + // `Promise.race` method + // https://tc39.github.io/ecma262/#sec-promise.race + race: function race(iterable) { + var C = this; + var capability = newPromiseCapability$1(C); + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aFunction(C.resolve); + iterate(iterable, function (promise) { + $promiseResolve.call(C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +// `Promise.prototype.finally` method +// https://tc39.github.io/ecma262/#sec-promise.prototype.finally +_export({ target: 'Promise', proto: true, real: true }, { + 'finally': function (onFinally) { + var C = speciesConstructor(this, getBuiltIn('Promise')); + var isFunction = typeof onFinally == 'function'; + return this.then( + isFunction ? function (x) { + return promiseResolve(C, onFinally()).then(function () { return x; }); + } : onFinally, + isFunction ? function (e) { + return promiseResolve(C, onFinally()).then(function () { throw e; }); + } : onFinally + ); + } +}); + +var collection = function (CONSTRUCTOR_NAME, wrapper, common, IS_MAP, IS_WEAK) { + var NativeConstructor = global_1[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var ADDER = IS_MAP ? 'set' : 'add'; + var exported = {}; + + var fixMethod = function (KEY) { + var nativeMethod = NativePrototype[KEY]; + redefine(NativePrototype, KEY, + KEY == 'add' ? function add(a) { + nativeMethod.call(this, a === 0 ? 0 : a); + return this; + } : KEY == 'delete' ? function (a) { + return IS_WEAK && !isObject(a) ? false : nativeMethod.call(this, a === 0 ? 0 : a); + } : KEY == 'get' ? function get(a) { + return IS_WEAK && !isObject(a) ? undefined : nativeMethod.call(this, a === 0 ? 0 : a); + } : KEY == 'has' ? function has(a) { + return IS_WEAK && !isObject(a) ? false : nativeMethod.call(this, a === 0 ? 0 : a); + } : function set(a, b) { + nativeMethod.call(this, a === 0 ? 0 : a, b); + return this; + } + ); + }; + + // eslint-disable-next-line max-len + if (isForced_1(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () { + new NativeConstructor().entries().next(); + })))) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + internalMetadata.REQUIRED = true; + } else if (isForced_1(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (target, iterable) { + anInstance(target, Constructor, CONSTRUCTOR_NAME); + var that = inheritIfRequired(new NativeConstructor(), target, Constructor); + if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + _export({ global: true, forced: Constructor != NativeConstructor }, exported); + + setToStringTag(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; +}; + +var defineProperty$6 = objectDefineProperty.f; + + + + + + + + +var fastKey = internalMetadata.fastKey; + + +var setInternalState$5 = internalState.set; +var internalStateGetterFor = internalState.getterFor; + +var collectionStrong = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var C = wrapper(function (that, iterable) { + anInstance(that, C, CONSTRUCTOR_NAME); + setInternalState$5(that, { + type: CONSTRUCTOR_NAME, + index: objectCreate(null), + first: undefined, + last: undefined, + size: 0 + }); + if (!descriptors) that.size = 0; + if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP); + }); + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var entry = getEntry(that, key); + var previous, index; + // change existing entry + if (entry) { + entry.value = value; + // create new entry + } else { + state.last = entry = { + index: index = fastKey(key, true), + key: key, + value: value, + previous: previous = state.last, + next: undefined, + removed: false + }; + if (!state.first) state.first = entry; + if (previous) previous.next = entry; + if (descriptors) state.size++; + else that.size++; + // add to index + if (index !== 'F') state.index[index] = entry; + } return that; + }; + + var getEntry = function (that, key) { + var state = getInternalState(that); + // fast case + var index = fastKey(key); + var entry; + if (index !== 'F') return state.index[index]; + // frozen object case + for (entry = state.first; entry; entry = entry.next) { + if (entry.key == key) return entry; + } + }; + + redefineAll(C.prototype, { + // 23.1.3.1 Map.prototype.clear() + // 23.2.3.2 Set.prototype.clear() + clear: function clear() { + var that = this; + var state = getInternalState(that); + var data = state.index; + var entry = state.first; + while (entry) { + entry.removed = true; + if (entry.previous) entry.previous = entry.previous.next = undefined; + delete data[entry.index]; + entry = entry.next; + } + state.first = state.last = undefined; + if (descriptors) state.size = 0; + else that.size = 0; + }, + // 23.1.3.3 Map.prototype.delete(key) + // 23.2.3.4 Set.prototype.delete(value) + 'delete': function (key) { + var that = this; + var state = getInternalState(that); + var entry = getEntry(that, key); + if (entry) { + var next = entry.next; + var prev = entry.previous; + delete state.index[entry.index]; + entry.removed = true; + if (prev) prev.next = next; + if (next) next.previous = prev; + if (state.first == entry) state.first = next; + if (state.last == entry) state.last = prev; + if (descriptors) state.size--; + else that.size--; + } return !!entry; + }, + // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined) + // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined) + forEach: function forEach(callbackfn /* , that = undefined */) { + var state = getInternalState(this); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var entry; + while (entry = entry ? entry.next : state.first) { + boundFunction(entry.value, entry.key, this); + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + } + }, + // 23.1.3.7 Map.prototype.has(key) + // 23.2.3.7 Set.prototype.has(value) + has: function has(key) { + return !!getEntry(this, key); + } + }); + + redefineAll(C.prototype, IS_MAP ? { + // 23.1.3.6 Map.prototype.get(key) + get: function get(key) { + var entry = getEntry(this, key); + return entry && entry.value; + }, + // 23.1.3.9 Map.prototype.set(key, value) + set: function set(key, value) { + return define(this, key === 0 ? 0 : key, value); + } + } : { + // 23.2.3.1 Set.prototype.add(value) + add: function add(value) { + return define(this, value = value === 0 ? 0 : value, value); + } + }); + if (descriptors) defineProperty$6(C.prototype, 'size', { + get: function () { + return getInternalState(this).size; + } + }); + return C; + }, + setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) { + var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; + var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); + var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); + // add .keys, .values, .entries, [@@iterator] + // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11 + defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) { + setInternalState$5(this, { + type: ITERATOR_NAME, + target: iterated, + state: getInternalCollectionState(iterated), + kind: kind, + last: undefined + }); + }, function () { + var state = getInternalIteratorState(this); + var kind = state.kind; + var entry = state.last; + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + // get next entry + if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { + // or finish the iteration + state.target = undefined; + return { value: undefined, done: true }; + } + // return step by kind + if (kind == 'keys') return { value: entry.key, done: false }; + if (kind == 'values') return { value: entry.value, done: false }; + return { value: [entry.key, entry.value], done: false }; + }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); + + // add [@@species], 23.1.2.2, 23.2.2.2 + setSpecies(CONSTRUCTOR_NAME); + } +}; + +// `Map` constructor +// https://tc39.github.io/ecma262/#sec-map-objects +var es_map = collection('Map', function (get) { + return function Map() { return get(this, arguments.length > 0 ? arguments[0] : undefined); }; +}, collectionStrong, true); + +// `Set` constructor +// https://tc39.github.io/ecma262/#sec-set-objects +var es_set = collection('Set', function (get) { + return function Set() { return get(this, arguments.length > 0 ? arguments[0] : undefined); }; +}, collectionStrong); + +var getWeakData = internalMetadata.getWeakData; + + + + + + + + +var setInternalState$6 = internalState.set; +var internalStateGetterFor$1 = internalState.getterFor; +var arrayFind = arrayMethods(5); +var arrayFindIndex = arrayMethods(6); +var id$1 = 0; + +// fallback for uncaught frozen keys +var uncaughtFrozenStore = function (store) { + return store.frozen || (store.frozen = new UncaughtFrozenStore()); +}; + +var UncaughtFrozenStore = function () { + this.entries = []; +}; + +var findUncaughtFrozen = function (store, key) { + return arrayFind(store.entries, function (it) { + return it[0] === key; + }); +}; + +UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = arrayFindIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) this.entries.splice(index, 1); + return !!~index; + } +}; + +var collectionWeak = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var C = wrapper(function (that, iterable) { + anInstance(that, C, CONSTRUCTOR_NAME); + setInternalState$6(that, { + type: CONSTRUCTOR_NAME, + id: id$1++, + frozen: undefined + }); + if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP); + }); + + var getInternalState = internalStateGetterFor$1(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + redefineAll(C.prototype, { + // 23.3.3.2 WeakMap.prototype.delete(key) + // 23.4.3.3 WeakSet.prototype.delete(value) + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && has(data, state.id) && delete data[state.id]; + }, + // 23.3.3.4 WeakMap.prototype.has(key) + // 23.4.3.4 WeakSet.prototype.has(value) + has: function has$1(key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && has(data, state.id); + } + }); + + redefineAll(C.prototype, IS_MAP ? { + // 23.3.3.3 WeakMap.prototype.get(key) + get: function get(key) { + var state = getInternalState(this); + if (isObject(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // 23.3.3.5 WeakMap.prototype.set(key, value) + set: function set(key, value) { + return define(this, key, value); + } + } : { + // 23.4.3.1 WeakSet.prototype.add(value) + add: function add(value) { + return define(this, value, true); + } + }); + + return C; + } +}; + +var es_weakMap = createCommonjsModule(function (module) { + + + + + + +var enforceIternalState = internalState.enforce; + + +var IS_IE11 = !global_1.ActiveXObject && 'ActiveXObject' in global_1; +var isExtensible = Object.isExtensible; +var InternalWeakMap; + +var wrapper = function (get) { + return function WeakMap() { + return get(this, arguments.length > 0 ? arguments[0] : undefined); + }; +}; + +// `WeakMap` constructor +// https://tc39.github.io/ecma262/#sec-weakmap-constructor +var $WeakMap = module.exports = collection('WeakMap', wrapper, collectionWeak, true, true); + +// IE11 WeakMap frozen keys fix +// We can't use feature detection because it crash some old IE builds +// https://github.com/zloirock/core-js/issues/485 +if (nativeWeakMap && IS_IE11) { + InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true); + internalMetadata.REQUIRED = true; + var WeakMapPrototype = $WeakMap.prototype; + var nativeDelete = WeakMapPrototype['delete']; + var nativeHas = WeakMapPrototype.has; + var nativeGet = WeakMapPrototype.get; + var nativeSet = WeakMapPrototype.set; + redefineAll(WeakMapPrototype, { + 'delete': function (key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeDelete.call(this, key) || state.frozen['delete'](key); + } return nativeDelete.call(this, key); + }, + has: function has(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeHas.call(this, key) || state.frozen.has(key); + } return nativeHas.call(this, key); + }, + get: function get(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeHas.call(this, key) ? nativeGet.call(this, key) : state.frozen.get(key); + } return nativeGet.call(this, key); + }, + set: function set(key, value) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + nativeHas.call(this, key) ? nativeSet.call(this, key, value) : state.frozen.set(key, value); + } else nativeSet.call(this, key, value); + return this; + } + }); +} +}); + +// `WeakSet` constructor +// https://tc39.github.io/ecma262/#sec-weakset-constructor +collection('WeakSet', function (get) { + return function WeakSet() { return get(this, arguments.length > 0 ? arguments[0] : undefined); }; +}, collectionWeak, false, true); + +var defineProperty$7 = objectDefineProperty.f; + + + + + +var DataView = global_1.DataView; +var DataViewPrototype = DataView && DataView.prototype; +var Int8Array$1 = global_1.Int8Array; +var Int8ArrayPrototype = Int8Array$1 && Int8Array$1.prototype; +var Uint8ClampedArray = global_1.Uint8ClampedArray; +var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype; +var TypedArray = Int8Array$1 && objectGetPrototypeOf(Int8Array$1); +var TypedArrayPrototype = Int8ArrayPrototype && objectGetPrototypeOf(Int8ArrayPrototype); +var ObjectPrototype$3 = Object.prototype; +var isPrototypeOf = ObjectPrototype$3.isPrototypeOf; + +var TO_STRING_TAG$3 = wellKnownSymbol('toStringTag'); +var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG'); +var NATIVE_ARRAY_BUFFER = !!(global_1.ArrayBuffer && global_1.DataView); +var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!objectSetPrototypeOf; +var TYPED_ARRAY_TAG_REQIRED = false; +var NAME$1; + +var TypedArrayConstructorsList = { + Int8Array: 1, + Uint8Array: 1, + Uint8ClampedArray: 1, + Int16Array: 2, + Uint16Array: 2, + Int32Array: 4, + Uint32Array: 4, + Float32Array: 4, + Float64Array: 8 +}; + +var isView = function isView(it) { + var klass = classof(it); + return klass === 'DataView' || has(TypedArrayConstructorsList, klass); +}; + +var isTypedArray = function (it) { + return isObject(it) && has(TypedArrayConstructorsList, classof(it)); +}; + +var aTypedArray = function (it) { + if (isTypedArray(it)) return it; + throw TypeError('Target is not a typed array'); +}; + +var aTypedArrayConstructor = function (C) { + if (objectSetPrototypeOf) { + if (isPrototypeOf.call(TypedArray, C)) return C; + } else for (var ARRAY in TypedArrayConstructorsList) if (has(TypedArrayConstructorsList, NAME$1)) { + var TypedArrayConstructor = global_1[ARRAY]; + if (TypedArrayConstructor && (C === TypedArrayConstructor || isPrototypeOf.call(TypedArrayConstructor, C))) { + return C; + } + } throw TypeError('Target is not a typed array constructor'); +}; + +var exportProto = function (KEY, property, forced) { + if (!descriptors) return; + if (forced) for (var ARRAY in TypedArrayConstructorsList) { + var TypedArrayConstructor = global_1[ARRAY]; + if (TypedArrayConstructor && has(TypedArrayConstructor.prototype, KEY)) { + delete TypedArrayConstructor.prototype[KEY]; + } + } + if (!TypedArrayPrototype[KEY] || forced) { + redefine(TypedArrayPrototype, KEY, forced ? property + : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property); + } +}; + +var exportStatic = function (KEY, property, forced) { + var ARRAY, TypedArrayConstructor; + if (!descriptors) return; + if (objectSetPrototypeOf) { + if (forced) for (ARRAY in TypedArrayConstructorsList) { + TypedArrayConstructor = global_1[ARRAY]; + if (TypedArrayConstructor && has(TypedArrayConstructor, KEY)) { + delete TypedArrayConstructor[KEY]; + } + } + if (!TypedArray[KEY] || forced) { + // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable + try { + return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8Array$1[KEY] || property); + } catch (error) { /* empty */ } + } else return; + } + for (ARRAY in TypedArrayConstructorsList) { + TypedArrayConstructor = global_1[ARRAY]; + if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) { + redefine(TypedArrayConstructor, KEY, property); + } + } +}; + +for (NAME$1 in TypedArrayConstructorsList) { + if (!global_1[NAME$1]) NATIVE_ARRAY_BUFFER_VIEWS = false; +} + +// WebKit bug - typed arrays constructors prototype is Object.prototype +if (!NATIVE_ARRAY_BUFFER_VIEWS || typeof TypedArray != 'function' || TypedArray === Function.prototype) { + // eslint-disable-next-line no-shadow + TypedArray = function TypedArray() { + throw TypeError('Incorrect invocation'); + }; + if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME$1 in TypedArrayConstructorsList) { + if (global_1[NAME$1]) objectSetPrototypeOf(global_1[NAME$1], TypedArray); + } +} + +if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype$3) { + TypedArrayPrototype = TypedArray.prototype; + if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME$1 in TypedArrayConstructorsList) { + if (global_1[NAME$1]) objectSetPrototypeOf(global_1[NAME$1].prototype, TypedArrayPrototype); + } +} + +// WebKit bug - one more object in Uint8ClampedArray prototype chain +if (NATIVE_ARRAY_BUFFER_VIEWS && objectGetPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) { + objectSetPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype); +} + +if (descriptors && !has(TypedArrayPrototype, TO_STRING_TAG$3)) { + TYPED_ARRAY_TAG_REQIRED = true; + defineProperty$7(TypedArrayPrototype, TO_STRING_TAG$3, { get: function () { + return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined; + } }); + for (NAME$1 in TypedArrayConstructorsList) if (global_1[NAME$1]) { + hide(global_1[NAME$1], TYPED_ARRAY_TAG, NAME$1); + } +} + +// WebKit bug - the same parent prototype for typed arrays and data view +if (NATIVE_ARRAY_BUFFER && objectSetPrototypeOf && objectGetPrototypeOf(DataViewPrototype) !== ObjectPrototype$3) { + objectSetPrototypeOf(DataViewPrototype, ObjectPrototype$3); +} + +var arrayBufferViewCore = { + NATIVE_ARRAY_BUFFER: NATIVE_ARRAY_BUFFER, + NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS, + TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQIRED && TYPED_ARRAY_TAG, + aTypedArray: aTypedArray, + aTypedArrayConstructor: aTypedArrayConstructor, + exportProto: exportProto, + exportStatic: exportStatic, + isView: isView, + isTypedArray: isTypedArray, + TypedArray: TypedArray, + TypedArrayPrototype: TypedArrayPrototype +}; + +// `ToIndex` abstract operation +// https://tc39.github.io/ecma262/#sec-toindex +var toIndex = function (it) { + if (it === undefined) return 0; + var number = toInteger(it); + var length = toLength(number); + if (number !== length) throw RangeError('Wrong length or index'); + return length; +}; + +var arrayBuffer = createCommonjsModule(function (module, exports) { + + +var NATIVE_ARRAY_BUFFER = arrayBufferViewCore.NATIVE_ARRAY_BUFFER; + + + + + + + +var getOwnPropertyNames = objectGetOwnPropertyNames.f; +var defineProperty = objectDefineProperty.f; + + + + +var getInternalState = internalState.get; +var setInternalState = internalState.set; +var ARRAY_BUFFER = 'ArrayBuffer'; +var DATA_VIEW = 'DataView'; +var PROTOTYPE = 'prototype'; +var WRONG_LENGTH = 'Wrong length'; +var WRONG_INDEX = 'Wrong index'; +var NativeArrayBuffer = global_1[ARRAY_BUFFER]; +var $ArrayBuffer = NativeArrayBuffer; +var $DataView = global_1[DATA_VIEW]; +var Math = global_1.Math; +var RangeError = global_1.RangeError; +// eslint-disable-next-line no-shadow-restricted-names +var Infinity = 1 / 0; +var abs = Math.abs; +var pow = Math.pow; +var floor = Math.floor; +var log = Math.log; +var LN2 = Math.LN2; + +// IEEE754 conversions based on https://github.com/feross/ieee754 +var packIEEE754 = function (number, mantissaLength, bytes) { + var buffer = new Array(bytes); + var exponentLength = bytes * 8 - mantissaLength - 1; + var eMax = (1 << exponentLength) - 1; + var eBias = eMax >> 1; + var rt = mantissaLength === 23 ? pow(2, -24) - pow(2, -77) : 0; + var sign = number < 0 || number === 0 && 1 / number < 0 ? 1 : 0; + var index = 0; + var exponent, mantissa, c; + number = abs(number); + // eslint-disable-next-line no-self-compare + if (number != number || number === Infinity) { + // eslint-disable-next-line no-self-compare + mantissa = number != number ? 1 : 0; + exponent = eMax; + } else { + exponent = floor(log(number) / LN2); + if (number * (c = pow(2, -exponent)) < 1) { + exponent--; + c *= 2; + } + if (exponent + eBias >= 1) { + number += rt / c; + } else { + number += rt * pow(2, 1 - eBias); + } + if (number * c >= 2) { + exponent++; + c /= 2; + } + if (exponent + eBias >= eMax) { + mantissa = 0; + exponent = eMax; + } else if (exponent + eBias >= 1) { + mantissa = (number * c - 1) * pow(2, mantissaLength); + exponent = exponent + eBias; + } else { + mantissa = number * pow(2, eBias - 1) * pow(2, mantissaLength); + exponent = 0; + } + } + for (; mantissaLength >= 8; buffer[index++] = mantissa & 255, mantissa /= 256, mantissaLength -= 8); + exponent = exponent << mantissaLength | mantissa; + exponentLength += mantissaLength; + for (; exponentLength > 0; buffer[index++] = exponent & 255, exponent /= 256, exponentLength -= 8); + buffer[--index] |= sign * 128; + return buffer; +}; + +var unpackIEEE754 = function (buffer, mantissaLength) { + var bytes = buffer.length; + var exponentLength = bytes * 8 - mantissaLength - 1; + var eMax = (1 << exponentLength) - 1; + var eBias = eMax >> 1; + var nBits = exponentLength - 7; + var index = bytes - 1; + var sign = buffer[index--]; + var exponent = sign & 127; + var mantissa; + sign >>= 7; + for (; nBits > 0; exponent = exponent * 256 + buffer[index], index--, nBits -= 8); + mantissa = exponent & (1 << -nBits) - 1; + exponent >>= -nBits; + nBits += mantissaLength; + for (; nBits > 0; mantissa = mantissa * 256 + buffer[index], index--, nBits -= 8); + if (exponent === 0) { + exponent = 1 - eBias; + } else if (exponent === eMax) { + return mantissa ? NaN : sign ? -Infinity : Infinity; + } else { + mantissa = mantissa + pow(2, mantissaLength); + exponent = exponent - eBias; + } return (sign ? -1 : 1) * mantissa * pow(2, exponent - mantissaLength); +}; + +var unpackInt32 = function (buffer) { + return buffer[3] << 24 | buffer[2] << 16 | buffer[1] << 8 | buffer[0]; +}; + +var packInt8 = function (number) { + return [number & 0xFF]; +}; + +var packInt16 = function (number) { + return [number & 0xFF, number >> 8 & 0xFF]; +}; + +var packInt32 = function (number) { + return [number & 0xFF, number >> 8 & 0xFF, number >> 16 & 0xFF, number >> 24 & 0xFF]; +}; + +var packFloat32 = function (number) { + return packIEEE754(number, 23, 4); +}; + +var packFloat64 = function (number) { + return packIEEE754(number, 52, 8); +}; + +var addGetter = function (Constructor, key) { + defineProperty(Constructor[PROTOTYPE], key, { get: function () { return getInternalState(this)[key]; } }); +}; + +var get = function (view, count, index, isLittleEndian) { + var numIndex = +index; + var intIndex = toIndex(numIndex); + var store = getInternalState(view); + if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX); + var bytes = getInternalState(store.buffer).bytes; + var start = intIndex + store.byteOffset; + var pack = bytes.slice(start, start + count); + return isLittleEndian ? pack : pack.reverse(); +}; + +var set = function (view, count, index, conversion, value, isLittleEndian) { + var numIndex = +index; + var intIndex = toIndex(numIndex); + var store = getInternalState(view); + if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX); + var bytes = getInternalState(store.buffer).bytes; + var start = intIndex + store.byteOffset; + var pack = conversion(+value); + for (var i = 0; i < count; i++) bytes[start + i] = pack[isLittleEndian ? i : count - i - 1]; +}; + +if (!NATIVE_ARRAY_BUFFER) { + $ArrayBuffer = function ArrayBuffer(length) { + anInstance(this, $ArrayBuffer, ARRAY_BUFFER); + var byteLength = toIndex(length); + setInternalState(this, { + bytes: arrayFill.call(new Array(byteLength), 0), + byteLength: byteLength + }); + if (!descriptors) this.byteLength = byteLength; + }; + + $DataView = function DataView(buffer, byteOffset, byteLength) { + anInstance(this, $DataView, DATA_VIEW); + anInstance(buffer, $ArrayBuffer, DATA_VIEW); + var bufferLength = getInternalState(buffer).byteLength; + var offset = toInteger(byteOffset); + if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset'); + byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength); + if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH); + setInternalState(this, { + buffer: buffer, + byteLength: byteLength, + byteOffset: offset + }); + if (!descriptors) { + this.buffer = buffer; + this.byteLength = byteLength; + this.byteOffset = offset; + } + }; + + if (descriptors) { + addGetter($ArrayBuffer, 'byteLength'); + addGetter($DataView, 'buffer'); + addGetter($DataView, 'byteLength'); + addGetter($DataView, 'byteOffset'); + } + + redefineAll($DataView[PROTOTYPE], { + getInt8: function getInt8(byteOffset) { + return get(this, 1, byteOffset)[0] << 24 >> 24; + }, + getUint8: function getUint8(byteOffset) { + return get(this, 1, byteOffset)[0]; + }, + getInt16: function getInt16(byteOffset /* , littleEndian */) { + var bytes = get(this, 2, byteOffset, arguments[1]); + return (bytes[1] << 8 | bytes[0]) << 16 >> 16; + }, + getUint16: function getUint16(byteOffset /* , littleEndian */) { + var bytes = get(this, 2, byteOffset, arguments[1]); + return bytes[1] << 8 | bytes[0]; + }, + getInt32: function getInt32(byteOffset /* , littleEndian */) { + return unpackInt32(get(this, 4, byteOffset, arguments[1])); + }, + getUint32: function getUint32(byteOffset /* , littleEndian */) { + return unpackInt32(get(this, 4, byteOffset, arguments[1])) >>> 0; + }, + getFloat32: function getFloat32(byteOffset /* , littleEndian */) { + return unpackIEEE754(get(this, 4, byteOffset, arguments[1]), 23); + }, + getFloat64: function getFloat64(byteOffset /* , littleEndian */) { + return unpackIEEE754(get(this, 8, byteOffset, arguments[1]), 52); + }, + setInt8: function setInt8(byteOffset, value) { + set(this, 1, byteOffset, packInt8, value); + }, + setUint8: function setUint8(byteOffset, value) { + set(this, 1, byteOffset, packInt8, value); + }, + setInt16: function setInt16(byteOffset, value /* , littleEndian */) { + set(this, 2, byteOffset, packInt16, value, arguments[2]); + }, + setUint16: function setUint16(byteOffset, value /* , littleEndian */) { + set(this, 2, byteOffset, packInt16, value, arguments[2]); + }, + setInt32: function setInt32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packInt32, value, arguments[2]); + }, + setUint32: function setUint32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packInt32, value, arguments[2]); + }, + setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packFloat32, value, arguments[2]); + }, + setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) { + set(this, 8, byteOffset, packFloat64, value, arguments[2]); + } + }); +} else { + if (!fails(function () { + NativeArrayBuffer(1); + }) || !fails(function () { + new NativeArrayBuffer(-1); // eslint-disable-line no-new + }) || fails(function () { + new NativeArrayBuffer(); // eslint-disable-line no-new + new NativeArrayBuffer(1.5); // eslint-disable-line no-new + new NativeArrayBuffer(NaN); // eslint-disable-line no-new + return NativeArrayBuffer.name != ARRAY_BUFFER; + })) { + $ArrayBuffer = function ArrayBuffer(length) { + anInstance(this, $ArrayBuffer); + return new NativeArrayBuffer(toIndex(length)); + }; + var ArrayBufferPrototype = $ArrayBuffer[PROTOTYPE] = NativeArrayBuffer[PROTOTYPE]; + for (var keys = getOwnPropertyNames(NativeArrayBuffer), j = 0, key; keys.length > j;) { + if (!((key = keys[j++]) in $ArrayBuffer)) hide($ArrayBuffer, key, NativeArrayBuffer[key]); + } + ArrayBufferPrototype.constructor = $ArrayBuffer; + } + // iOS Safari 7.x bug + var testView = new $DataView(new $ArrayBuffer(2)); + var nativeSetInt8 = $DataView[PROTOTYPE].setInt8; + testView.setInt8(0, 2147483648); + testView.setInt8(1, 2147483649); + if (testView.getInt8(0) || !testView.getInt8(1)) redefineAll($DataView[PROTOTYPE], { + setInt8: function setInt8(byteOffset, value) { + nativeSetInt8.call(this, byteOffset, value << 24 >> 24); + }, + setUint8: function setUint8(byteOffset, value) { + nativeSetInt8.call(this, byteOffset, value << 24 >> 24); + } + }, { unsafe: true }); +} + +setToStringTag($ArrayBuffer, ARRAY_BUFFER); +setToStringTag($DataView, DATA_VIEW); +exports[ARRAY_BUFFER] = $ArrayBuffer; +exports[DATA_VIEW] = $DataView; +}); + +var ARRAY_BUFFER = 'ArrayBuffer'; +var ArrayBuffer = arrayBuffer[ARRAY_BUFFER]; +var NativeArrayBuffer = global_1[ARRAY_BUFFER]; + +// `ArrayBuffer` constructor +// https://tc39.github.io/ecma262/#sec-arraybuffer-constructor +_export({ global: true, forced: NativeArrayBuffer !== ArrayBuffer }, { + ArrayBuffer: ArrayBuffer +}); + +setSpecies(ARRAY_BUFFER); + +var NATIVE_ARRAY_BUFFER_VIEWS$1 = arrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; + +// `ArrayBuffer.isView` method +// https://tc39.github.io/ecma262/#sec-arraybuffer.isview +_export({ target: 'ArrayBuffer', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS$1 }, { + isView: arrayBufferViewCore.isView +}); + +var ArrayBuffer$1 = arrayBuffer.ArrayBuffer; +var DataView$1 = arrayBuffer.DataView; +var nativeArrayBufferSlice = ArrayBuffer$1.prototype.slice; + +var INCORRECT_SLICE = fails(function () { + return !new ArrayBuffer$1(2).slice(1, undefined).byteLength; +}); + +// `ArrayBuffer.prototype.slice` method +// https://tc39.github.io/ecma262/#sec-arraybuffer.prototype.slice +_export({ target: 'ArrayBuffer', proto: true, unsafe: true, forced: INCORRECT_SLICE }, { + slice: function slice(start, end) { + if (nativeArrayBufferSlice !== undefined && end === undefined) { + return nativeArrayBufferSlice.call(anObject(this), start); // FF fix + } + var length = anObject(this).byteLength; + var first = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + var result = new (speciesConstructor(this, ArrayBuffer$1))(toLength(fin - first)); + var viewSource = new DataView$1(this); + var viewTarget = new DataView$1(result); + var index = 0; + while (first < fin) { + viewTarget.setUint8(index++, viewSource.getUint8(first++)); + } return result; + } +}); + +var NATIVE_ARRAY_BUFFER$1 = arrayBufferViewCore.NATIVE_ARRAY_BUFFER; + +// `DataView` constructor +// https://tc39.github.io/ecma262/#sec-dataview-constructor +_export({ global: true, forced: !NATIVE_ARRAY_BUFFER$1 }, { + DataView: arrayBuffer.DataView +}); + +/* eslint-disable no-new */ + + + +var NATIVE_ARRAY_BUFFER_VIEWS$2 = arrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; + +var ArrayBuffer$2 = global_1.ArrayBuffer; +var Int8Array$2 = global_1.Int8Array; + +var typedArraysConstructorsRequiresWrappers = !NATIVE_ARRAY_BUFFER_VIEWS$2 || !fails(function () { + Int8Array$2(1); +}) || !fails(function () { + new Int8Array$2(-1); +}) || !checkCorrectnessOfIteration(function (iterable) { + new Int8Array$2(); + new Int8Array$2(null); + new Int8Array$2(1.5); + new Int8Array$2(iterable); +}, true) || fails(function () { + // Safari 11 bug + return new Int8Array$2(new ArrayBuffer$2(2), 1, undefined).length !== 1; +}); + +var toOffset = function (it, BYTES) { + var offset = toInteger(it); + if (offset < 0 || offset % BYTES) throw RangeError('Wrong offset'); + return offset; +}; + +var aTypedArrayConstructor$1 = arrayBufferViewCore.aTypedArrayConstructor; + +var typedArrayFrom = function from(source /* , mapfn, thisArg */) { + var O = toObject(source); + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + var iteratorMethod = getIteratorMethod(O); + var i, length, result, step, iterator; + if (iteratorMethod != undefined && !isArrayIteratorMethod(iteratorMethod)) { + iterator = iteratorMethod.call(O); + O = []; + while (!(step = iterator.next()).done) { + O.push(step.value); + } + } + if (mapping && argumentsLength > 2) { + mapfn = bindContext(mapfn, arguments[2], 2); + } + length = toLength(O.length); + result = new (aTypedArrayConstructor$1(this))(length); + for (i = 0; length > i; i++) { + result[i] = mapping ? mapfn(O[i], i) : O[i]; + } + return result; +}; + +var typedArrayConstructor = createCommonjsModule(function (module) { + + + + + + + + + + + + + + + + + + +var getOwnPropertyNames = objectGetOwnPropertyNames.f; + + + + + + + +var getInternalState = internalState.get; +var setInternalState = internalState.set; +var nativeDefineProperty = objectDefineProperty.f; +var nativeGetOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; +var forEach = arrayMethods(0); +var RangeError = global_1.RangeError; +var ArrayBuffer = arrayBuffer.ArrayBuffer; +var DataView = arrayBuffer.DataView; +var NATIVE_ARRAY_BUFFER_VIEWS = arrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; +var TYPED_ARRAY_TAG = arrayBufferViewCore.TYPED_ARRAY_TAG; +var TypedArray = arrayBufferViewCore.TypedArray; +var TypedArrayPrototype = arrayBufferViewCore.TypedArrayPrototype; +var aTypedArrayConstructor = arrayBufferViewCore.aTypedArrayConstructor; +var isTypedArray = arrayBufferViewCore.isTypedArray; +var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT'; +var WRONG_LENGTH = 'Wrong length'; + +var fromList = function (C, list) { + var index = 0; + var length = list.length; + var result = new (aTypedArrayConstructor(C))(length); + while (length > index) result[index] = list[index++]; + return result; +}; + +var addGetter = function (it, key) { + nativeDefineProperty(it, key, { get: function () { + return getInternalState(this)[key]; + } }); +}; + +var isArrayBuffer = function (it) { + var klass; + return it instanceof ArrayBuffer || (klass = classof(it)) == 'ArrayBuffer' || klass == 'SharedArrayBuffer'; +}; + +var isTypedArrayIndex = function (target, key) { + return isTypedArray(target) + && typeof key != 'symbol' + && key in target + && String(+key) == String(key); +}; + +var wrappedGetOwnPropertyDescriptor = function getOwnPropertyDescriptor(target, key) { + return isTypedArrayIndex(target, key = toPrimitive(key, true)) + ? createPropertyDescriptor(2, target[key]) + : nativeGetOwnPropertyDescriptor(target, key); +}; + +var wrappedDefineProperty = function defineProperty(target, key, descriptor) { + if (isTypedArrayIndex(target, key = toPrimitive(key, true)) + && isObject(descriptor) + && has(descriptor, 'value') + && !has(descriptor, 'get') + && !has(descriptor, 'set') + // TODO: add validation descriptor w/o calling accessors + && !descriptor.configurable + && (!has(descriptor, 'writable') || descriptor.writable) + && (!has(descriptor, 'enumerable') || descriptor.enumerable) + ) { + target[key] = descriptor.value; + return target; + } return nativeDefineProperty(target, key, descriptor); +}; + +if (descriptors) { + if (!NATIVE_ARRAY_BUFFER_VIEWS) { + objectGetOwnPropertyDescriptor.f = wrappedGetOwnPropertyDescriptor; + objectDefineProperty.f = wrappedDefineProperty; + addGetter(TypedArrayPrototype, 'buffer'); + addGetter(TypedArrayPrototype, 'byteOffset'); + addGetter(TypedArrayPrototype, 'byteLength'); + addGetter(TypedArrayPrototype, 'length'); + } + + _export({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, { + getOwnPropertyDescriptor: wrappedGetOwnPropertyDescriptor, + defineProperty: wrappedDefineProperty + }); + + // eslint-disable-next-line max-statements + module.exports = function (TYPE, BYTES, wrapper, CLAMPED) { + var CONSTRUCTOR_NAME = TYPE + (CLAMPED ? 'Clamped' : '') + 'Array'; + var GETTER = 'get' + TYPE; + var SETTER = 'set' + TYPE; + var NativeTypedArrayConstructor = global_1[CONSTRUCTOR_NAME]; + var TypedArrayConstructor = NativeTypedArrayConstructor; + var TypedArrayConstructorPrototype = TypedArrayConstructor && TypedArrayConstructor.prototype; + var exported = {}; + + var getter = function (that, index) { + var data = getInternalState(that); + return data.view[GETTER](index * BYTES + data.byteOffset, true); + }; + + var setter = function (that, index, value) { + var data = getInternalState(that); + if (CLAMPED) value = (value = Math.round(value)) < 0 ? 0 : value > 0xFF ? 0xFF : value & 0xFF; + data.view[SETTER](index * BYTES + data.byteOffset, value, true); + }; + + var addElement = function (that, index) { + nativeDefineProperty(that, index, { + get: function () { + return getter(this, index); + }, + set: function (value) { + return setter(this, index, value); + }, + enumerable: true + }); + }; + + if (!NATIVE_ARRAY_BUFFER_VIEWS) { + TypedArrayConstructor = wrapper(function (that, data, offset, $length) { + anInstance(that, TypedArrayConstructor, CONSTRUCTOR_NAME); + var index = 0; + var byteOffset = 0; + var buffer, byteLength, length; + if (!isObject(data)) { + length = toIndex(data); + byteLength = length * BYTES; + buffer = new ArrayBuffer(byteLength); + } else if (isArrayBuffer(data)) { + buffer = data; + byteOffset = toOffset(offset, BYTES); + var $len = data.byteLength; + if ($length === undefined) { + if ($len % BYTES) throw RangeError(WRONG_LENGTH); + byteLength = $len - byteOffset; + if (byteLength < 0) throw RangeError(WRONG_LENGTH); + } else { + byteLength = toLength($length) * BYTES; + if (byteLength + byteOffset > $len) throw RangeError(WRONG_LENGTH); + } + length = byteLength / BYTES; + } else if (isTypedArray(data)) { + return fromList(TypedArrayConstructor, data); + } else { + return typedArrayFrom.call(TypedArrayConstructor, data); + } + setInternalState(that, { + buffer: buffer, + byteOffset: byteOffset, + byteLength: byteLength, + length: length, + view: new DataView(buffer) + }); + while (index < length) addElement(that, index++); + }); + + if (objectSetPrototypeOf) objectSetPrototypeOf(TypedArrayConstructor, TypedArray); + TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = objectCreate(TypedArrayPrototype); + } else if (typedArraysConstructorsRequiresWrappers) { + TypedArrayConstructor = wrapper(function (that, data, typedArrayOffset, $length) { + anInstance(that, TypedArrayConstructor, CONSTRUCTOR_NAME); + if (!isObject(data)) return new NativeTypedArrayConstructor(toIndex(data)); + if (isArrayBuffer(data)) return $length !== undefined + ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES), $length) + : typedArrayOffset !== undefined + ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES)) + : new NativeTypedArrayConstructor(data); + if (isTypedArray(data)) return fromList(TypedArrayConstructor, data); + return typedArrayFrom.call(TypedArrayConstructor, data); + }); + + if (objectSetPrototypeOf) objectSetPrototypeOf(TypedArrayConstructor, TypedArray); + forEach(getOwnPropertyNames(NativeTypedArrayConstructor), function (key) { + if (!(key in TypedArrayConstructor)) hide(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]); + }); + TypedArrayConstructor.prototype = TypedArrayConstructorPrototype; + } + + if (TypedArrayConstructorPrototype.constructor !== TypedArrayConstructor) { + hide(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor); + } + + if (TYPED_ARRAY_TAG) hide(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME); + + exported[CONSTRUCTOR_NAME] = TypedArrayConstructor; + + _export({ + global: true, forced: TypedArrayConstructor != NativeTypedArrayConstructor, sham: !NATIVE_ARRAY_BUFFER_VIEWS + }, exported); + + if (!(BYTES_PER_ELEMENT in TypedArrayConstructor)) { + hide(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES); + } + + if (!(BYTES_PER_ELEMENT in TypedArrayConstructorPrototype)) { + hide(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES); + } + + setSpecies(CONSTRUCTOR_NAME); + }; +} else module.exports = function () { /* empty */ }; +}); + +// `Int8Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +typedArrayConstructor('Int8', 1, function (init) { + return function Int8Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + +// `Uint8Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +typedArrayConstructor('Uint8', 1, function (init) { + return function Uint8Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + +// `Uint8ClampedArray` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +typedArrayConstructor('Uint8', 1, function (init) { + return function Uint8ClampedArray(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}, true); + +// `Int16Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +typedArrayConstructor('Int16', 2, function (init) { + return function Int16Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + +// `Uint16Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +typedArrayConstructor('Uint16', 2, function (init) { + return function Uint16Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + +// `Int32Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +typedArrayConstructor('Int32', 4, function (init) { + return function Int32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + +// `Uint32Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +typedArrayConstructor('Uint32', 4, function (init) { + return function Uint32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + +// `Float32Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +typedArrayConstructor('Float32', 4, function (init) { + return function Float32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + +// `Float64Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +typedArrayConstructor('Float64', 8, function (init) { + return function Float64Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + +// `%TypedArray%.from` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.from +arrayBufferViewCore.exportStatic('from', typedArrayFrom, typedArraysConstructorsRequiresWrappers); + +var aTypedArrayConstructor$2 = arrayBufferViewCore.aTypedArrayConstructor; + +// `%TypedArray%.of` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.of +arrayBufferViewCore.exportStatic('of', function of(/* ...items */) { + var index = 0; + var length = arguments.length; + var result = new (aTypedArrayConstructor$2(this))(length); + while (length > index) result[index] = arguments[index++]; + return result; +}, typedArraysConstructorsRequiresWrappers); + +var aTypedArray$1 = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.copyWithin` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.copywithin +arrayBufferViewCore.exportProto('copyWithin', function copyWithin(target, start /* , end */) { + return arrayCopyWithin.call(aTypedArray$1(this), target, start, arguments.length > 2 ? arguments[2] : undefined); +}); + +var arrayEvery = arrayMethods(4); +var aTypedArray$2 = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.every` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.every +arrayBufferViewCore.exportProto('every', function every(callbackfn /* , thisArg */) { + return arrayEvery(aTypedArray$2(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); +}); + +var aTypedArray$3 = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.fill` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.fill +// eslint-disable-next-line no-unused-vars +arrayBufferViewCore.exportProto('fill', function fill(value /* , start, end */) { + return arrayFill.apply(aTypedArray$3(this), arguments); +}); + +var arrayFilter = arrayMethods(2); +var aTypedArray$4 = arrayBufferViewCore.aTypedArray; +var aTypedArrayConstructor$3 = arrayBufferViewCore.aTypedArrayConstructor; + +// `%TypedArray%.prototype.filter` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.filter +arrayBufferViewCore.exportProto('filter', function filter(callbackfn /* , thisArg */) { + var list = arrayFilter(aTypedArray$4(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var C = speciesConstructor(this, this.constructor); + var index = 0; + var length = list.length; + var result = new (aTypedArrayConstructor$3(C))(length); + while (length > index) result[index] = list[index++]; + return result; +}); + +var arrayFind$1 = arrayMethods(5); +var aTypedArray$5 = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.find` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.find +arrayBufferViewCore.exportProto('find', function find(predicate /* , thisArg */) { + return arrayFind$1(aTypedArray$5(this), predicate, arguments.length > 1 ? arguments[1] : undefined); +}); + +var arrayFindIndex$1 = arrayMethods(6); +var aTypedArray$6 = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.findIndex` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.findindex +arrayBufferViewCore.exportProto('findIndex', function findIndex(predicate /* , thisArg */) { + return arrayFindIndex$1(aTypedArray$6(this), predicate, arguments.length > 1 ? arguments[1] : undefined); +}); + +var arrayForEach$1 = arrayMethods(0); +var aTypedArray$7 = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.forEach` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.foreach +arrayBufferViewCore.exportProto('forEach', function forEach(callbackfn /* , thisArg */) { + arrayForEach$1(aTypedArray$7(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); +}); + +var aTypedArray$8 = arrayBufferViewCore.aTypedArray; +var arrayIncludes$1 = arrayIncludes(true); + +// `%TypedArray%.prototype.includes` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.includes +arrayBufferViewCore.exportProto('includes', function includes(searchElement /* , fromIndex */) { + return arrayIncludes$1(aTypedArray$8(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); +}); + +var aTypedArray$9 = arrayBufferViewCore.aTypedArray; +var arrayIndexOf$1 = arrayIncludes(false); + +// `%TypedArray%.prototype.indexOf` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.indexof +arrayBufferViewCore.exportProto('indexOf', function indexOf(searchElement /* , fromIndex */) { + return arrayIndexOf$1(aTypedArray$9(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); +}); + +var ITERATOR$5 = wellKnownSymbol('iterator'); +var Uint8Array = global_1.Uint8Array; +var arrayValues = es_array_iterator.values; +var arrayKeys = es_array_iterator.keys; +var arrayEntries = es_array_iterator.entries; +var aTypedArray$a = arrayBufferViewCore.aTypedArray; +var exportProto$1 = arrayBufferViewCore.exportProto; +var nativeTypedArrayIterator = Uint8Array && Uint8Array.prototype[ITERATOR$5]; + +var CORRECT_ITER_NAME = !!nativeTypedArrayIterator + && (nativeTypedArrayIterator.name == 'values' || nativeTypedArrayIterator.name == undefined); + +var typedArrayValues = function values() { + return arrayValues.call(aTypedArray$a(this)); +}; + +// `%TypedArray%.prototype.entries` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.entries +exportProto$1('entries', function entries() { + return arrayEntries.call(aTypedArray$a(this)); +}); +// `%TypedArray%.prototype.keys` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.keys +exportProto$1('keys', function keys() { + return arrayKeys.call(aTypedArray$a(this)); +}); +// `%TypedArray%.prototype.values` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.values +exportProto$1('values', typedArrayValues, !CORRECT_ITER_NAME); +// `%TypedArray%.prototype[@@iterator]` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype-@@iterator +exportProto$1(ITERATOR$5, typedArrayValues, !CORRECT_ITER_NAME); + +var aTypedArray$b = arrayBufferViewCore.aTypedArray; +var arrayJoin = [].join; + +// `%TypedArray%.prototype.join` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.join +// eslint-disable-next-line no-unused-vars +arrayBufferViewCore.exportProto('join', function join(separator) { + return arrayJoin.apply(aTypedArray$b(this), arguments); +}); + +var aTypedArray$c = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.lastIndexOf` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.lastindexof +// eslint-disable-next-line no-unused-vars +arrayBufferViewCore.exportProto('lastIndexOf', function lastIndexOf(searchElement /* , fromIndex */) { + return arrayLastIndexOf.apply(aTypedArray$c(this), arguments); +}); + +var aTypedArray$d = arrayBufferViewCore.aTypedArray; +var aTypedArrayConstructor$4 = arrayBufferViewCore.aTypedArrayConstructor; + +var internalTypedArrayMap = arrayMethods(1, function (O, length) { + return new (aTypedArrayConstructor$4(speciesConstructor(O, O.constructor)))(length); +}); + +// `%TypedArray%.prototype.map` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.map +arrayBufferViewCore.exportProto('map', function map(mapfn /* , thisArg */) { + return internalTypedArrayMap(aTypedArray$d(this), mapfn, arguments.length > 1 ? arguments[1] : undefined); +}); + +var aTypedArray$e = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.reduce` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reduce +arrayBufferViewCore.exportProto('reduce', function reduce(callbackfn /* , initialValue */) { + return arrayReduce(aTypedArray$e(this), callbackfn, arguments.length, arguments[1], false); +}); + +var aTypedArray$f = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.reduceRicht` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reduceright +arrayBufferViewCore.exportProto('reduceRight', function reduceRight(callbackfn /* , initialValue */) { + return arrayReduce(aTypedArray$f(this), callbackfn, arguments.length, arguments[1], true); +}); + +var aTypedArray$g = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.reverse` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reverse +arrayBufferViewCore.exportProto('reverse', function reverse() { + var that = this; + var length = aTypedArray$g(that).length; + var middle = Math.floor(length / 2); + var index = 0; + var value; + while (index < middle) { + value = that[index]; + that[index++] = that[--length]; + that[length] = value; + } return that; +}); + +var aTypedArray$h = arrayBufferViewCore.aTypedArray; + +var FORCED$g = fails(function () { + // eslint-disable-next-line no-undef + new Int8Array(1).set({}); +}); + +// `%TypedArray%.prototype.set` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.set +arrayBufferViewCore.exportProto('set', function set(arrayLike /* , offset */) { + aTypedArray$h(this); + var offset = toOffset(arguments[1], 1); + var length = this.length; + var src = toObject(arrayLike); + var len = toLength(src.length); + var index = 0; + if (len + offset > length) throw RangeError('Wrong length'); + while (index < len) this[offset + index] = src[index++]; +}, FORCED$g); + +var aTypedArray$i = arrayBufferViewCore.aTypedArray; +var aTypedArrayConstructor$5 = arrayBufferViewCore.aTypedArrayConstructor; +var arraySlice$1 = [].slice; + +var FORCED$h = fails(function () { + // eslint-disable-next-line no-undef + new Int8Array(1).slice(); +}); + +// `%TypedArray%.prototype.slice` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.slice +arrayBufferViewCore.exportProto('slice', function slice(start, end) { + var list = arraySlice$1.call(aTypedArray$i(this), start, end); + var C = speciesConstructor(this, this.constructor); + var index = 0; + var length = list.length; + var result = new (aTypedArrayConstructor$5(C))(length); + while (length > index) result[index] = list[index++]; + return result; +}, FORCED$h); + +var arraySome = arrayMethods(3); +var aTypedArray$j = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.some` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.some +arrayBufferViewCore.exportProto('some', function some(callbackfn /* , thisArg */) { + return arraySome(aTypedArray$j(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); +}); + +var aTypedArray$k = arrayBufferViewCore.aTypedArray; +var arraySort = [].sort; + +// `%TypedArray%.prototype.sort` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.sort +arrayBufferViewCore.exportProto('sort', function sort(comparefn) { + return arraySort.call(aTypedArray$k(this), comparefn); +}); + +var aTypedArray$l = arrayBufferViewCore.aTypedArray; + +// `%TypedArray%.prototype.subarray` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.subarray +arrayBufferViewCore.exportProto('subarray', function subarray(begin, end) { + var O = aTypedArray$l(this); + var length = O.length; + var beginIndex = toAbsoluteIndex(begin, length); + return new (speciesConstructor(O, O.constructor))( + O.buffer, + O.byteOffset + beginIndex * O.BYTES_PER_ELEMENT, + toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - beginIndex) + ); +}); + +var Int8Array$3 = global_1.Int8Array; +var aTypedArray$m = arrayBufferViewCore.aTypedArray; +var arrayToLocaleString = [].toLocaleString; +var arraySlice$2 = [].slice; + +// iOS Safari 6.x fails here +var TO_LOCALE_BUG = !!Int8Array$3 && fails(function () { + arrayToLocaleString.call(new Int8Array$3(1)); +}); +var FORCED$i = fails(function () { + return [1, 2].toLocaleString() != new Int8Array$3([1, 2]).toLocaleString(); +}) || !fails(function () { + Int8Array$3.prototype.toLocaleString.call([1, 2]); +}); + +// `%TypedArray%.prototype.toLocaleString` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tolocalestring +arrayBufferViewCore.exportProto('toLocaleString', function toLocaleString() { + return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice$2.call(aTypedArray$m(this)) : aTypedArray$m(this), arguments); +}, FORCED$i); + +var Uint8Array$1 = global_1.Uint8Array; +var Uint8ArrayPrototype = Uint8Array$1 && Uint8Array$1.prototype; +var arrayToString = [].toString; +var arrayJoin$1 = [].join; + +if (fails(function () { arrayToString.call({}); })) { + arrayToString = function toString() { + return arrayJoin$1.call(this); + }; +} + +// `%TypedArray%.prototype.toString` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tostring +arrayBufferViewCore.exportProto('toString', arrayToString, (Uint8ArrayPrototype || {}).toString != arrayToString); + +var nativeApply = (global_1.Reflect || {}).apply; +var functionApply = Function.apply; + +// MS Edge argumentsList argument is optional +var OPTIONAL_ARGUMENTS_LIST = !fails(function () { + nativeApply(function () { /* empty */ }); +}); + +// `Reflect.apply` method +// https://tc39.github.io/ecma262/#sec-reflect.apply +_export({ target: 'Reflect', stat: true, forced: OPTIONAL_ARGUMENTS_LIST }, { + apply: function apply(target, thisArgument, argumentsList) { + aFunction(target); + anObject(argumentsList); + return nativeApply + ? nativeApply(target, thisArgument, argumentsList) + : functionApply.call(target, thisArgument, argumentsList); + } +}); + +var nativeConstruct = (global_1.Reflect || {}).construct; + +// `Reflect.construct` method +// https://tc39.github.io/ecma262/#sec-reflect.construct +// MS Edge supports only 2 arguments and argumentsList argument is optional +// FF Nightly sets third argument as `new.target`, but does not create `this` from it +var NEW_TARGET_BUG = fails(function () { + function F() { /* empty */ } + return !(nativeConstruct(function () { /* empty */ }, [], F) instanceof F); +}); +var ARGS_BUG = !fails(function () { + nativeConstruct(function () { /* empty */ }); +}); +var FORCED$j = NEW_TARGET_BUG || ARGS_BUG; + +_export({ target: 'Reflect', stat: true, forced: FORCED$j, sham: FORCED$j }, { + construct: function construct(Target, args /* , newTarget */) { + aFunction(Target); + anObject(args); + var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]); + if (ARGS_BUG && !NEW_TARGET_BUG) return nativeConstruct(Target, args, newTarget); + if (Target == newTarget) { + // w/o altered newTarget, optimization for 0-4 arguments + switch (args.length) { + case 0: return new Target(); + case 1: return new Target(args[0]); + case 2: return new Target(args[0], args[1]); + case 3: return new Target(args[0], args[1], args[2]); + case 4: return new Target(args[0], args[1], args[2], args[3]); + } + // w/o altered newTarget, lot of arguments case + var $args = [null]; + $args.push.apply($args, args); + return new (functionBind.apply(Target, $args))(); + } + // with altered newTarget, not support built-in constructors + var proto = newTarget.prototype; + var instance = objectCreate(isObject(proto) ? proto : Object.prototype); + var result = Function.apply.call(Target, instance, args); + return isObject(result) ? result : instance; + } +}); + +// MS Edge has broken Reflect.defineProperty - throwing instead of returning false +var ERROR_INSTEAD_OF_FALSE = fails(function () { + // eslint-disable-next-line no-undef + Reflect.defineProperty(objectDefineProperty.f({}, 1, { value: 1 }), 1, { value: 2 }); +}); + +// `Reflect.defineProperty` method +// https://tc39.github.io/ecma262/#sec-reflect.defineproperty +_export({ target: 'Reflect', stat: true, forced: ERROR_INSTEAD_OF_FALSE, sham: !descriptors }, { + defineProperty: function defineProperty(target, propertyKey, attributes) { + anObject(target); + propertyKey = toPrimitive(propertyKey, true); + anObject(attributes); + try { + objectDefineProperty.f(target, propertyKey, attributes); + return true; + } catch (error) { + return false; + } + } +}); + +var getOwnPropertyDescriptor$6 = objectGetOwnPropertyDescriptor.f; + + +// `Reflect.deleteProperty` method +// https://tc39.github.io/ecma262/#sec-reflect.deleteproperty +_export({ target: 'Reflect', stat: true }, { + deleteProperty: function deleteProperty(target, propertyKey) { + var descriptor = getOwnPropertyDescriptor$6(anObject(target), propertyKey); + return descriptor && !descriptor.configurable ? false : delete target[propertyKey]; + } +}); + +// `Reflect.get` method +// https://tc39.github.io/ecma262/#sec-reflect.get +function get$1(target, propertyKey /* , receiver */) { + var receiver = arguments.length < 3 ? target : arguments[2]; + var descriptor, prototype; + if (anObject(target) === receiver) return target[propertyKey]; + if (descriptor = objectGetOwnPropertyDescriptor.f(target, propertyKey)) return has(descriptor, 'value') + ? descriptor.value + : descriptor.get === undefined + ? undefined + : descriptor.get.call(receiver); + if (isObject(prototype = objectGetPrototypeOf(target))) return get$1(prototype, propertyKey, receiver); +} + +_export({ target: 'Reflect', stat: true }, { + get: get$1 +}); + +// `Reflect.getOwnPropertyDescriptor` method +// https://tc39.github.io/ecma262/#sec-reflect.getownpropertydescriptor +_export({ target: 'Reflect', stat: true, sham: !descriptors }, { + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) { + return objectGetOwnPropertyDescriptor.f(anObject(target), propertyKey); + } +}); + +// `Reflect.getPrototypeOf` method +// https://tc39.github.io/ecma262/#sec-reflect.getprototypeof +_export({ target: 'Reflect', stat: true, sham: !correctPrototypeGetter }, { + getPrototypeOf: function getPrototypeOf(target) { + return objectGetPrototypeOf(anObject(target)); + } +}); + +// `Reflect.has` method +// https://tc39.github.io/ecma262/#sec-reflect.has +_export({ target: 'Reflect', stat: true }, { + has: function has(target, propertyKey) { + return propertyKey in target; + } +}); + +var objectIsExtensible = Object.isExtensible; + +// `Reflect.isExtensible` method +// https://tc39.github.io/ecma262/#sec-reflect.isextensible +_export({ target: 'Reflect', stat: true }, { + isExtensible: function isExtensible(target) { + anObject(target); + return objectIsExtensible ? objectIsExtensible(target) : true; + } +}); + +// `Reflect.ownKeys` method +// https://tc39.github.io/ecma262/#sec-reflect.ownkeys +_export({ target: 'Reflect', stat: true }, { + ownKeys: ownKeys +}); + +// `Reflect.preventExtensions` method +// https://tc39.github.io/ecma262/#sec-reflect.preventextensions +_export({ target: 'Reflect', stat: true, sham: !freezing }, { + preventExtensions: function preventExtensions(target) { + anObject(target); + try { + var objectPreventExtensions = getBuiltIn('Object', 'preventExtensions'); + if (objectPreventExtensions) objectPreventExtensions(target); + return true; + } catch (error) { + return false; + } + } +}); + +// `Reflect.set` method +// https://tc39.github.io/ecma262/#sec-reflect.set +function set$2(target, propertyKey, V /* , receiver */) { + var receiver = arguments.length < 4 ? target : arguments[3]; + var ownDescriptor = objectGetOwnPropertyDescriptor.f(anObject(target), propertyKey); + var existingDescriptor, prototype; + if (!ownDescriptor) { + if (isObject(prototype = objectGetPrototypeOf(target))) { + return set$2(prototype, propertyKey, V, receiver); + } + ownDescriptor = createPropertyDescriptor(0); + } + if (has(ownDescriptor, 'value')) { + if (ownDescriptor.writable === false || !isObject(receiver)) return false; + if (existingDescriptor = objectGetOwnPropertyDescriptor.f(receiver, propertyKey)) { + if (existingDescriptor.get || existingDescriptor.set || existingDescriptor.writable === false) return false; + existingDescriptor.value = V; + objectDefineProperty.f(receiver, propertyKey, existingDescriptor); + } else objectDefineProperty.f(receiver, propertyKey, createPropertyDescriptor(0, V)); + return true; + } + return ownDescriptor.set === undefined ? false : (ownDescriptor.set.call(receiver, V), true); +} + +_export({ target: 'Reflect', stat: true }, { + set: set$2 +}); + +// `Reflect.setPrototypeOf` method +// https://tc39.github.io/ecma262/#sec-reflect.setprototypeof +if (objectSetPrototypeOf) _export({ target: 'Reflect', stat: true }, { + setPrototypeOf: function setPrototypeOf(target, proto) { + validateSetPrototypeOfArguments(target, proto); + try { + objectSetPrototypeOf(target, proto); + return true; + } catch (error) { + return false; + } + } +}); + +var metadata = shared('metadata'); +var store$2 = metadata.store || (metadata.store = new es_weakMap()); + +var getOrCreateMetadataMap = function (target, targetKey, create) { + var targetMetadata = store$2.get(target); + if (!targetMetadata) { + if (!create) return; + store$2.set(target, targetMetadata = new es_map()); + } + var keyMetadata = targetMetadata.get(targetKey); + if (!keyMetadata) { + if (!create) return; + targetMetadata.set(targetKey, keyMetadata = new es_map()); + } return keyMetadata; +}; + +var ordinaryHasOwnMetadata = function (MetadataKey, O, P) { + var metadataMap = getOrCreateMetadataMap(O, P, false); + return metadataMap === undefined ? false : metadataMap.has(MetadataKey); +}; + +var ordinaryGetOwnMetadata = function (MetadataKey, O, P) { + var metadataMap = getOrCreateMetadataMap(O, P, false); + return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey); +}; + +var ordinaryDefineOwnMetadata = function (MetadataKey, MetadataValue, O, P) { + getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue); +}; + +var ordinaryOwnMetadataKeys = function (target, targetKey) { + var metadataMap = getOrCreateMetadataMap(target, targetKey, false); + var keys = []; + if (metadataMap) metadataMap.forEach(function (_, key) { keys.push(key); }); + return keys; +}; + +var toMetadataKey = function (it) { + return it === undefined || typeof it == 'symbol' ? it : String(it); +}; + +var reflectMetadata = { + store: store$2, + getMap: getOrCreateMetadataMap, + has: ordinaryHasOwnMetadata, + get: ordinaryGetOwnMetadata, + set: ordinaryDefineOwnMetadata, + keys: ordinaryOwnMetadataKeys, + toKey: toMetadataKey +}; + +var toMetadataKey$1 = reflectMetadata.toKey; +var ordinaryDefineOwnMetadata$1 = reflectMetadata.set; + +// `Reflect.defineMetadata` method +// https://github.com/rbuckton/reflect-metadata +_export({ target: 'Reflect', stat: true }, { + defineMetadata: function defineMetadata(metadataKey, metadataValue, target /* , targetKey */) { + var targetKey = arguments.length < 4 ? undefined : toMetadataKey$1(arguments[3]); + ordinaryDefineOwnMetadata$1(metadataKey, metadataValue, anObject(target), targetKey); + } +}); + +var toMetadataKey$2 = reflectMetadata.toKey; +var getOrCreateMetadataMap$1 = reflectMetadata.getMap; +var store$3 = reflectMetadata.store; + +// `Reflect.deleteMetadata` method +// https://github.com/rbuckton/reflect-metadata +_export({ target: 'Reflect', stat: true }, { + deleteMetadata: function deleteMetadata(metadataKey, target /* , targetKey */) { + var targetKey = arguments.length < 3 ? undefined : toMetadataKey$2(arguments[2]); + var metadataMap = getOrCreateMetadataMap$1(anObject(target), targetKey, false); + if (metadataMap === undefined || !metadataMap['delete'](metadataKey)) return false; + if (metadataMap.size) return true; + var targetMetadata = store$3.get(target); + targetMetadata['delete'](targetKey); + return !!targetMetadata.size || store$3['delete'](target); + } +}); + +var ordinaryHasOwnMetadata$1 = reflectMetadata.has; +var ordinaryGetOwnMetadata$1 = reflectMetadata.get; +var toMetadataKey$3 = reflectMetadata.toKey; + +var ordinaryGetMetadata = function (MetadataKey, O, P) { + var hasOwn = ordinaryHasOwnMetadata$1(MetadataKey, O, P); + if (hasOwn) return ordinaryGetOwnMetadata$1(MetadataKey, O, P); + var parent = objectGetPrototypeOf(O); + return parent !== null ? ordinaryGetMetadata(MetadataKey, parent, P) : undefined; +}; + +// `Reflect.getMetadata` method +// https://github.com/rbuckton/reflect-metadata +_export({ target: 'Reflect', stat: true }, { + getMetadata: function getMetadata(metadataKey, target /* , targetKey */) { + var targetKey = arguments.length < 3 ? undefined : toMetadataKey$3(arguments[2]); + return ordinaryGetMetadata(metadataKey, anObject(target), targetKey); + } +}); + +var ordinaryOwnMetadataKeys$1 = reflectMetadata.keys; +var toMetadataKey$4 = reflectMetadata.toKey; + +var from = function (iter) { + var result = []; + iterate(iter, result.push, result); + return result; +}; + +var ordinaryMetadataKeys = function (O, P) { + var oKeys = ordinaryOwnMetadataKeys$1(O, P); + var parent = objectGetPrototypeOf(O); + if (parent === null) return oKeys; + var pKeys = ordinaryMetadataKeys(parent, P); + return pKeys.length ? oKeys.length ? from(new es_set(oKeys.concat(pKeys))) : pKeys : oKeys; +}; + +// `Reflect.getMetadataKeys` method +// https://github.com/rbuckton/reflect-metadata +_export({ target: 'Reflect', stat: true }, { + getMetadataKeys: function getMetadataKeys(target /* , targetKey */) { + var targetKey = arguments.length < 2 ? undefined : toMetadataKey$4(arguments[1]); + return ordinaryMetadataKeys(anObject(target), targetKey); + } +}); + +var ordinaryGetOwnMetadata$2 = reflectMetadata.get; +var toMetadataKey$5 = reflectMetadata.toKey; + +// `Reflect.getOwnMetadata` method +// https://github.com/rbuckton/reflect-metadata +_export({ target: 'Reflect', stat: true }, { + getOwnMetadata: function getOwnMetadata(metadataKey, target /* , targetKey */) { + var targetKey = arguments.length < 3 ? undefined : toMetadataKey$5(arguments[2]); + return ordinaryGetOwnMetadata$2(metadataKey, anObject(target), targetKey); + } +}); + +var ordinaryOwnMetadataKeys$2 = reflectMetadata.keys; +var toMetadataKey$6 = reflectMetadata.toKey; + +// `Reflect.getOwnMetadataKeys` method +// https://github.com/rbuckton/reflect-metadata +_export({ target: 'Reflect', stat: true }, { + getOwnMetadataKeys: function getOwnMetadataKeys(target /* , targetKey */) { + var targetKey = arguments.length < 2 ? undefined : toMetadataKey$6(arguments[1]); + return ordinaryOwnMetadataKeys$2(anObject(target), targetKey); + } +}); + +var ordinaryHasOwnMetadata$2 = reflectMetadata.has; +var toMetadataKey$7 = reflectMetadata.toKey; + +var ordinaryHasMetadata = function (MetadataKey, O, P) { + var hasOwn = ordinaryHasOwnMetadata$2(MetadataKey, O, P); + if (hasOwn) return true; + var parent = objectGetPrototypeOf(O); + return parent !== null ? ordinaryHasMetadata(MetadataKey, parent, P) : false; +}; + +// `Reflect.hasMetadata` method +// https://github.com/rbuckton/reflect-metadata +_export({ target: 'Reflect', stat: true }, { + hasMetadata: function hasMetadata(metadataKey, target /* , targetKey */) { + var targetKey = arguments.length < 3 ? undefined : toMetadataKey$7(arguments[2]); + return ordinaryHasMetadata(metadataKey, anObject(target), targetKey); + } +}); + +var ordinaryHasOwnMetadata$3 = reflectMetadata.has; +var toMetadataKey$8 = reflectMetadata.toKey; + +// `Reflect.hasOwnMetadata` method +// https://github.com/rbuckton/reflect-metadata +_export({ target: 'Reflect', stat: true }, { + hasOwnMetadata: function hasOwnMetadata(metadataKey, target /* , targetKey */) { + var targetKey = arguments.length < 3 ? undefined : toMetadataKey$8(arguments[2]); + return ordinaryHasOwnMetadata$3(metadataKey, anObject(target), targetKey); + } +}); + +var toMetadataKey$9 = reflectMetadata.toKey; +var ordinaryDefineOwnMetadata$2 = reflectMetadata.set; + +// `Reflect.metadata` method +// https://github.com/rbuckton/reflect-metadata +_export({ target: 'Reflect', stat: true }, { + metadata: function metadata(metadataKey, metadataValue) { + return function decorator(target, key) { + ordinaryDefineOwnMetadata$2(metadataKey, metadataValue, anObject(target), toMetadataKey$9(key)); + }; + } +}); + +// `Math.iaddh` method +// https://gist.github.com/BrendanEich/4294d5c212a6d2254703 +_export({ target: 'Math', stat: true }, { + iaddh: function iaddh(x0, x1, y0, y1) { + var $x0 = x0 >>> 0; + var $x1 = x1 >>> 0; + var $y0 = y0 >>> 0; + return $x1 + (y1 >>> 0) + (($x0 & $y0 | ($x0 | $y0) & ~($x0 + $y0 >>> 0)) >>> 31) | 0; + } +}); + +// `Math.isubh` method +// https://gist.github.com/BrendanEich/4294d5c212a6d2254703 +_export({ target: 'Math', stat: true }, { + isubh: function isubh(x0, x1, y0, y1) { + var $x0 = x0 >>> 0; + var $x1 = x1 >>> 0; + var $y0 = y0 >>> 0; + return $x1 - (y1 >>> 0) - ((~$x0 & $y0 | ~($x0 ^ $y0) & $x0 - $y0 >>> 0) >>> 31) | 0; + } +}); + +// `Math.imulh` method +// https://gist.github.com/BrendanEich/4294d5c212a6d2254703 +_export({ target: 'Math', stat: true }, { + imulh: function imulh(u, v) { + var UINT16 = 0xFFFF; + var $u = +u; + var $v = +v; + var u0 = $u & UINT16; + var v0 = $v & UINT16; + var u1 = $u >> 16; + var v1 = $v >> 16; + var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16); + return u1 * v1 + (t >> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >> 16); + } +}); + +// `Math.umulh` method +// https://gist.github.com/BrendanEich/4294d5c212a6d2254703 +_export({ target: 'Math', stat: true }, { + umulh: function umulh(u, v) { + var UINT16 = 0xFFFF; + var $u = +u; + var $v = +v; + var u0 = $u & UINT16; + var v0 = $v & UINT16; + var u1 = $u >>> 16; + var v1 = $v >>> 16; + var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16); + return u1 * v1 + (t >>> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >>> 16); + } +}); + +// `String.prototype.at` method +// https://github.com/mathiasbynens/String.prototype.at +_export({ target: 'String', proto: true }, { + at: function at(pos) { + return stringAt(this, pos, true); + } +}); + +var ITERATOR$6 = wellKnownSymbol('iterator'); + +var nativeUrl = !fails(function () { + var url = new URL('b?e=1', 'http://a'); + var searchParams = url.searchParams; + url.pathname = 'c%20d'; + return (isPure && !url.toJSON) + || !searchParams.sort + || url.href !== 'http://a/c%20d?e=1' + || searchParams.get('e') !== '1' + || String(new URLSearchParams('?a=1')) !== 'a=1' + || !searchParams[ITERATOR$6] + // throws in Edge + || new URL('https://a@b').username !== 'a' + || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b' + // not punycoded in Edge + || new URL('http://тест').host !== 'xn--e1aybc' + // not escaped in Chrome 62- + || new URL('http://a#б').hash !== '#%D0%B1'; +}); + +// based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js +var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1 +var base = 36; +var tMin = 1; +var tMax = 26; +var skew = 38; +var damp = 700; +var initialBias = 72; +var initialN = 128; // 0x80 +var delimiter = '-'; // '\x2D' +var regexNonASCII = /[^\0-\u007E]/; // non-ASCII chars +var regexSeparators = /[.\u3002\uFF0E\uFF61]/g; // RFC 3490 separators +var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process'; +var baseMinusTMin = base - tMin; +var floor$6 = Math.floor; +var stringFromCharCode = String.fromCharCode; + +/** + * Creates an array containing the numeric code points of each Unicode + * character in the string. While JavaScript uses UCS-2 internally, + * this function will convert a pair of surrogate halves (each of which + * UCS-2 exposes as separate characters) into a single code point, + * matching UTF-16. + */ +var ucs2decode = function (string) { + var output = []; + var counter = 0; + var length = string.length; + while (counter < length) { + var value = string.charCodeAt(counter++); + if (value >= 0xD800 && value <= 0xDBFF && counter < length) { + // It's a high surrogate, and there is a next character. + var extra = string.charCodeAt(counter++); + if ((extra & 0xFC00) == 0xDC00) { // Low surrogate. + output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); + } else { + // It's an unmatched surrogate; only append this code unit, in case the + // next code unit is the high surrogate of a surrogate pair. + output.push(value); + counter--; + } + } else { + output.push(value); + } + } + return output; +}; + +/** + * Converts a digit/integer into a basic code point. + */ +var digitToBasic = function (digit) { + // 0..25 map to ASCII a..z or A..Z + // 26..35 map to ASCII 0..9 + return digit + 22 + 75 * (digit < 26); +}; + +/** + * Bias adaptation function as per section 3.4 of RFC 3492. + * https://tools.ietf.org/html/rfc3492#section-3.4 + */ +var adapt = function (delta, numPoints, firstTime) { + var k = 0; + delta = firstTime ? floor$6(delta / damp) : delta >> 1; + delta += floor$6(delta / numPoints); + for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) { + delta = floor$6(delta / baseMinusTMin); + } + return floor$6(k + (baseMinusTMin + 1) * delta / (delta + skew)); +}; + +/** + * Converts a string of Unicode symbols (e.g. a domain name label) to a + * Punycode string of ASCII-only symbols. + */ +// eslint-disable-next-line max-statements +var encode = function (input) { + var output = []; + + // Convert the input in UCS-2 to an array of Unicode code points. + input = ucs2decode(input); + + // Cache the length. + var inputLength = input.length; + + // Initialize the state. + var n = initialN; + var delta = 0; + var bias = initialBias; + var i, currentValue; + + // Handle the basic code points. + for (i = 0; i < input.length; i++) { + currentValue = input[i]; + if (currentValue < 0x80) { + output.push(stringFromCharCode(currentValue)); + } + } + + var basicLength = output.length; // number of basic code points. + var handledCPCount = basicLength; // number of code points that have been handled; + + // Finish the basic string with a delimiter unless it's empty. + if (basicLength) { + output.push(delimiter); + } + + // Main encoding loop: + while (handledCPCount < inputLength) { + // All non-basic code points < n have been handled already. Find the next larger one: + var m = maxInt; + for (i = 0; i < input.length; i++) { + currentValue = input[i]; + if (currentValue >= n && currentValue < m) { + m = currentValue; + } + } + + // Increase `delta` enough to advance the decoder's state to , but guard against overflow. + var handledCPCountPlusOne = handledCPCount + 1; + if (m - n > floor$6((maxInt - delta) / handledCPCountPlusOne)) { + throw RangeError(OVERFLOW_ERROR); + } + + delta += (m - n) * handledCPCountPlusOne; + n = m; + + for (i = 0; i < input.length; i++) { + currentValue = input[i]; + if (currentValue < n && ++delta > maxInt) { + throw RangeError(OVERFLOW_ERROR); + } + if (currentValue == n) { + // Represent delta as a generalized variable-length integer. + var q = delta; + for (var k = base; /* no condition */; k += base) { + var t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); + if (q < t) { + break; + } + var qMinusT = q - t; + var baseMinusT = base - t; + output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT))); + q = floor$6(qMinusT / baseMinusT); + } + + output.push(stringFromCharCode(digitToBasic(q))); + bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); + delta = 0; + ++handledCPCount; + } + } + + ++delta; + ++n; + } + return output.join(''); +}; + +var punycodeToAscii = function (input) { + var encoded = []; + var labels = input.toLowerCase().replace(regexSeparators, '\u002E').split('.'); + var i, label; + for (i = 0; i < labels.length; i++) { + label = labels[i]; + encoded.push(regexNonASCII.test(label) ? 'xn--' + encode(label) : label); + } + return encoded.join('.'); +}; + +var getIterator = function (it) { + var iteratorMethod = getIteratorMethod(it); + if (typeof iteratorMethod != 'function') { + throw TypeError(String(it) + ' is not iterable'); + } return anObject(iteratorMethod.call(it)); +}; + +var ITERATOR$7 = wellKnownSymbol('iterator'); +var URL_SEARCH_PARAMS = 'URLSearchParams'; +var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator'; +var setInternalState$7 = internalState.set; +var getInternalParamsState = internalState.getterFor(URL_SEARCH_PARAMS); +var getInternalIteratorState = internalState.getterFor(URL_SEARCH_PARAMS_ITERATOR); + +var plus = /\+/g; +var sequences = Array(4); + +var percentSequence = function (bytes) { + return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi')); +}; + +var percentDecode = function (sequence) { + try { + return decodeURIComponent(sequence); + } catch (error) { + return sequence; + } +}; + +var deserialize = function (it) { + var result = it.replace(plus, ' '); + var bytes = 4; + try { + return decodeURIComponent(result); + } catch (error) { + while (bytes) { + result = result.replace(percentSequence(bytes--), percentDecode); + } + return result; + } +}; + +var find = /[!'()~]|%20/g; + +var replace = { + '!': '%21', + "'": '%27', + '(': '%28', + ')': '%29', + '~': '%7E', + '%20': '+' +}; + +var replacer = function (match) { + return replace[match]; +}; + +var serialize = function (it) { + return encodeURIComponent(it).replace(find, replacer); +}; + +var parseSearchParams = function (result, query) { + if (query) { + var attributes = query.split('&'); + var i = 0; + var attribute, entry; + while (i < attributes.length) { + attribute = attributes[i++]; + if (attribute.length) { + entry = attribute.split('='); + result.push({ + key: deserialize(entry.shift()), + value: deserialize(entry.join('=')) + }); + } + } + } return result; +}; + +var updateSearchParams = function (query) { + this.entries.length = 0; + parseSearchParams(this.entries, query); +}; + +var validateArgumentsLength = function (passed, required) { + if (passed < required) throw TypeError('Not enough arguments'); +}; + +var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) { + setInternalState$7(this, { + type: URL_SEARCH_PARAMS_ITERATOR, + iterator: getIterator(getInternalParamsState(params).entries), + kind: kind + }); +}, 'Iterator', function next() { + var state = getInternalIteratorState(this); + var kind = state.kind; + var step = state.iterator.next(); + var entry = step.value; + if (!step.done) { + step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value]; + } return step; +}); + +// `URLSearchParams` constructor +// https://url.spec.whatwg.org/#interface-urlsearchparams +var URLSearchParamsConstructor = function URLSearchParams(/* init */) { + anInstance(this, URLSearchParamsConstructor, URL_SEARCH_PARAMS); + var init = arguments.length > 0 ? arguments[0] : undefined; + var that = this; + var entries = []; + var iteratorMethod, iterator, step, entryIterator, first, second, key; + + setInternalState$7(that, { + type: URL_SEARCH_PARAMS, + entries: entries, + updateURL: null, + updateSearchParams: updateSearchParams + }); + + if (init !== undefined) { + if (isObject(init)) { + iteratorMethod = getIteratorMethod(init); + if (typeof iteratorMethod === 'function') { + iterator = iteratorMethod.call(init); + while (!(step = iterator.next()).done) { + entryIterator = getIterator(anObject(step.value)); + if ( + (first = entryIterator.next()).done || + (second = entryIterator.next()).done || + !entryIterator.next().done + ) throw TypeError('Expected sequence with length 2'); + entries.push({ key: first.value + '', value: second.value + '' }); + } + } else for (key in init) if (has(init, key)) entries.push({ key: key, value: init[key] + '' }); + } else { + parseSearchParams(entries, typeof init === 'string' ? init.charAt(0) === '?' ? init.slice(1) : init : init + ''); + } + } +}; + +var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype; + +redefineAll(URLSearchParamsPrototype, { + // `URLSearchParams.prototype.appent` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-append + append: function append(name, value) { + validateArgumentsLength(arguments.length, 2); + var state = getInternalParamsState(this); + state.entries.push({ key: name + '', value: value + '' }); + if (state.updateURL) state.updateURL(); + }, + // `URLSearchParams.prototype.delete` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-delete + 'delete': function (name) { + validateArgumentsLength(arguments.length, 1); + var state = getInternalParamsState(this); + var entries = state.entries; + var key = name + ''; + var i = 0; + while (i < entries.length) { + if (entries[i].key === key) entries.splice(i, 1); + else i++; + } + if (state.updateURL) state.updateURL(); + }, + // `URLSearchParams.prototype.get` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-get + get: function get(name) { + validateArgumentsLength(arguments.length, 1); + var entries = getInternalParamsState(this).entries; + var key = name + ''; + var i = 0; + for (; i < entries.length; i++) if (entries[i].key === key) return entries[i].value; + return null; + }, + // `URLSearchParams.prototype.getAll` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-getall + getAll: function getAll(name) { + validateArgumentsLength(arguments.length, 1); + var entries = getInternalParamsState(this).entries; + var key = name + ''; + var result = []; + var i = 0; + for (; i < entries.length; i++) if (entries[i].key === key) result.push(entries[i].value); + return result; + }, + // `URLSearchParams.prototype.has` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-has + has: function has(name) { + validateArgumentsLength(arguments.length, 1); + var entries = getInternalParamsState(this).entries; + var key = name + ''; + var i = 0; + while (i < entries.length) if (entries[i++].key === key) return true; + return false; + }, + // `URLSearchParams.prototype.set` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-set + set: function set(name, value) { + validateArgumentsLength(arguments.length, 1); + var state = getInternalParamsState(this); + var entries = state.entries; + var found = false; + var key = name + ''; + var val = value + ''; + var i = 0; + var entry; + for (; i < entries.length; i++) { + entry = entries[i]; + if (entry.key === key) { + if (found) entries.splice(i--, 1); + else { + found = true; + entry.value = val; + } + } + } + if (!found) entries.push({ key: key, value: val }); + if (state.updateURL) state.updateURL(); + }, + // `URLSearchParams.prototype.sort` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-sort + sort: function sort() { + var state = getInternalParamsState(this); + var entries = state.entries; + // Array#sort is not stable in some engines + var slice = entries.slice(); + var entry, i, j; + entries.length = 0; + for (i = 0; i < slice.length; i++) { + entry = slice[i]; + for (j = 0; j < i; j++) if (entries[j].key > entry.key) { + entries.splice(j, 0, entry); + break; + } + if (j === i) entries.push(entry); + } + if (state.updateURL) state.updateURL(); + }, + // `URLSearchParams.prototype.forEach` method + forEach: function forEach(callback /* , thisArg */) { + var entries = getInternalParamsState(this).entries; + var boundFunction = bindContext(callback, arguments.length > 1 ? arguments[1] : undefined, 3); + var i = 0; + var entry; + while (i < entries.length) { + entry = entries[i++]; + boundFunction(entry.value, entry.key, this); + } + }, + // `URLSearchParams.prototype.keys` method + keys: function keys() { + return new URLSearchParamsIterator(this, 'keys'); + }, + // `URLSearchParams.prototype.values` method + values: function values() { + return new URLSearchParamsIterator(this, 'values'); + }, + // `URLSearchParams.prototype.entries` method + entries: function entries() { + return new URLSearchParamsIterator(this, 'entries'); + } +}, { enumerable: true }); + +// `URLSearchParams.prototype[@@iterator]` method +redefine(URLSearchParamsPrototype, ITERATOR$7, URLSearchParamsPrototype.entries); + +// `URLSearchParams.prototype.toString` method +// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior +redefine(URLSearchParamsPrototype, 'toString', function toString() { + var entries = getInternalParamsState(this).entries; + var result = []; + var i = 0; + var entry; + while (i < entries.length) { + entry = entries[i++]; + result.push(serialize(entry.key) + '=' + serialize(entry.value)); + } return result.join('&'); +}, { enumerable: true }); + +setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS); + +_export({ global: true, forced: !nativeUrl }, { + URLSearchParams: URLSearchParamsConstructor +}); + +var web_urlSearchParams = { + URLSearchParams: URLSearchParamsConstructor, + getState: getInternalParamsState +}; + +var NativeURL = global_1.URL; +var URLSearchParams$1 = web_urlSearchParams.URLSearchParams; +var getInternalSearchParamsState = web_urlSearchParams.getState; +var setInternalState$8 = internalState.set; +var getInternalURLState = internalState.getterFor('URL'); +var pow$3 = Math.pow; + +var INVALID_AUTHORITY = 'Invalid authority'; +var INVALID_SCHEME = 'Invalid scheme'; +var INVALID_HOST = 'Invalid host'; +var INVALID_PORT = 'Invalid port'; + +var ALPHA = /[A-Za-z]/; +var ALPHANUMERIC = /[\d+\-.A-Za-z]/; +var DIGIT = /\d/; +var HEX_START = /^(0x|0X)/; +var OCT = /^[0-7]+$/; +var DEC = /^\d+$/; +var HEX = /^[\dA-Fa-f]+$/; +// eslint-disable-next-line no-control-regex +var FORBIDDEN_HOST_CODE_POINT = /[\u0000\u0009\u000A\u000D #%/:?@[\\]]/; +// eslint-disable-next-line no-control-regex +var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\u0000\u0009\u000A\u000D #/:?@[\\]]/; +// eslint-disable-next-line no-control-regex +var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u001F ]+|[\u0000-\u001F ]+$/g; +// eslint-disable-next-line no-control-regex +var TAB_AND_NEW_LINE = /[\u0009\u000A\u000D]/g; +var EOF; + +var parseHost = function (url, input) { + var result, codePoints, i; + if (input.charAt(0) == '[') { + if (input.charAt(input.length - 1) != ']') return INVALID_HOST; + result = parseIPv6(input.slice(1, -1)); + if (!result) return INVALID_HOST; + url.host = result; + // opaque host + } else if (!isSpecial(url)) { + if (FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT.test(input)) return INVALID_HOST; + result = ''; + codePoints = arrayFrom(input); + for (i = 0; i < codePoints.length; i++) result += percentEncode(codePoints[i], C0ControlPercentEncodeSet); + url.host = result; + } else { + input = punycodeToAscii(input); + if (FORBIDDEN_HOST_CODE_POINT.test(input)) return INVALID_HOST; + result = parseIPv4(input); + if (result === null) return INVALID_HOST; + url.host = result; + } +}; + +var parseIPv4 = function (input) { + var parts = input.split('.'); + var partsLength, numbers, i, part, R, n, ipv4; + if (parts[parts.length - 1] == '') { + if (parts.length) parts.pop(); + } + partsLength = parts.length; + if (partsLength > 4) return input; + numbers = []; + for (i = 0; i < partsLength; i++) { + part = parts[i]; + if (part == '') return input; + R = 10; + if (part.length > 1 && part.charAt(0) == '0') { + R = HEX_START.test(part) ? 16 : 8; + part = part.slice(R == 8 ? 1 : 2); + } + if (part === '') { + n = 0; + } else { + if (!(R == 10 ? DEC : R == 8 ? OCT : HEX).test(part)) return input; + n = parseInt(part, R); + } + numbers.push(n); + } + for (i = 0; i < partsLength; i++) { + n = numbers[i]; + if (i == partsLength - 1) { + if (n >= pow$3(256, 5 - partsLength)) return null; + } else if (n > 255) return null; + } + ipv4 = numbers.pop(); + for (i = 0; i < numbers.length; i++) { + ipv4 += numbers[i] * pow$3(256, 3 - i); + } + return ipv4; +}; + +// eslint-disable-next-line max-statements +var parseIPv6 = function (input) { + var address = [0, 0, 0, 0, 0, 0, 0, 0]; + var pieceIndex = 0; + var compress = null; + var pointer = 0; + var value, length, numbersSeen, ipv4Piece, number, swaps, swap; + + var char = function () { + return input.charAt(pointer); + }; + + if (char() == ':') { + if (input.charAt(1) != ':') return; + pointer += 2; + pieceIndex++; + compress = pieceIndex; + } + while (char()) { + if (pieceIndex == 8) return; + if (char() == ':') { + if (compress !== null) return; + pointer++; + pieceIndex++; + compress = pieceIndex; + continue; + } + value = length = 0; + while (length < 4 && HEX.test(char())) { + value = value * 16 + parseInt(char(), 16); + pointer++; + length++; + } + if (char() == '.') { + if (length == 0) return; + pointer -= length; + if (pieceIndex > 6) return; + numbersSeen = 0; + while (char()) { + ipv4Piece = null; + if (numbersSeen > 0) { + if (char() == '.' && numbersSeen < 4) pointer++; + else return; + } + if (!DIGIT.test(char())) return; + while (DIGIT.test(char())) { + number = parseInt(char(), 10); + if (ipv4Piece === null) ipv4Piece = number; + else if (ipv4Piece == 0) return; + else ipv4Piece = ipv4Piece * 10 + number; + if (ipv4Piece > 255) return; + pointer++; + } + address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece; + numbersSeen++; + if (numbersSeen == 2 || numbersSeen == 4) pieceIndex++; + } + if (numbersSeen != 4) return; + break; + } else if (char() == ':') { + pointer++; + if (!char()) return; + } else if (char()) return; + address[pieceIndex++] = value; + } + if (compress !== null) { + swaps = pieceIndex - compress; + pieceIndex = 7; + while (pieceIndex != 0 && swaps > 0) { + swap = address[pieceIndex]; + address[pieceIndex--] = address[compress + swaps - 1]; + address[compress + --swaps] = swap; + } + } else if (pieceIndex != 8) return; + return address; +}; + +var findLongestZeroSequence = function (ipv6) { + var maxIndex = null; + var maxLength = 1; + var currStart = null; + var currLength = 0; + var i = 0; + for (; i < 8; i++) { + if (ipv6[i] !== 0) { + if (currLength > maxLength) { + maxIndex = currStart; + maxLength = currLength; + } + currStart = null; + currLength = 0; + } else { + if (currStart === null) currStart = i; + ++currLength; + } + } + if (currLength > maxLength) { + maxIndex = currStart; + maxLength = currLength; + } + return maxIndex; +}; + +var serializeHost = function (host) { + var result, i, compress, ignore0; + // ipv4 + if (typeof host == 'number') { + result = []; + for (i = 0; i < 4; i++) { + result.unshift(host % 256); + host = Math.floor(host / 256); + } return result.join('.'); + // ipv6 + } else if (typeof host == 'object') { + result = ''; + compress = findLongestZeroSequence(host); + for (i = 0; i < 8; i++) { + if (ignore0 && host[i] === 0) continue; + if (ignore0) ignore0 = false; + if (compress === i) { + result += i ? ':' : '::'; + ignore0 = true; + } else { + result += host[i].toString(16); + if (i < 7) result += ':'; + } + } + return '[' + result + ']'; + } return host; +}; + +var C0ControlPercentEncodeSet = {}; +var fragmentPercentEncodeSet = objectAssign({}, C0ControlPercentEncodeSet, { + ' ': 1, '"': 1, '<': 1, '>': 1, '`': 1 +}); +var pathPercentEncodeSet = objectAssign({}, fragmentPercentEncodeSet, { + '#': 1, '?': 1, '{': 1, '}': 1 +}); +var userinfoPercentEncodeSet = objectAssign({}, pathPercentEncodeSet, { + '/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\': 1, ']': 1, '^': 1, '|': 1 +}); + +var percentEncode = function (char, set) { + var code = stringAt(char, 0); + return code > 0x20 && code < 0x7F && !has(set, char) ? char : encodeURIComponent(char); +}; + +var specialSchemes = { + ftp: 21, + file: null, + gopher: 70, + http: 80, + https: 443, + ws: 80, + wss: 443 +}; + +var isSpecial = function (url) { + return has(specialSchemes, url.scheme); +}; + +var includesCredentials = function (url) { + return url.username != '' || url.password != ''; +}; + +var cannotHaveUsernamePasswordPort = function (url) { + return !url.host || url.cannotBeABaseURL || url.scheme == 'file'; +}; + +var isWindowsDriveLetter = function (string, normalized) { + var second; + return string.length == 2 && ALPHA.test(string.charAt(0)) + && ((second = string.charAt(1)) == ':' || (!normalized && second == '|')); +}; + +var startsWithWindowsDriveLetter = function (string) { + var third; + return string.length > 1 && isWindowsDriveLetter(string.slice(0, 2)) && ( + string.length == 2 || + ((third = string.charAt(2)) === '/' || third === '\\' || third === '?' || third === '#') + ); +}; + +var shortenURLsPath = function (url) { + var path = url.path; + var pathSize = path.length; + if (pathSize && (url.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) { + path.pop(); + } +}; + +var isSingleDot = function (segment) { + return segment === '.' || segment.toLowerCase() === '%2e'; +}; + +var isDoubleDot = function (segment) { + segment = segment.toLowerCase(); + return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e'; +}; + +// States: +var SCHEME_START = {}; +var SCHEME = {}; +var NO_SCHEME = {}; +var SPECIAL_RELATIVE_OR_AUTHORITY = {}; +var PATH_OR_AUTHORITY = {}; +var RELATIVE = {}; +var RELATIVE_SLASH = {}; +var SPECIAL_AUTHORITY_SLASHES = {}; +var SPECIAL_AUTHORITY_IGNORE_SLASHES = {}; +var AUTHORITY = {}; +var HOST = {}; +var HOSTNAME = {}; +var PORT = {}; +var FILE = {}; +var FILE_SLASH = {}; +var FILE_HOST = {}; +var PATH_START = {}; +var PATH = {}; +var CANNOT_BE_A_BASE_URL_PATH = {}; +var QUERY = {}; +var FRAGMENT = {}; + +// eslint-disable-next-line max-statements +var parseURL = function (url, input, stateOverride, base) { + var state = stateOverride || SCHEME_START; + var pointer = 0; + var buffer = ''; + var seenAt = false; + var seenBracket = false; + var seenPasswordToken = false; + var codePoints, char, bufferCodePoints, failure; + + if (!stateOverride) { + url.scheme = ''; + url.username = ''; + url.password = ''; + url.host = null; + url.port = null; + url.path = []; + url.query = null; + url.fragment = null; + url.cannotBeABaseURL = false; + input = input.replace(LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, ''); + } + + input = input.replace(TAB_AND_NEW_LINE, ''); + + codePoints = arrayFrom(input); + + while (pointer <= codePoints.length) { + char = codePoints[pointer]; + switch (state) { + case SCHEME_START: + if (char && ALPHA.test(char)) { + buffer += char.toLowerCase(); + state = SCHEME; + } else if (!stateOverride) { + state = NO_SCHEME; + continue; + } else return INVALID_SCHEME; + break; + + case SCHEME: + if (char && (ALPHANUMERIC.test(char) || char == '+' || char == '-' || char == '.')) { + buffer += char.toLowerCase(); + } else if (char == ':') { + if (stateOverride) { + if ( + (isSpecial(url) != has(specialSchemes, buffer)) || + (buffer == 'file' && (includesCredentials(url) || url.port !== null)) || + (url.scheme == 'file' && !url.host) + ) return; + } + url.scheme = buffer; + if (stateOverride) { + if (isSpecial(url) && specialSchemes[url.scheme] == url.port) url.port = null; + return; + } + buffer = ''; + if (url.scheme == 'file') { + state = FILE; + } else if (isSpecial(url) && base && base.scheme == url.scheme) { + state = SPECIAL_RELATIVE_OR_AUTHORITY; + } else if (isSpecial(url)) { + state = SPECIAL_AUTHORITY_SLASHES; + } else if (codePoints[pointer + 1] == '/') { + state = PATH_OR_AUTHORITY; + pointer++; + } else { + url.cannotBeABaseURL = true; + url.path.push(''); + state = CANNOT_BE_A_BASE_URL_PATH; + } + } else if (!stateOverride) { + buffer = ''; + state = NO_SCHEME; + pointer = 0; + continue; + } else return INVALID_SCHEME; + break; + + case NO_SCHEME: + if (!base || (base.cannotBeABaseURL && char != '#')) return INVALID_SCHEME; + if (base.cannotBeABaseURL && char == '#') { + url.scheme = base.scheme; + url.path = base.path.slice(); + url.query = base.query; + url.fragment = ''; + url.cannotBeABaseURL = true; + state = FRAGMENT; + break; + } + state = base.scheme == 'file' ? FILE : RELATIVE; + continue; + + case SPECIAL_RELATIVE_OR_AUTHORITY: + if (char == '/' && codePoints[pointer + 1] == '/') { + state = SPECIAL_AUTHORITY_IGNORE_SLASHES; + pointer++; + } else { + state = RELATIVE; + continue; + } break; + + case PATH_OR_AUTHORITY: + if (char == '/') { + state = AUTHORITY; + break; + } else { + state = PATH; + continue; + } + + case RELATIVE: + url.scheme = base.scheme; + if (char == EOF) { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = base.path.slice(); + url.query = base.query; + } else if (char == '/' || (char == '\\' && isSpecial(url))) { + state = RELATIVE_SLASH; + } else if (char == '?') { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = base.path.slice(); + url.query = ''; + state = QUERY; + } else if (char == '#') { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = base.path.slice(); + url.query = base.query; + url.fragment = ''; + state = FRAGMENT; + } else { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = base.path.slice(); + url.path.pop(); + state = PATH; + continue; + } break; + + case RELATIVE_SLASH: + if (isSpecial(url) && (char == '/' || char == '\\')) { + state = SPECIAL_AUTHORITY_IGNORE_SLASHES; + } else if (char == '/') { + state = AUTHORITY; + } else { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + state = PATH; + continue; + } break; + + case SPECIAL_AUTHORITY_SLASHES: + state = SPECIAL_AUTHORITY_IGNORE_SLASHES; + if (char != '/' || buffer.charAt(pointer + 1) != '/') continue; + pointer++; + break; + + case SPECIAL_AUTHORITY_IGNORE_SLASHES: + if (char != '/' && char != '\\') { + state = AUTHORITY; + continue; + } break; + + case AUTHORITY: + if (char == '@') { + if (seenAt) buffer = '%40' + buffer; + seenAt = true; + bufferCodePoints = arrayFrom(buffer); + for (var i = 0; i < bufferCodePoints.length; i++) { + var codePoint = bufferCodePoints[i]; + if (codePoint == ':' && !seenPasswordToken) { + seenPasswordToken = true; + continue; + } + var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet); + if (seenPasswordToken) url.password += encodedCodePoints; + else url.username += encodedCodePoints; + } + buffer = ''; + } else if ( + char == EOF || char == '/' || char == '?' || char == '#' || + (char == '\\' && isSpecial(url)) + ) { + if (seenAt && buffer == '') return INVALID_AUTHORITY; + pointer -= arrayFrom(buffer).length + 1; + buffer = ''; + state = HOST; + } else buffer += char; + break; + + case HOST: + case HOSTNAME: + if (stateOverride && url.scheme == 'file') { + state = FILE_HOST; + continue; + } else if (char == ':' && !seenBracket) { + if (buffer == '') return INVALID_HOST; + failure = parseHost(url, buffer); + if (failure) return failure; + buffer = ''; + state = PORT; + if (stateOverride == HOSTNAME) return; + } else if ( + char == EOF || char == '/' || char == '?' || char == '#' || + (char == '\\' && isSpecial(url)) + ) { + if (isSpecial(url) && buffer == '') return INVALID_HOST; + if (stateOverride && buffer == '' && (includesCredentials(url) || url.port !== null)) return; + failure = parseHost(url, buffer); + if (failure) return failure; + buffer = ''; + state = PATH_START; + if (stateOverride) return; + continue; + } else { + if (char == '[') seenBracket = true; + else if (char == ']') seenBracket = false; + buffer += char; + } break; + + case PORT: + if (DIGIT.test(char)) { + buffer += char; + } else if ( + char == EOF || char == '/' || char == '?' || char == '#' || + (char == '\\' && isSpecial(url)) || + stateOverride + ) { + if (buffer != '') { + var port = parseInt(buffer, 10); + if (port > 0xFFFF) return INVALID_PORT; + url.port = (isSpecial(url) && port === specialSchemes[url.scheme]) ? null : port; + buffer = ''; + } + if (stateOverride) return; + state = PATH_START; + continue; + } else return INVALID_PORT; + break; + + case FILE: + url.scheme = 'file'; + if (char == '/' || char == '\\') state = FILE_SLASH; + else if (base && base.scheme == 'file') { + if (char == EOF) { + url.host = base.host; + url.path = base.path.slice(); + url.query = base.query; + } else if (char == '?') { + url.host = base.host; + url.path = base.path.slice(); + url.query = ''; + state = QUERY; + } else if (char == '#') { + url.host = base.host; + url.path = base.path.slice(); + url.query = base.query; + url.fragment = ''; + state = FRAGMENT; + } else { + if (!startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) { + url.host = base.host; + url.path = base.path.slice(); + shortenURLsPath(url); + } + state = PATH; + continue; + } + } else { + state = PATH; + continue; + } break; + + case FILE_SLASH: + if (char == '/' || char == '\\') { + state = FILE_HOST; + break; + } + if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) { + if (isWindowsDriveLetter(base.path[0], true)) url.path.push(base.path[0]); + else url.host = base.host; + } + state = PATH; + continue; + + case FILE_HOST: + if (char == EOF || char == '/' || char == '\\' || char == '?' || char == '#') { + if (!stateOverride && isWindowsDriveLetter(buffer)) { + state = PATH; + } else if (buffer == '') { + url.host = ''; + if (stateOverride) return; + state = PATH_START; + } else { + failure = parseHost(url, buffer); + if (failure) return failure; + if (url.host == 'localhost') url.host = ''; + if (stateOverride) return; + buffer = ''; + state = PATH_START; + } continue; + } else buffer += char; + break; + + case PATH_START: + if (isSpecial(url)) { + state = PATH; + if (char != '/' && char != '\\') continue; + } else if (!stateOverride && char == '?') { + url.query = ''; + state = QUERY; + } else if (!stateOverride && char == '#') { + url.fragment = ''; + state = FRAGMENT; + } else if (char != EOF) { + state = PATH; + if (char != '/') continue; + } break; + + case PATH: + if ( + char == EOF || char == '/' || + (char == '\\' && isSpecial(url)) || + (!stateOverride && (char == '?' || char == '#')) + ) { + if (isDoubleDot(buffer)) { + shortenURLsPath(url); + if (char != '/' && !(char == '\\' && isSpecial(url))) { + url.path.push(''); + } + } else if (isSingleDot(buffer)) { + if (char != '/' && !(char == '\\' && isSpecial(url))) { + url.path.push(''); + } + } else { + if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) { + if (url.host) url.host = ''; + buffer = buffer.charAt(0) + ':'; // normalize windows drive letter + } + url.path.push(buffer); + } + buffer = ''; + if (url.scheme == 'file' && (char == EOF || char == '?' || char == '#')) { + while (url.path.length > 1 && url.path[0] === '') { + url.path.shift(); + } + } + if (char == '?') { + url.query = ''; + state = QUERY; + } else if (char == '#') { + url.fragment = ''; + state = FRAGMENT; + } + } else { + buffer += percentEncode(char, pathPercentEncodeSet); + } break; + + case CANNOT_BE_A_BASE_URL_PATH: + if (char == '?') { + url.query = ''; + state = QUERY; + } else if (char == '#') { + url.fragment = ''; + state = FRAGMENT; + } else if (char != EOF) { + url.path[0] += percentEncode(char, C0ControlPercentEncodeSet); + } break; + + case QUERY: + if (!stateOverride && char == '#') { + url.fragment = ''; + state = FRAGMENT; + } else if (char != EOF) { + if (char == "'" && isSpecial(url)) url.query += '%27'; + else if (char == '#') url.query += '%23'; + else url.query += percentEncode(char, C0ControlPercentEncodeSet); + } break; + + case FRAGMENT: + if (char != EOF) url.fragment += percentEncode(char, fragmentPercentEncodeSet); + break; + } + + pointer++; + } +}; + +// `URL` constructor +// https://url.spec.whatwg.org/#url-class +var URLConstructor = function URL(url /* , base */) { + var that = anInstance(this, URLConstructor, 'URL'); + var base = arguments.length > 1 ? arguments[1] : undefined; + var urlString = String(url); + var state = setInternalState$8(that, { type: 'URL' }); + var baseState, failure; + if (base !== undefined) { + if (base instanceof URLConstructor) baseState = getInternalURLState(base); + else { + failure = parseURL(baseState = {}, String(base)); + if (failure) throw TypeError(failure); + } + } + failure = parseURL(state, urlString, null, baseState); + if (failure) throw TypeError(failure); + var searchParams = state.searchParams = new URLSearchParams$1(); + var searchParamsState = getInternalSearchParamsState(searchParams); + searchParamsState.updateSearchParams(state.query); + searchParamsState.updateURL = function () { + state.query = String(searchParams) || null; + }; + if (!descriptors) { + that.href = serializeURL.call(that); + that.origin = getOrigin.call(that); + that.protocol = getProtocol.call(that); + that.username = getUsername.call(that); + that.password = getPassword.call(that); + that.host = getHost.call(that); + that.hostname = getHostname.call(that); + that.port = getPort.call(that); + that.pathname = getPathname.call(that); + that.search = getSearch.call(that); + that.searchParams = getSearchParams.call(that); + that.hash = getHash.call(that); + } +}; + +var URLPrototype = URLConstructor.prototype; + +var serializeURL = function () { + var url = getInternalURLState(this); + var scheme = url.scheme; + var username = url.username; + var password = url.password; + var host = url.host; + var port = url.port; + var path = url.path; + var query = url.query; + var fragment = url.fragment; + var output = scheme + ':'; + if (host !== null) { + output += '//'; + if (includesCredentials(url)) { + output += username + (password ? ':' + password : '') + '@'; + } + output += serializeHost(host); + if (port !== null) output += ':' + port; + } else if (scheme == 'file') output += '//'; + output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : ''; + if (query !== null) output += '?' + query; + if (fragment !== null) output += '#' + fragment; + return output; +}; + +var getOrigin = function () { + var url = getInternalURLState(this); + var scheme = url.scheme; + var port = url.port; + if (scheme == 'blob') try { + return new URL(scheme.path[0]).origin; + } catch (error) { + return 'null'; + } + if (scheme == 'file' || !isSpecial(url)) return 'null'; + return scheme + '://' + serializeHost(url.host) + (port !== null ? ':' + port : ''); +}; + +var getProtocol = function () { + return getInternalURLState(this).scheme + ':'; +}; + +var getUsername = function () { + return getInternalURLState(this).username; +}; + +var getPassword = function () { + return getInternalURLState(this).password; +}; + +var getHost = function () { + var url = getInternalURLState(this); + var host = url.host; + var port = url.port; + return host === null ? '' + : port === null ? serializeHost(host) + : serializeHost(host) + ':' + port; +}; + +var getHostname = function () { + var host = getInternalURLState(this).host; + return host === null ? '' : serializeHost(host); +}; + +var getPort = function () { + var port = getInternalURLState(this).port; + return port === null ? '' : String(port); +}; + +var getPathname = function () { + var url = getInternalURLState(this); + var path = url.path; + return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : ''; +}; + +var getSearch = function () { + var query = getInternalURLState(this).query; + return query ? '?' + query : ''; +}; + +var getSearchParams = function () { + return getInternalURLState(this).searchParams; +}; + +var getHash = function () { + var fragment = getInternalURLState(this).fragment; + return fragment ? '#' + fragment : ''; +}; + +var accessorDescriptor = function (getter, setter) { + return { get: getter, set: setter, configurable: true, enumerable: true }; +}; + +if (descriptors) { + objectDefineProperties(URLPrototype, { + // `URL.prototype.href` accessors pair + // https://url.spec.whatwg.org/#dom-url-href + href: accessorDescriptor(serializeURL, function (href) { + var url = getInternalURLState(this); + var urlString = String(href); + var failure = parseURL(url, urlString); + if (failure) throw TypeError(failure); + getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query); + }), + // `URL.prototype.origin` getter + // https://url.spec.whatwg.org/#dom-url-origin + origin: accessorDescriptor(getOrigin), + // `URL.prototype.protocol` accessors pair + // https://url.spec.whatwg.org/#dom-url-protocol + protocol: accessorDescriptor(getProtocol, function (protocol) { + var url = getInternalURLState(this); + parseURL(url, String(protocol) + ':', SCHEME_START); + }), + // `URL.prototype.username` accessors pair + // https://url.spec.whatwg.org/#dom-url-username + username: accessorDescriptor(getUsername, function (username) { + var url = getInternalURLState(this); + var codePoints = arrayFrom(String(username)); + if (cannotHaveUsernamePasswordPort(url)) return; + url.username = ''; + for (var i = 0; i < codePoints.length; i++) { + url.username += percentEncode(codePoints[i], userinfoPercentEncodeSet); + } + }), + // `URL.prototype.password` accessors pair + // https://url.spec.whatwg.org/#dom-url-password + password: accessorDescriptor(getPassword, function (password) { + var url = getInternalURLState(this); + var codePoints = arrayFrom(String(password)); + if (cannotHaveUsernamePasswordPort(url)) return; + url.password = ''; + for (var i = 0; i < codePoints.length; i++) { + url.password += percentEncode(codePoints[i], userinfoPercentEncodeSet); + } + }), + // `URL.prototype.host` accessors pair + // https://url.spec.whatwg.org/#dom-url-host + host: accessorDescriptor(getHost, function (host) { + var url = getInternalURLState(this); + if (url.cannotBeABaseURL) return; + parseURL(url, String(host), HOST); + }), + // `URL.prototype.hostname` accessors pair + // https://url.spec.whatwg.org/#dom-url-hostname + hostname: accessorDescriptor(getHostname, function (hostname) { + var url = getInternalURLState(this); + if (url.cannotBeABaseURL) return; + parseURL(url, String(hostname), HOSTNAME); + }), + // `URL.prototype.port` accessors pair + // https://url.spec.whatwg.org/#dom-url-port + port: accessorDescriptor(getPort, function (port) { + var url = getInternalURLState(this); + if (cannotHaveUsernamePasswordPort(url)) return; + port = String(port); + if (port == '') url.port = null; + else parseURL(url, port, PORT); + }), + // `URL.prototype.pathname` accessors pair + // https://url.spec.whatwg.org/#dom-url-pathname + pathname: accessorDescriptor(getPathname, function (pathname) { + var url = getInternalURLState(this); + if (url.cannotBeABaseURL) return; + url.path = []; + parseURL(url, pathname + '', PATH_START); + }), + // `URL.prototype.search` accessors pair + // https://url.spec.whatwg.org/#dom-url-search + search: accessorDescriptor(getSearch, function (search) { + var url = getInternalURLState(this); + search = String(search); + if (search == '') { + url.query = null; + } else { + if ('?' == search.charAt(0)) search = search.slice(1); + url.query = ''; + parseURL(url, search, QUERY); + } + getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query); + }), + // `URL.prototype.searchParams` getter + // https://url.spec.whatwg.org/#dom-url-searchparams + searchParams: accessorDescriptor(getSearchParams), + // `URL.prototype.hash` accessors pair + // https://url.spec.whatwg.org/#dom-url-hash + hash: accessorDescriptor(getHash, function (hash) { + var url = getInternalURLState(this); + hash = String(hash); + if (hash == '') { + url.fragment = null; + return; + } + if ('#' == hash.charAt(0)) hash = hash.slice(1); + url.fragment = ''; + parseURL(url, hash, FRAGMENT); + }) + }); +} + +// `URL.prototype.toJSON` method +// https://url.spec.whatwg.org/#dom-url-tojson +redefine(URLPrototype, 'toJSON', function toJSON() { + return serializeURL.call(this); +}, { enumerable: true }); + +// `URL.prototype.toString` method +// https://url.spec.whatwg.org/#URL-stringification-behavior +redefine(URLPrototype, 'toString', function toString() { + return serializeURL.call(this); +}, { enumerable: true }); + +if (NativeURL) { + var nativeCreateObjectURL = NativeURL.createObjectURL; + var nativeRevokeObjectURL = NativeURL.revokeObjectURL; + // `URL.createObjectURL` method + // https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL + // eslint-disable-next-line no-unused-vars + if (nativeCreateObjectURL) redefine(URLConstructor, 'createObjectURL', function createObjectURL(blob) { + return nativeCreateObjectURL.apply(NativeURL, arguments); + }); + // `URL.revokeObjectURL` method + // https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL + // eslint-disable-next-line no-unused-vars + if (nativeRevokeObjectURL) redefine(URLConstructor, 'revokeObjectURL', function revokeObjectURL(url) { + return nativeRevokeObjectURL.apply(NativeURL, arguments); + }); +} + +setToStringTag(URLConstructor, 'URL'); + +_export({ global: true, forced: !nativeUrl, sham: !descriptors }, { + URL: URLConstructor +}); + +// `URL.prototype.toJSON` method +// https://url.spec.whatwg.org/#dom-url-tojson +_export({ target: 'URL', proto: true, enumerable: true }, { + toJSON: function toJSON() { + return URL.prototype.toString.call(this); + } +}); + +var defineProperty$8 = objectDefineProperty.f; + +// `Array.prototype.lastIndex` getter +// https://github.com/keithamus/proposal-array-last +if (descriptors && !('lastIndex' in [])) { + defineProperty$8(Array.prototype, 'lastIndex', { + configurable: true, + get: function lastIndex() { + var O = toObject(this); + var len = toLength(O.length); + return len == 0 ? 0 : len - 1; + } + }); + + addToUnscopables('lastIndex'); +} + +var defineProperty$9 = objectDefineProperty.f; + +// `Array.prototype.lastIndex` accessor +// https://github.com/keithamus/proposal-array-last +if (descriptors && !('lastItem' in [])) { + defineProperty$9(Array.prototype, 'lastItem', { + configurable: true, + get: function lastItem() { + var O = toObject(this); + var len = toLength(O.length); + return len == 0 ? undefined : O[len - 1]; + }, + set: function lastItem(value) { + var O = toObject(this); + var len = toLength(O.length); + return O[len == 0 ? 0 : len - 1] = value; + } + }); + + addToUnscopables('lastItem'); +} + +// `Map.groupBy` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', stat: true }, { + groupBy: function groupBy(iterable, keyDerivative) { + var newMap = new this(); + aFunction(keyDerivative); + var has = aFunction(newMap.has); + var get = aFunction(newMap.get); + var set = aFunction(newMap.set); + iterate(iterable, function (element) { + var derivedKey = keyDerivative(element); + if (!has.call(newMap, derivedKey)) set.call(newMap, derivedKey, [element]); + else get.call(newMap, derivedKey).push(element); + }); + return newMap; + } +}); + +// `Map.keyBy` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', stat: true }, { + keyBy: function keyBy(iterable, keyDerivative) { + var newMap = new this(); + aFunction(keyDerivative); + var setter = aFunction(newMap.set); + iterate(iterable, function (element) { + setter.call(newMap, keyDerivative(element), element); + }); + return newMap; + } +}); + +// https://github.com/tc39/collection-methods +var collectionDeleteAll = function (/* ...elements */) { + var collection = anObject(this); + var remover = aFunction(collection['delete']); + var allDeleted = true; + for (var k = 0, len = arguments.length; k < len; k++) { + allDeleted = allDeleted && remover.call(collection, arguments[k]); + } + return !!allDeleted; +}; + +// `Map.prototype.deleteAll` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + deleteAll: function deleteAll(/* ...elements */) { + return collectionDeleteAll.apply(this, arguments); + } +}); + +var getMapIterator = function (it) { + // eslint-disable-next-line no-undef + return Map.prototype.entries.call(it); +}; + +// `Map.prototype.every` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + every: function every(callbackfn /* , thisArg */) { + var map = anObject(this); + var iterator = getMapIterator(map); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var step, entry; + while (!(step = iterator.next()).done) { + entry = step.value; + if (!boundFunction(entry[1], entry[0], map)) return false; + } return true; + } +}); + +// `Map.prototype.filter` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + filter: function filter(callbackfn /* , thisArg */) { + var map = anObject(this); + var iterator = getMapIterator(map); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var newMap = new (speciesConstructor(map, getBuiltIn('Map')))(); + var setter = aFunction(newMap.set); + var step, entry, key, value; + while (!(step = iterator.next()).done) { + entry = step.value; + if (boundFunction(value = entry[1], key = entry[0], map)) setter.call(newMap, key, value); + } + return newMap; + } +}); + +// `Map.prototype.find` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + find: function find(callbackfn /* , thisArg */) { + var map = anObject(this); + var iterator = getMapIterator(map); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var step, entry, value; + while (!(step = iterator.next()).done) { + entry = step.value; + if (boundFunction(value = entry[1], entry[0], map)) return value; + } + } +}); + +// `Map.prototype.findKey` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + findKey: function findKey(callbackfn /* , thisArg */) { + var map = anObject(this); + var iterator = getMapIterator(map); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var step, entry, key; + while (!(step = iterator.next()).done) { + entry = step.value; + if (boundFunction(entry[1], key = entry[0], map)) return key; + } + } +}); + +// `SameValueZero` abstract operation +// https://tc39.github.io/ecma262/#sec-samevaluezero +var sameValueZero = function (x, y) { + // eslint-disable-next-line no-self-compare + return x === y || x != x && y != y; +}; + +// `Map.prototype.includes` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + includes: function includes(searchElement) { + var map = anObject(this); + var iterator = getMapIterator(map); + var step; + while (!(step = iterator.next()).done) { + if (sameValueZero(step.value[1], searchElement)) return true; + } + return false; + } +}); + +// `Map.prototype.includes` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + keyOf: function keyOf(searchElement) { + var map = anObject(this); + var iterator = getMapIterator(map); + var step, entry; + while (!(step = iterator.next()).done) { + entry = step.value; + if (entry[1] === searchElement) return entry[0]; + } + } +}); + +// `Map.prototype.mapKeys` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + mapKeys: function mapKeys(callbackfn /* , thisArg */) { + var map = anObject(this); + var iterator = getMapIterator(map); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var newMap = new (speciesConstructor(map, getBuiltIn('Map')))(); + var setter = aFunction(newMap.set); + var step, entry, value; + while (!(step = iterator.next()).done) { + entry = step.value; + setter.call(newMap, boundFunction(value = entry[1], entry[0], map), value); + } + return newMap; + } +}); + +// `Map.prototype.mapValues` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + mapValues: function mapValues(callbackfn /* , thisArg */) { + var map = anObject(this); + var iterator = getMapIterator(map); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var newMap = new (speciesConstructor(map, getBuiltIn('Map')))(); + var setter = aFunction(newMap.set); + var step, entry, key; + while (!(step = iterator.next()).done) { + entry = step.value; + setter.call(newMap, key = entry[0], boundFunction(entry[1], key, map)); + } + return newMap; + } +}); + +// `Map.prototype.merge` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + // eslint-disable-next-line no-unused-vars + merge: function merge(iterable /* ...iterbles */) { + var map = anObject(this); + var setter = aFunction(map.set); + var i = 0; + while (i < arguments.length) { + iterate(arguments[i++], setter, map, true); + } + return map; + } +}); + +// `Map.prototype.reduce` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + reduce: function reduce(callbackfn /* , initialValue */) { + var map = anObject(this); + var iterator = getMapIterator(map); + var accumulator, step, entry; + aFunction(callbackfn); + if (arguments.length > 1) accumulator = arguments[1]; + else { + step = iterator.next(); + if (step.done) throw TypeError('Reduce of empty map with no initial value'); + accumulator = step.value[1]; + } + while (!(step = iterator.next()).done) { + entry = step.value; + accumulator = callbackfn(accumulator, entry[1], entry[0], map); + } + return accumulator; + } +}); + +// `Set.prototype.some` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + some: function some(callbackfn /* , thisArg */) { + var map = anObject(this); + var iterator = getMapIterator(map); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var step, entry; + while (!(step = iterator.next()).done) { + entry = step.value; + if (boundFunction(entry[1], entry[0], map)) return true; + } return false; + } +}); + +// `Set.prototype.update` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Map', proto: true, real: true, forced: isPure }, { + update: function update(key, callback /* , thunk */) { + var map = anObject(this); + aFunction(callback); + var isPresentInMap = map.has(key); + if (!isPresentInMap && arguments.length < 3) { + throw TypeError('Updating absent value'); + } + var value = isPresentInMap ? map.get(key) : aFunction(arguments[2])(key, map); + map.set(key, callback(value, key, map)); + return map; + } +}); + +// https://github.com/tc39/collection-methods +var collectionAddAll = function (/* ...elements */) { + var set = anObject(this); + var adder = aFunction(set.add); + for (var k = 0, len = arguments.length; k < len; k++) { + adder.call(set, arguments[k]); + } + return set; +}; + +// `Set.prototype.addAll` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + addAll: function addAll(/* ...elements */) { + return collectionAddAll.apply(this, arguments); + } +}); + +// `Set.prototype.deleteAll` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + deleteAll: function deleteAll(/* ...elements */) { + return collectionDeleteAll.apply(this, arguments); + } +}); + +var getSetIterator = function (it) { + // eslint-disable-next-line no-undef + return Set.prototype.values.call(it); +}; + +// `Set.prototype.every` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + every: function every(callbackfn /* , thisArg */) { + var set = anObject(this); + var iterator = getSetIterator(set); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var step, value; + while (!(step = iterator.next()).done) { + if (!boundFunction(value = step.value, value, set)) return false; + } return true; + } +}); + +// `Set.prototype.filter` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + filter: function filter(callbackfn /* , thisArg */) { + var set = anObject(this); + var iterator = getSetIterator(set); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var newSet = new (speciesConstructor(set, getBuiltIn('Set')))(); + var adder = aFunction(newSet.add); + var step, value; + while (!(step = iterator.next()).done) { + if (boundFunction(value = step.value, value, set)) adder.call(newSet, value); + } + return newSet; + } +}); + +// `Set.prototype.find` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + find: function find(callbackfn /* , thisArg */) { + var set = anObject(this); + var iterator = getSetIterator(set); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var step, value; + while (!(step = iterator.next()).done) { + if (boundFunction(value = step.value, value, set)) return value; + } + } +}); + +// `Set.prototype.join` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + join: function join(separator) { + var set = anObject(this); + var iterator = getSetIterator(set); + var sep = separator === undefined ? ',' : String(separator); + var result = []; + var step; + while (!(step = iterator.next()).done) result.push(step.value); + return result.join(sep); + } +}); + +// `Set.prototype.map` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + map: function map(callbackfn /* , thisArg */) { + var set = anObject(this); + var iterator = getSetIterator(set); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var newSet = new (speciesConstructor(set, getBuiltIn('Set')))(); + var adder = aFunction(newSet.add); + var step, value; + while (!(step = iterator.next()).done) { + adder.call(newSet, boundFunction(value = step.value, value, set)); + } + return newSet; + } +}); + +// `Set.prototype.reduce` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + reduce: function reduce(callbackfn /* , initialValue */) { + var set = anObject(this); + var iterator = getSetIterator(set); + var accumulator, step, value; + aFunction(callbackfn); + if (arguments.length > 1) accumulator = arguments[1]; + else { + step = iterator.next(); + if (step.done) throw TypeError('Reduce of empty set with no initial value'); + accumulator = step.value; + } + while (!(step = iterator.next()).done) { + accumulator = callbackfn(accumulator, value = step.value, value, set); + } + return accumulator; + } +}); + +// `Set.prototype.some` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + some: function some(callbackfn /* , thisArg */) { + var set = anObject(this); + var iterator = getSetIterator(set); + var boundFunction = bindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var step, value; + while (!(step = iterator.next()).done) { + if (boundFunction(value = step.value, value, set)) return true; + } return false; + } +}); + +// `WeakMap.prototype.deleteAll` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'WeakMap', proto: true, real: true, forced: isPure }, { + deleteAll: function deleteAll(/* ...elements */) { + return collectionDeleteAll.apply(this, arguments); + } +}); + +// `WeakSet.prototype.addAll` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'WeakSet', proto: true, real: true, forced: isPure }, { + addAll: function addAll(/* ...elements */) { + return collectionAddAll.apply(this, arguments); + } +}); + +// `WeakSet.prototype.deleteAll` method +// https://github.com/tc39/proposal-collection-methods +_export({ target: 'WeakSet', proto: true, real: true, forced: isPure }, { + deleteAll: function deleteAll(/* ...elements */) { + return collectionDeleteAll.apply(this, arguments); + } +}); + +// https://tc39.github.io/proposal-setmap-offrom/ + + + + +var collectionFrom = function from(source /* , mapFn, thisArg */) { + var mapFn = arguments[1]; + var mapping, A, n, boundFunction; + aFunction(this); + mapping = mapFn !== undefined; + if (mapping) aFunction(mapFn); + if (source == undefined) return new this(); + A = []; + if (mapping) { + n = 0; + boundFunction = bindContext(mapFn, arguments[2], 2); + iterate(source, function (nextItem) { + A.push(boundFunction(nextItem, n++)); + }); + } else { + iterate(source, A.push, A); + } + return new this(A); +}; + +// `Map.from` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-map.from +_export({ target: 'Map', stat: true }, { + from: collectionFrom +}); + +// https://tc39.github.io/proposal-setmap-offrom/ +var collectionOf = function of() { + var length = arguments.length; + var A = new Array(length); + while (length--) A[length] = arguments[length]; + return new this(A); +}; + +// `Map.of` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-map.of +_export({ target: 'Map', stat: true }, { + of: collectionOf +}); + +// `Set.from` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-set.from +_export({ target: 'Set', stat: true }, { + from: collectionFrom +}); + +// `Set.of` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-set.of +_export({ target: 'Set', stat: true }, { + of: collectionOf +}); + +// `WeakMap.from` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from +_export({ target: 'WeakMap', stat: true }, { + from: collectionFrom +}); + +// `WeakMap.of` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of +_export({ target: 'WeakMap', stat: true }, { + of: collectionOf +}); + +// `WeakSet.from` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.from +_export({ target: 'WeakSet', stat: true }, { + from: collectionFrom +}); + +// `WeakSet.of` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.of +_export({ target: 'WeakSet', stat: true }, { + of: collectionOf +}); + +var min$6 = Math.min; +var max$4 = Math.max; + +// `Math.clamp` method +// https://rwaldron.github.io/proposal-math-extensions/ +_export({ target: 'Math', stat: true }, { + clamp: function clamp(x, lower, upper) { + return min$6(upper, max$4(lower, x)); + } +}); + +// `Math.DEG_PER_RAD` constant +// https://rwaldron.github.io/proposal-math-extensions/ +_export({ target: 'Math', stat: true }, { + DEG_PER_RAD: Math.PI / 180 +}); + +var RAD_PER_DEG = 180 / Math.PI; + +// `Math.degrees` method +// https://rwaldron.github.io/proposal-math-extensions/ +_export({ target: 'Math', stat: true }, { + degrees: function degrees(radians) { + return radians * RAD_PER_DEG; + } +}); + +// `Math.scale` method implementation +// https://rwaldron.github.io/proposal-math-extensions/ +var mathScale = Math.scale || function scale(x, inLow, inHigh, outLow, outHigh) { + if ( + arguments.length === 0 + /* eslint-disable no-self-compare */ + || x != x + || inLow != inLow + || inHigh != inHigh + || outLow != outLow + || outHigh != outHigh + /* eslint-enable no-self-compare */ + ) return NaN; + if (x === Infinity || x === -Infinity) return x; + return (x - inLow) * (outHigh - outLow) / (inHigh - inLow) + outLow; +}; + +// `Math.fscale` method +// https://rwaldron.github.io/proposal-math-extensions/ +_export({ target: 'Math', stat: true }, { + fscale: function fscale(x, inLow, inHigh, outLow, outHigh) { + return mathFround(mathScale(x, inLow, inHigh, outLow, outHigh)); + } +}); + +// `Math.RAD_PER_DEG` constant +// https://rwaldron.github.io/proposal-math-extensions/ +_export({ target: 'Math', stat: true }, { + RAD_PER_DEG: 180 / Math.PI +}); + +var DEG_PER_RAD = Math.PI / 180; + +// `Math.radians` method +// https://rwaldron.github.io/proposal-math-extensions/ +_export({ target: 'Math', stat: true }, { + radians: function radians(degrees) { + return degrees * DEG_PER_RAD; + } +}); + +// `Math.scale` method +// https://rwaldron.github.io/proposal-math-extensions/ +_export({ target: 'Math', stat: true }, { + scale: mathScale +}); + +// `Math.signbit` method +// https://github.com/tc39/proposal-Math.signbit +_export({ target: 'Math', stat: true }, { + signbit: function signbit(x) { + // eslint-disable-next-line no-self-compare + return (x = +x) != x ? x : x == 0 ? 1 / x == Infinity : x > 0; + } +}); + +var INVALID_NUMBER_REPRESENTATION = 'Invalid number representation'; +var INVALID_RADIX = 'Invalid radix'; +var valid = /^[\da-z]+$/; + +// `Number.fromString` method +// https://github.com/tc39/proposal-number-fromstring +_export({ target: 'Number', stat: true }, { + fromString: function fromString(string, radix) { + var sign = 1; + var R, mathNum; + if (typeof string != 'string') throw TypeError(INVALID_NUMBER_REPRESENTATION); + if (!string.length) throw SyntaxError(INVALID_NUMBER_REPRESENTATION); + if (string.charAt(0) == '-') { + sign = -1; + string = string.slice(1); + if (!string.length) throw SyntaxError(INVALID_NUMBER_REPRESENTATION); + } + R = radix === undefined ? 10 : toInteger(radix); + if (R < 2 || R > 36) throw RangeError(INVALID_RADIX); + if (!valid.test(string) || (mathNum = _parseInt(string, R)).toString(R) !== string) { + throw SyntaxError(INVALID_NUMBER_REPRESENTATION); + } + return sign * mathNum; + } +}); + +// https://github.com/tc39/proposal-observable + + + + + + + + + + + +var defineProperty$a = objectDefineProperty.f; + + + + +var OBSERVABLE = wellKnownSymbol('observable'); +var getInternalState$5 = internalState.get; +var setInternalState$9 = internalState.set; +var BREAK = iterate.BREAK; + +var getMethod = function (fn) { + return fn == null ? undefined : aFunction(fn); +}; + +var cleanupSubscription = function (subscriptionState) { + var cleanup = subscriptionState.cleanup; + if (cleanup) { + subscriptionState.cleanup = undefined; + try { + cleanup(); + } catch (error) { + hostReportErrors(error); + } + } +}; + +var subscriptionClosed = function (subscriptionState) { + return subscriptionState.observer === undefined; +}; + +var close = function (subscription, subscriptionState) { + if (!descriptors) { + subscription.closed = true; + var subscriptionObserver = subscriptionState.subscriptionObserver; + if (subscriptionObserver) subscriptionObserver.closed = true; + } subscriptionState.observer = undefined; +}; + +var Subscription = function (observer, subscriber) { + var subscriptionState = setInternalState$9(this, { + cleanup: undefined, + observer: anObject(observer), + subscriptionObserver: undefined + }); + var start; + if (!descriptors) this.closed = false; + try { + if (start = getMethod(observer.start)) start.call(observer, this); + } catch (error) { + hostReportErrors(error); + } + if (subscriptionClosed(subscriptionState)) return; + var subscriptionObserver = subscriptionState.subscriptionObserver = new SubscriptionObserver(this); + try { + var cleanup = subscriber(subscriptionObserver); + var subscription = cleanup; + if (cleanup != null) subscriptionState.cleanup = typeof cleanup.unsubscribe === 'function' + ? function () { subscription.unsubscribe(); } + : aFunction(cleanup); + } catch (error) { + subscriptionObserver.error(error); + return; + } if (subscriptionClosed(subscriptionState)) cleanupSubscription(subscriptionState); +}; + +Subscription.prototype = redefineAll({}, { + unsubscribe: function unsubscribe() { + var subscriptionState = getInternalState$5(this); + if (!subscriptionClosed(subscriptionState)) { + close(this, subscriptionState); + cleanupSubscription(subscriptionState); + } + } +}); + +if (descriptors) defineProperty$a(Subscription.prototype, 'closed', { + configurable: true, + get: function () { + return subscriptionClosed(getInternalState$5(this)); + } +}); + +var SubscriptionObserver = function (subscription) { + setInternalState$9(this, { subscription: subscription }); + if (!descriptors) this.closed = false; +}; + +SubscriptionObserver.prototype = redefineAll({}, { + next: function next(value) { + var subscriptionState = getInternalState$5(getInternalState$5(this).subscription); + if (!subscriptionClosed(subscriptionState)) { + var observer = subscriptionState.observer; + try { + var m = getMethod(observer.next); + if (m) m.call(observer, value); + } catch (error) { + hostReportErrors(error); + } + } + }, + error: function error(value) { + var subscription = getInternalState$5(this).subscription; + var subscriptionState = getInternalState$5(subscription); + if (!subscriptionClosed(subscriptionState)) { + var observer = subscriptionState.observer; + close(subscription, subscriptionState); + try { + var m = getMethod(observer.error); + if (m) m.call(observer, value); + else hostReportErrors(value); + } catch (err) { + hostReportErrors(err); + } cleanupSubscription(subscriptionState); + } + }, + complete: function complete() { + var subscription = getInternalState$5(this).subscription; + var subscriptionState = getInternalState$5(subscription); + if (!subscriptionClosed(subscriptionState)) { + var observer = subscriptionState.observer; + close(subscription, subscriptionState); + try { + var m = getMethod(observer.complete); + if (m) m.call(observer); + } catch (error) { + hostReportErrors(error); + } cleanupSubscription(subscriptionState); + } + } +}); + +if (descriptors) defineProperty$a(SubscriptionObserver.prototype, 'closed', { + configurable: true, + get: function () { + return subscriptionClosed(getInternalState$5(getInternalState$5(this).subscription)); + } +}); + +var $Observable = function Observable(subscriber) { + anInstance(this, $Observable, 'Observable'); + setInternalState$9(this, { subscriber: aFunction(subscriber) }); +}; + +redefineAll($Observable.prototype, { + subscribe: function subscribe(observer) { + var argumentsLength = arguments.length; + return new Subscription(typeof observer === 'function' ? { + next: observer, + error: argumentsLength > 1 ? arguments[1] : undefined, + complete: argumentsLength > 2 ? arguments[2] : undefined + } : isObject(observer) ? observer : {}, getInternalState$5(this).subscriber); + } +}); + +redefineAll($Observable, { + from: function from(x) { + var C = typeof this === 'function' ? this : $Observable; + var method = getMethod(anObject(x)[OBSERVABLE]); + if (method) { + var observable = anObject(method.call(x)); + return observable.constructor === C ? observable : new C(function (observer) { + return observable.subscribe(observer); + }); + } + var iterator = getIterator(x); + return new C(function (observer) { + iterate(iterator, function (it) { + observer.next(it); + if (observer.closed) return BREAK; + }, undefined, false, true); + observer.complete(); + }); + }, + of: function of() { + for (var i = 0, argumentsLength = arguments.length, items = new Array(argumentsLength); i < argumentsLength;) { + items[i] = arguments[i++]; + } + return new (typeof this === 'function' ? this : $Observable)(function (observer) { + for (var j = 0; j < items.length; ++j) { + observer.next(items[j]); + if (observer.closed) return; + } observer.complete(); + }); + } +}); + +hide($Observable.prototype, OBSERVABLE, function () { return this; }); + +_export({ global: true }, { + Observable: $Observable +}); + +setSpecies('Observable'); + +// `Symbol.observable` well-known symbol +// https://github.com/tc39/proposal-observable +defineWellKnownSymbol('observable'); + +// `Symbol.patternMatch` well-known symbol +// https://github.com/tc39/proposal-pattern-matching +defineWellKnownSymbol('patternMatch'); + +// `Promise.try` method +// https://github.com/tc39/proposal-promise-try +_export({ target: 'Promise', stat: true }, { + 'try': function (callbackfn) { + var promiseCapability = newPromiseCapability.f(this); + var result = perform(callbackfn); + (result.error ? promiseCapability.reject : promiseCapability.resolve)(result.value); + return promiseCapability.promise; + } +}); + +var Node = function () { + // keys + this.object = null; + this.symbol = null; + // child nodes + this.primitives = null; + this.objectsByIndex = objectCreate(null); +}; + +Node.prototype.get = function (key, initializer) { + return this[key] || (this[key] = initializer()); +}; + +Node.prototype.next = function (i, it, IS_OBJECT) { + var store = IS_OBJECT + ? this.objectsByIndex[i] || (this.objectsByIndex[i] = new es_weakMap()) + : this.primitives || (this.primitives = new es_map()); + var entry = store.get(it); + if (!entry) store.set(it, entry = new Node()); + return entry; +}; + +var root = new Node(); + +var compositeKey = function () { + var active = root; + var length = arguments.length; + var i, it; + // for prevent leaking, start from objects + for (i = 0; i < length; i++) { + if (isObject(it = arguments[i])) active = active.next(i, it, true); + } + if (this === Object && active === root) throw TypeError('Composite keys must contain a non-primitive component'); + for (i = 0; i < length; i++) { + if (!isObject(it = arguments[i])) active = active.next(i, it, false); + } return active; +}; + +var initializer = function () { + var freeze = getBuiltIn('Object', 'freeze'); + return freeze ? freeze(objectCreate(null)) : objectCreate(null); +}; + +// https://github.com/tc39/proposal-richer-keys/tree/master/compositeKey +_export({ global: true }, { + compositeKey: function compositeKey$1() { + return compositeKey.apply(Object, arguments).get('object', initializer); + } +}); + +// https://github.com/tc39/proposal-richer-keys/tree/master/compositeKey +_export({ global: true }, { + compositeSymbol: function compositeSymbol() { + if (arguments.length === 1 && typeof arguments[0] === 'string') return getBuiltIn('Symbol')['for'](arguments[0]); + return compositeKey.apply(null, arguments).get('symbol', getBuiltIn('Symbol')); + } +}); + +var SEEDED_RANDOM = 'Seeded Random'; +var SEEDED_RANDOM_GENERATOR = SEEDED_RANDOM + ' Generator'; +var setInternalState$a = internalState.set; +var getInternalState$6 = internalState.getterFor(SEEDED_RANDOM_GENERATOR); +var SEED_TYPE_ERROR = 'Math.seededPRNG() argument should have a "seed" field with a finite value.'; + +var $SeededRandomGenerator = createIteratorConstructor(function SeededRandomGenerator(seed) { + setInternalState$a(this, { + type: SEEDED_RANDOM_GENERATOR, + seed: seed % 2147483647 + }); +}, SEEDED_RANDOM, function next() { + var state = getInternalState$6(this); + var seed = state.seed = (state.seed * 1103515245 + 12345) % 2147483647; + return { value: (seed & 1073741823) / 1073741823, done: false }; +}); + +// `Math.seededPRNG` method +// https://github.com/tc39/proposal-seeded-random +// based on https://github.com/tc39/proposal-seeded-random/blob/78b8258835b57fc2100d076151ab506bc3202ae6/demo.html +_export({ target: 'Math', stat: true, forced: true }, { + seededPRNG: function seededPRNG(it) { + var seed = anObject(it).seed; + if (!numberIsFinite(seed)) throw TypeError(SEED_TYPE_ERROR); + return new $SeededRandomGenerator(seed); + } +}); + +var STRING_ITERATOR$1 = 'String Iterator'; +var setInternalState$b = internalState.set; +var getInternalState$7 = internalState.getterFor(STRING_ITERATOR$1); + +// TODO: unify with String#@@iterator +var $StringIterator = createIteratorConstructor(function StringIterator(string) { + setInternalState$b(this, { + type: STRING_ITERATOR$1, + string: string, + index: 0 + }); +}, 'String', function next() { + var state = getInternalState$7(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return { value: undefined, done: true }; + point = stringAt(string, index, true); + state.index += point.length; + return { value: { codePoint: stringAt(point, 0), position: index }, done: false }; +}); + +// `String.prototype.codePoints` method +// https://github.com/tc39/proposal-string-prototype-codepoints +_export({ target: 'String', proto: true }, { + codePoints: function codePoints() { + return new $StringIterator(String(requireObjectCoercible(this))); + } +}); + +// `Symbol.patternMatch` well-known symbol +// https://github.com/tc39/proposal-using-statement +defineWellKnownSymbol('dispose'); + +var $AggregateError = function AggregateError(errors, message) { + var that = this; + if (!(that instanceof $AggregateError)) return new $AggregateError(errors, message); + if (objectSetPrototypeOf) { + that = objectSetPrototypeOf(new Error(message), objectGetPrototypeOf(that)); + } + var errorsArray = []; + iterate(errors, errorsArray.push, errorsArray); + that.errors = errorsArray; + if (message !== undefined) hide(that, 'message', String(message)); + return that; +}; + +$AggregateError.prototype = objectCreate(Error.prototype, { + constructor: createPropertyDescriptor(5, $AggregateError), + name: createPropertyDescriptor(5, 'AggregateError') +}); + +_export({ global: true }, { + AggregateError: $AggregateError +}); + +var PROMISE_ANY_ERROR = 'No one promise resolved'; + +// `Promise.any` method +// https://github.com/tc39/proposal-promise-any +_export({ target: 'Promise', stat: true }, { + any: function any(iterable) { + var C = this; + var capability = newPromiseCapability.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var promiseResolve = aFunction(C.resolve); + var errors = []; + var counter = 0; + var remaining = 1; + var alreadyResolved = false; + iterate(iterable, function (promise) { + var index = counter++; + var alreadyRejected = false; + errors.push(undefined); + remaining++; + promiseResolve.call(C, promise).then(function (value) { + if (alreadyRejected || alreadyResolved) return; + alreadyResolved = true; + resolve(value); + }, function (e) { + if (alreadyRejected || alreadyResolved) return; + alreadyRejected = true; + errors[index] = e; + --remaining || reject(new (getBuiltIn('AggregateError'))(errors, PROMISE_ANY_ERROR)); + }); + }); + --remaining || reject(new (getBuiltIn('AggregateError'))(errors, PROMISE_ANY_ERROR)); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +// `Set.prototype.difference` method +// https://github.com/tc39/proposal-set-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + difference: function difference(iterable) { + var set = anObject(this); + var newSet = new (speciesConstructor(set, getBuiltIn('Set')))(set); + var remover = aFunction(newSet['delete']); + iterate(iterable, function (value) { + remover.call(newSet, value); + }); + return newSet; + } +}); + +// `Set.prototype.intersection` method +// https://github.com/tc39/proposal-set-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + intersection: function intersection(iterable) { + var set = anObject(this); + var newSet = new (speciesConstructor(set, getBuiltIn('Set')))(); + var hasCheck = aFunction(set.has); + var adder = aFunction(newSet.add); + iterate(iterable, function (value) { + if (hasCheck.call(set, value)) adder.call(newSet, value); + }); + return newSet; + } +}); + +var BREAK$1 = iterate.BREAK; + +// `Set.prototype.isDisjointFrom` method +// https://tc39.github.io/proposal-set-methods/#Set.prototype.isDisjointFrom +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + isDisjointFrom: function isDisjointFrom(iterable) { + var set = anObject(this); + var hasCheck = aFunction(set.has); + return iterate(iterable, function (value) { + if (hasCheck.call(set, value) === true) return BREAK$1; + }) !== BREAK$1; + } +}); + +var BREAK$2 = iterate.BREAK; + +// `Set.prototype.isSubsetOf` method +// https://tc39.github.io/proposal-set-methods/#Set.prototype.isSubsetOf +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + isSubsetOf: function isSubsetOf(iterable) { + var iterator = getIterator(this); + var otherSet = anObject(iterable); + var hasCheck = otherSet.has; + if (typeof hasCheck != 'function') { + otherSet = new (getBuiltIn('Set'))(iterable); + hasCheck = aFunction(otherSet.has); + } + return iterate(iterator, function (value) { + if (hasCheck.call(otherSet, value) === false) return BREAK$2; + }, undefined, false, true) !== BREAK$2; + } +}); + +var BREAK$3 = iterate.BREAK; + +// `Set.prototype.isSupersetOf` method +// https://tc39.github.io/proposal-set-methods/#Set.prototype.isSupersetOf +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + isSupersetOf: function isSupersetOf(iterable) { + var set = anObject(this); + var hasCheck = aFunction(set.has); + return iterate(iterable, function (value) { + if (hasCheck.call(set, value) === false) return BREAK$3; + }) !== BREAK$3; + } +}); + +// `Set.prototype.union` method +// https://github.com/tc39/proposal-set-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + union: function union(iterable) { + var set = anObject(this); + var newSet = new (speciesConstructor(set, getBuiltIn('Set')))(set); + iterate(iterable, aFunction(newSet.add), newSet); + return newSet; + } +}); + +// `Set.prototype.symmetricDifference` method +// https://github.com/tc39/proposal-set-methods +_export({ target: 'Set', proto: true, real: true, forced: isPure }, { + symmetricDifference: function symmetricDifference(iterable) { + var set = anObject(this); + var newSet = new (speciesConstructor(set, getBuiltIn('Set')))(set); + var remover = aFunction(newSet['delete']); + var adder = aFunction(newSet.add); + iterate(iterable, function (value) { + remover.call(newSet, value) || adder.call(newSet, value); + }); + return newSet; + } +}); + +var REPLACE_ALL = wellKnownSymbol('replaceAll'); +var RegExpPrototype$3 = RegExp.prototype; + +var $replaceAll = function (string, replaceValue) { + var rx = anObject(this); + var flags = String('flags' in RegExpPrototype$3 ? rx.flags : regexpFlags.call(rx)); + if (!~flags.indexOf('g')) { + rx = new (speciesConstructor(rx, RegExp))(rx.source, flags + 'g'); + } + return String(string).replace(rx, replaceValue); +}; + +// `String.prototype.replaceAll` method +// https://github.com/tc39/proposal-string-replace-all +_export({ target: 'String', proto: true }, { + replaceAll: function replaceAll(searchValue, replaceValue) { + var O = requireObjectCoercible(this); + var replacer, string, searchString, template, result, i; + if (searchValue != null) { + replacer = searchValue[REPLACE_ALL]; + if (replacer !== undefined) { + return replacer.call(searchValue, O, replaceValue); + } + } + string = String(O); + searchString = String(searchValue); + template = string.split(searchString); + if (typeof replaceValue !== 'function') { + return template.join(String(replaceValue)); + } + result = template[0]; + for (i = 1; i < template.length; i++) { + result += String(replaceValue(searchString, i - 1, string)); + result += template[i]; + } + return result; + } +}); + +REPLACE_ALL in RegExpPrototype$3 || hide(RegExpPrototype$3, REPLACE_ALL, $replaceAll); + +// `Symbol.replaceAll` well-known symbol +// https://tc39.github.io/proposal-string-replaceall/ +defineWellKnownSymbol('replaceAll'); + +// `globalThis` object +// https://github.com/tc39/proposal-global +_export({ global: true }, { globalThis: global_1 }); + +// `Promise.allSettled` method +// https://github.com/tc39/proposal-promise-allSettled +_export({ target: 'Promise', stat: true }, { + allSettled: function allSettled(iterable) { + var C = this; + var capability = newPromiseCapability.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var promiseResolve = aFunction(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + values.push(undefined); + remaining++; + promiseResolve.call(C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'fulfilled', value: value }; + --remaining || resolve(values); + }, function (e) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'rejected', reason: e }; + --remaining || resolve(values); + }); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +// iterable DOM collections +// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods +var domIterables = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 +}; + +for (var COLLECTION_NAME in domIterables) { + var Collection = global_1[COLLECTION_NAME]; + var CollectionPrototype = Collection && Collection.prototype; + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== arrayForEach) try { + hide(CollectionPrototype, 'forEach', arrayForEach); + } catch (error) { + CollectionPrototype.forEach = arrayForEach; + } +} + +var ITERATOR$8 = wellKnownSymbol('iterator'); +var TO_STRING_TAG$4 = wellKnownSymbol('toStringTag'); +var ArrayValues = es_array_iterator.values; + +for (var COLLECTION_NAME$1 in domIterables) { + var Collection$1 = global_1[COLLECTION_NAME$1]; + var CollectionPrototype$1 = Collection$1 && Collection$1.prototype; + if (CollectionPrototype$1) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype$1[ITERATOR$8] !== ArrayValues) try { + hide(CollectionPrototype$1, ITERATOR$8, ArrayValues); + } catch (error) { + CollectionPrototype$1[ITERATOR$8] = ArrayValues; + } + if (!CollectionPrototype$1[TO_STRING_TAG$4]) hide(CollectionPrototype$1, TO_STRING_TAG$4, COLLECTION_NAME$1); + if (domIterables[COLLECTION_NAME$1]) for (var METHOD_NAME in es_array_iterator) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype$1[METHOD_NAME] !== es_array_iterator[METHOD_NAME]) try { + hide(CollectionPrototype$1, METHOD_NAME, es_array_iterator[METHOD_NAME]); + } catch (error) { + CollectionPrototype$1[METHOD_NAME] = es_array_iterator[METHOD_NAME]; + } + } + } +} + +var FORCED$k = !global_1.setImmediate || !global_1.clearImmediate; + +_export({ global: true, bind: true, enumerable: true, forced: FORCED$k }, { + setImmediate: task.set, + clearImmediate: task.clear +}); + +var process$3 = global_1.process; +var isNode = classofRaw(process$3) == 'process'; + +// `queueMicrotask` method +// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-queuemicrotask +_export({ global: true, enumerable: true, noTargetGet: true }, { + queueMicrotask: function queueMicrotask(fn) { + var domain = isNode && process$3.domain; + microtask(domain ? domain.bind(fn) : fn); + } +}); + +// ie9- setTimeout & setInterval additional parameters fix + + + + +var slice = [].slice; +var MSIE = /MSIE .\./.test(userAgent); // <- dirty ie9- check + +var wrap$1 = function (set) { + return function (fn, time /* , ...args */) { + var boundArgs = arguments.length > 2; + var args = boundArgs ? slice.call(arguments, 2) : false; + return set(boundArgs ? function () { + // eslint-disable-next-line no-new-func + (typeof fn == 'function' ? fn : Function(fn)).apply(this, args); + } : fn, time); + }; +}; + +_export({ global: true, bind: true, forced: MSIE }, { + setTimeout: wrap$1(global_1.setTimeout), + setInterval: wrap$1(global_1.setInterval) +}); diff --git a/test/form/samples/supports-core-js/main.js b/test/form/samples/supports-core-js/main.js new file mode 100644 index 00000000000..66bfb4d1516 --- /dev/null +++ b/test/form/samples/supports-core-js/main.js @@ -0,0 +1 @@ +import 'core-js'; diff --git a/test/form/samples/supports-es5-shim/_config.js b/test/form/samples/supports-es5-shim/_config.js new file mode 100644 index 00000000000..30d26541716 --- /dev/null +++ b/test/form/samples/supports-es5-shim/_config.js @@ -0,0 +1,14 @@ +module.exports = { + description: 'supports es5-shim', + options: { + onwarn(warning) { + if (warning.code !== 'THIS_IS_UNDEFINED') { + throw new Error(warning.message); + } + }, + // TODO notable exception: Promise.resolve(thenable) not yet retained + // check against tree-shake: false when updating the shim + treeshake: true, + plugins: [require('rollup-plugin-node-resolve')(), require('rollup-plugin-commonjs')()] + } +}; diff --git a/test/form/samples/supports-es5-shim/_expected.js b/test/form/samples/supports-es5-shim/_expected.js new file mode 100644 index 00000000000..9256991f4c1 --- /dev/null +++ b/test/form/samples/supports-es5-shim/_expected.js @@ -0,0 +1,2103 @@ +var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +function createCommonjsModule(fn, module) { + return module = { exports: {} }, fn(module, module.exports), module.exports; +} + +var es5Shim = createCommonjsModule(function (module, exports) { + +// UMD (Universal Module Definition) +// see https://github.com/umdjs/umd/blob/master/templates/returnExports.js +(function (root, factory) { + + /* global define, exports, module */ + { + // Node. Does not work with strict CommonJS, but + // only CommonJS-like enviroments that support module.exports, + // like Node. + module.exports = factory(); + } +}(commonjsGlobal, function () { + /** + * Brings an environment as close to ECMAScript 5 compliance + * as is possible with the facilities of erstwhile engines. + * + * Annotated ES5: http://es5.github.com/ (specific links below) + * ES5 Spec: http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf + * Required reading: http://javascriptweblog.wordpress.com/2011/12/05/extending-javascript-natives/ + */ + + // Shortcut to an often accessed properties, in order to avoid multiple + // dereference that costs universally. This also holds a reference to known-good + // functions. + var $Array = Array; + var ArrayPrototype = $Array.prototype; + var $Object = Object; + var ObjectPrototype = $Object.prototype; + var $Function = Function; + var FunctionPrototype = $Function.prototype; + var $String = String; + var StringPrototype = $String.prototype; + var $Number = Number; + var NumberPrototype = $Number.prototype; + var array_slice = ArrayPrototype.slice; + var array_splice = ArrayPrototype.splice; + var array_push = ArrayPrototype.push; + var array_unshift = ArrayPrototype.unshift; + var array_concat = ArrayPrototype.concat; + var array_join = ArrayPrototype.join; + var call = FunctionPrototype.call; + var apply = FunctionPrototype.apply; + var max = Math.max; + var min = Math.min; + + // Having a toString local variable name breaks in Opera so use to_string. + var to_string = ObjectPrototype.toString; + + /* global Symbol */ + /* eslint-disable one-var-declaration-per-line, no-redeclare, max-statements-per-line */ + var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol'; + var isCallable; /* inlined from https://npmjs.com/is-callable */ var fnToStr = Function.prototype.toString, constructorRegex = /^\s*class /, isES6ClassFn = function isES6ClassFn(value) { try { var fnStr = fnToStr.call(value); var singleStripped = fnStr.replace(/\/\/.*\n/g, ''); var multiStripped = singleStripped.replace(/\/\*[.\s\S]*\*\//g, ''); var spaceStripped = multiStripped.replace(/\n/mg, ' ').replace(/ {2}/g, ' '); return constructorRegex.test(spaceStripped); } catch (e) { return false; /* not a function */ } }, tryFunctionObject = function tryFunctionObject(value) { try { if (isES6ClassFn(value)) { return false; } fnToStr.call(value); return true; } catch (e) { return false; } }, fnClass = '[object Function]', genClass = '[object GeneratorFunction]', isCallable = function isCallable(value) { if (!value) { return false; } if (typeof value !== 'function' && typeof value !== 'object') { return false; } if (hasToStringTag) { return tryFunctionObject(value); } if (isES6ClassFn(value)) { return false; } var strClass = to_string.call(value); return strClass === fnClass || strClass === genClass; }; + + var isRegex; /* inlined from https://npmjs.com/is-regex */ var regexExec = RegExp.prototype.exec, tryRegexExec = function tryRegexExec(value) { try { regexExec.call(value); return true; } catch (e) { return false; } }, regexClass = '[object RegExp]'; isRegex = function isRegex(value) { if (typeof value !== 'object') { return false; } return hasToStringTag ? tryRegexExec(value) : to_string.call(value) === regexClass; }; + var isString; /* inlined from https://npmjs.com/is-string */ var strValue = String.prototype.valueOf, tryStringObject = function tryStringObject(value) { try { strValue.call(value); return true; } catch (e) { return false; } }, stringClass = '[object String]'; isString = function isString(value) { if (typeof value === 'string') { return true; } if (typeof value !== 'object') { return false; } return hasToStringTag ? tryStringObject(value) : to_string.call(value) === stringClass; }; + /* eslint-enable one-var-declaration-per-line, no-redeclare, max-statements-per-line */ + + /* inlined from http://npmjs.com/define-properties */ + var supportsDescriptors = $Object.defineProperty && (function () { + try { + var obj = {}; + $Object.defineProperty(obj, 'x', { enumerable: false, value: obj }); + for (var _ in obj) { // jscs:ignore disallowUnusedVariables + return false; + } + return obj.x === obj; + } catch (e) { /* this is ES3 */ + return false; + } + }()); + var defineProperties = (function (has) { + // Define configurable, writable, and non-enumerable props + // if they don't exist. + var defineProperty; + if (supportsDescriptors) { + defineProperty = function (object, name, method, forceAssign) { + if (!forceAssign && (name in object)) { + return; + } + $Object.defineProperty(object, name, { + configurable: true, + enumerable: false, + writable: true, + value: method + }); + }; + } else { + defineProperty = function (object, name, method, forceAssign) { + if (!forceAssign && (name in object)) { + return; + } + object[name] = method; + }; + } + return function defineProperties(object, map, forceAssign) { + for (var name in map) { + if (has.call(map, name)) { + defineProperty(object, name, map[name], forceAssign); + } + } + }; + }(ObjectPrototype.hasOwnProperty)); + + // + // Util + // ====== + // + + /* replaceable with https://npmjs.com/package/es-abstract /helpers/isPrimitive */ + var isPrimitive = function isPrimitive(input) { + var type = typeof input; + return input === null || (type !== 'object' && type !== 'function'); + }; + + var isActualNaN = $Number.isNaN || function isActualNaN(x) { + return x !== x; + }; + + var ES = { + // ES5 9.4 + // http://es5.github.com/#x9.4 + // http://jsperf.com/to-integer + /* replaceable with https://npmjs.com/package/es-abstract ES5.ToInteger */ + ToInteger: function ToInteger(num) { + var n = +num; + if (isActualNaN(n)) { + n = 0; + } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) { + n = (n > 0 || -1) * Math.floor(Math.abs(n)); + } + return n; + }, + + /* replaceable with https://npmjs.com/package/es-abstract ES5.ToPrimitive */ + ToPrimitive: function ToPrimitive(input) { + var val, valueOf, toStr; + if (isPrimitive(input)) { + return input; + } + valueOf = input.valueOf; + if (isCallable(valueOf)) { + val = valueOf.call(input); + if (isPrimitive(val)) { + return val; + } + } + toStr = input.toString; + if (isCallable(toStr)) { + val = toStr.call(input); + if (isPrimitive(val)) { + return val; + } + } + throw new TypeError(); + }, + + // ES5 9.9 + // http://es5.github.com/#x9.9 + /* replaceable with https://npmjs.com/package/es-abstract ES5.ToObject */ + ToObject: function (o) { + if (o == null) { // this matches both null and undefined + throw new TypeError("can't convert " + o + ' to object'); + } + return $Object(o); + }, + + /* replaceable with https://npmjs.com/package/es-abstract ES5.ToUint32 */ + ToUint32: function ToUint32(x) { + return x >>> 0; + } + }; + + // + // Function + // ======== + // + + // ES-5 15.3.4.5 + // http://es5.github.com/#x15.3.4.5 + + var Empty = function Empty() {}; + + defineProperties(FunctionPrototype, { + bind: function bind(that) { // .length is 1 + // 1. Let Target be the this value. + var target = this; + // 2. If IsCallable(Target) is false, throw a TypeError exception. + if (!isCallable(target)) { + throw new TypeError('Function.prototype.bind called on incompatible ' + target); + } + // 3. Let A be a new (possibly empty) internal list of all of the + // argument values provided after thisArg (arg1, arg2 etc), in order. + // XXX slicedArgs will stand in for "A" if used + var args = array_slice.call(arguments, 1); // for normal call + // 4. Let F be a new native ECMAScript object. + // 11. Set the [[Prototype]] internal property of F to the standard + // built-in Function prototype object as specified in 15.3.3.1. + // 12. Set the [[Call]] internal property of F as described in + // 15.3.4.5.1. + // 13. Set the [[Construct]] internal property of F as described in + // 15.3.4.5.2. + // 14. Set the [[HasInstance]] internal property of F as described in + // 15.3.4.5.3. + var bound; + var binder = function () { + + if (this instanceof bound) { + // 15.3.4.5.2 [[Construct]] + // When the [[Construct]] internal method of a function object, + // F that was created using the bind function is called with a + // list of arguments ExtraArgs, the following steps are taken: + // 1. Let target be the value of F's [[TargetFunction]] + // internal property. + // 2. If target has no [[Construct]] internal method, a + // TypeError exception is thrown. + // 3. Let boundArgs be the value of F's [[BoundArgs]] internal + // property. + // 4. Let args be a new list containing the same values as the + // list boundArgs in the same order followed by the same + // values as the list ExtraArgs in the same order. + // 5. Return the result of calling the [[Construct]] internal + // method of target providing args as the arguments. + + var result = apply.call( + target, + this, + array_concat.call(args, array_slice.call(arguments)) + ); + if ($Object(result) === result) { + return result; + } + return this; + + } else { + // 15.3.4.5.1 [[Call]] + // When the [[Call]] internal method of a function object, F, + // which was created using the bind function is called with a + // this value and a list of arguments ExtraArgs, the following + // steps are taken: + // 1. Let boundArgs be the value of F's [[BoundArgs]] internal + // property. + // 2. Let boundThis be the value of F's [[BoundThis]] internal + // property. + // 3. Let target be the value of F's [[TargetFunction]] internal + // property. + // 4. Let args be a new list containing the same values as the + // list boundArgs in the same order followed by the same + // values as the list ExtraArgs in the same order. + // 5. Return the result of calling the [[Call]] internal method + // of target providing boundThis as the this value and + // providing args as the arguments. + + // equiv: target.call(this, ...boundArgs, ...args) + return apply.call( + target, + that, + array_concat.call(args, array_slice.call(arguments)) + ); + + } + + }; + + // 15. If the [[Class]] internal property of Target is "Function", then + // a. Let L be the length property of Target minus the length of A. + // b. Set the length own property of F to either 0 or L, whichever is + // larger. + // 16. Else set the length own property of F to 0. + + var boundLength = max(0, target.length - args.length); + + // 17. Set the attributes of the length own property of F to the values + // specified in 15.3.5.1. + var boundArgs = []; + for (var i = 0; i < boundLength; i++) { + array_push.call(boundArgs, '$' + i); + } + + // XXX Build a dynamic function with desired amount of arguments is the only + // way to set the length property of a function. + // In environments where Content Security Policies enabled (Chrome extensions, + // for ex.) all use of eval or Function costructor throws an exception. + // However in all of these environments Function.prototype.bind exists + // and so this code will never be executed. + bound = $Function('binder', 'return function (' + array_join.call(boundArgs, ',') + '){ return binder.apply(this, arguments); }')(binder); + + if (target.prototype) { + Empty.prototype = target.prototype; + bound.prototype = new Empty(); + // Clean up dangling references. + Empty.prototype = null; + } + + // TODO + // 18. Set the [[Extensible]] internal property of F to true. + + // TODO + // 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3). + // 20. Call the [[DefineOwnProperty]] internal method of F with + // arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]: + // thrower, [[Enumerable]]: false, [[Configurable]]: false}, and + // false. + // 21. Call the [[DefineOwnProperty]] internal method of F with + // arguments "arguments", PropertyDescriptor {[[Get]]: thrower, + // [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false}, + // and false. + + // TODO + // NOTE Function objects created using Function.prototype.bind do not + // have a prototype property or the [[Code]], [[FormalParameters]], and + // [[Scope]] internal properties. + // XXX can't delete prototype in pure-js. + + // 22. Return F. + return bound; + } + }); + + // _Please note: Shortcuts are defined after `Function.prototype.bind` as we + // use it in defining shortcuts. + var owns = call.bind(ObjectPrototype.hasOwnProperty); + var toStr = call.bind(ObjectPrototype.toString); + var arraySlice = call.bind(array_slice); + var arraySliceApply = apply.bind(array_slice); + /* globals document */ + if (typeof document === 'object' && document && document.documentElement) { + try { + arraySlice(document.documentElement.childNodes); + } catch (e) { + var origArraySlice = arraySlice; + var origArraySliceApply = arraySliceApply; + arraySlice = function arraySliceIE(arr) { + var r = []; + var i = arr.length; + while (i-- > 0) { + r[i] = arr[i]; + } + return origArraySliceApply(r, origArraySlice(arguments, 1)); + }; + arraySliceApply = function arraySliceApplyIE(arr, args) { + return origArraySliceApply(arraySlice(arr), args); + }; + } + } + var strSlice = call.bind(StringPrototype.slice); + var strSplit = call.bind(StringPrototype.split); + var strIndexOf = call.bind(StringPrototype.indexOf); + var pushCall = call.bind(array_push); + var isEnum = call.bind(ObjectPrototype.propertyIsEnumerable); + var arraySort = call.bind(ArrayPrototype.sort); + + // + // Array + // ===== + // + + var isArray = $Array.isArray || function isArray(obj) { + return toStr(obj) === '[object Array]'; + }; + + // ES5 15.4.4.12 + // http://es5.github.com/#x15.4.4.13 + // Return len+argCount. + // [bugfix, ielt8] + // IE < 8 bug: [].unshift(0) === undefined but should be "1" + var hasUnshiftReturnValueBug = [].unshift(0) !== 1; + defineProperties(ArrayPrototype, { + unshift: function () { + array_unshift.apply(this, arguments); + return this.length; + } + }, hasUnshiftReturnValueBug); + + // ES5 15.4.3.2 + // http://es5.github.com/#x15.4.3.2 + // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray + defineProperties($Array, { isArray: isArray }); + + // The IsCallable() check in the Array functions + // has been replaced with a strict check on the + // internal class of the object to trap cases where + // the provided function was actually a regular + // expression literal, which in V8 and + // JavaScriptCore is a typeof "function". Only in + // V8 are regular expression literals permitted as + // reduce parameters, so it is desirable in the + // general case for the shim to match the more + // strict and common behavior of rejecting regular + // expressions. + + // ES5 15.4.4.18 + // http://es5.github.com/#x15.4.4.18 + // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/forEach + + // Check failure of by-index access of string characters (IE < 9) + // and failure of `0 in boxedString` (Rhino) + var boxedString = $Object('a'); + var splitString = boxedString[0] !== 'a' || !(0 in boxedString); + + var properlyBoxesContext = function properlyBoxed(method) { + // Check node 0.6.21 bug where third parameter is not boxed + var properlyBoxesNonStrict = true; + var properlyBoxesStrict = true; + var threwException = false; + if (method) { + try { + method.call('foo', function (_, __, context) { + if (typeof context !== 'object') { + properlyBoxesNonStrict = false; + } + }); + + method.call([1], function () { + 'use strict'; + + properlyBoxesStrict = typeof this === 'string'; + }, 'x'); + } catch (e) { + threwException = true; + } + } + return !!method && !threwException && properlyBoxesNonStrict && properlyBoxesStrict; + }; + + defineProperties(ArrayPrototype, { + forEach: function forEach(callbackfn/*, thisArg*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var i = -1; + var length = ES.ToUint32(self.length); + var T; + if (arguments.length > 1) { + T = arguments[1]; + } + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.forEach callback must be a function'); + } + + while (++i < length) { + if (i in self) { + // Invoke the callback function with call, passing arguments: + // context, property value, property key, thisArg object + if (typeof T === 'undefined') { + callbackfn(self[i], i, object); + } else { + callbackfn.call(T, self[i], i, object); + } + } + } + } + }, !properlyBoxesContext(ArrayPrototype.forEach)); + + // ES5 15.4.4.19 + // http://es5.github.com/#x15.4.4.19 + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map + defineProperties(ArrayPrototype, { + map: function map(callbackfn/*, thisArg*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + var result = $Array(length); + var T; + if (arguments.length > 1) { + T = arguments[1]; + } + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.map callback must be a function'); + } + + for (var i = 0; i < length; i++) { + if (i in self) { + if (typeof T === 'undefined') { + result[i] = callbackfn(self[i], i, object); + } else { + result[i] = callbackfn.call(T, self[i], i, object); + } + } + } + return result; + } + }, !properlyBoxesContext(ArrayPrototype.map)); + + // ES5 15.4.4.20 + // http://es5.github.com/#x15.4.4.20 + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter + defineProperties(ArrayPrototype, { + filter: function filter(callbackfn/*, thisArg*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + var result = []; + var value; + var T; + if (arguments.length > 1) { + T = arguments[1]; + } + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.filter callback must be a function'); + } + + for (var i = 0; i < length; i++) { + if (i in self) { + value = self[i]; + if (typeof T === 'undefined' ? callbackfn(value, i, object) : callbackfn.call(T, value, i, object)) { + pushCall(result, value); + } + } + } + return result; + } + }, !properlyBoxesContext(ArrayPrototype.filter)); + + // ES5 15.4.4.16 + // http://es5.github.com/#x15.4.4.16 + // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every + defineProperties(ArrayPrototype, { + every: function every(callbackfn/*, thisArg*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + var T; + if (arguments.length > 1) { + T = arguments[1]; + } + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.every callback must be a function'); + } + + for (var i = 0; i < length; i++) { + if (i in self && !(typeof T === 'undefined' ? callbackfn(self[i], i, object) : callbackfn.call(T, self[i], i, object))) { + return false; + } + } + return true; + } + }, !properlyBoxesContext(ArrayPrototype.every)); + + // ES5 15.4.4.17 + // http://es5.github.com/#x15.4.4.17 + // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some + defineProperties(ArrayPrototype, { + some: function some(callbackfn/*, thisArg */) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + var T; + if (arguments.length > 1) { + T = arguments[1]; + } + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.some callback must be a function'); + } + + for (var i = 0; i < length; i++) { + if (i in self && (typeof T === 'undefined' ? callbackfn(self[i], i, object) : callbackfn.call(T, self[i], i, object))) { + return true; + } + } + return false; + } + }, !properlyBoxesContext(ArrayPrototype.some)); + + // ES5 15.4.4.21 + // http://es5.github.com/#x15.4.4.21 + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce + var reduceCoercesToObject = false; + if (ArrayPrototype.reduce) { + reduceCoercesToObject = typeof ArrayPrototype.reduce.call('es5', function (_, __, ___, list) { + return list; + }) === 'object'; + } + defineProperties(ArrayPrototype, { + reduce: function reduce(callbackfn/*, initialValue*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.reduce callback must be a function'); + } + + // no value to return if no initial value and an empty array + if (length === 0 && arguments.length === 1) { + throw new TypeError('reduce of empty array with no initial value'); + } + + var i = 0; + var result; + if (arguments.length >= 2) { + result = arguments[1]; + } else { + do { + if (i in self) { + result = self[i++]; + break; + } + + // if array contains no values, no initial value to return + if (++i >= length) { + throw new TypeError('reduce of empty array with no initial value'); + } + } while (true); + } + + for (; i < length; i++) { + if (i in self) { + result = callbackfn(result, self[i], i, object); + } + } + + return result; + } + }, !reduceCoercesToObject); + + // ES5 15.4.4.22 + // http://es5.github.com/#x15.4.4.22 + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight + var reduceRightCoercesToObject = false; + if (ArrayPrototype.reduceRight) { + reduceRightCoercesToObject = typeof ArrayPrototype.reduceRight.call('es5', function (_, __, ___, list) { + return list; + }) === 'object'; + } + defineProperties(ArrayPrototype, { + reduceRight: function reduceRight(callbackfn/*, initial*/) { + var object = ES.ToObject(this); + var self = splitString && isString(this) ? strSplit(this, '') : object; + var length = ES.ToUint32(self.length); + + // If no callback function or if callback is not a callable function + if (!isCallable(callbackfn)) { + throw new TypeError('Array.prototype.reduceRight callback must be a function'); + } + + // no value to return if no initial value, empty array + if (length === 0 && arguments.length === 1) { + throw new TypeError('reduceRight of empty array with no initial value'); + } + + var result; + var i = length - 1; + if (arguments.length >= 2) { + result = arguments[1]; + } else { + do { + if (i in self) { + result = self[i--]; + break; + } + + // if array contains no values, no initial value to return + if (--i < 0) { + throw new TypeError('reduceRight of empty array with no initial value'); + } + } while (true); + } + + if (i < 0) { + return result; + } + + do { + if (i in self) { + result = callbackfn(result, self[i], i, object); + } + } while (i--); + + return result; + } + }, !reduceRightCoercesToObject); + + // ES5 15.4.4.14 + // http://es5.github.com/#x15.4.4.14 + // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf + var hasFirefox2IndexOfBug = ArrayPrototype.indexOf && [0, 1].indexOf(1, 2) !== -1; + defineProperties(ArrayPrototype, { + indexOf: function indexOf(searchElement/*, fromIndex */) { + var self = splitString && isString(this) ? strSplit(this, '') : ES.ToObject(this); + var length = ES.ToUint32(self.length); + + if (length === 0) { + return -1; + } + + var i = 0; + if (arguments.length > 1) { + i = ES.ToInteger(arguments[1]); + } + + // handle negative indices + i = i >= 0 ? i : max(0, length + i); + for (; i < length; i++) { + if (i in self && self[i] === searchElement) { + return i; + } + } + return -1; + } + }, hasFirefox2IndexOfBug); + + // ES5 15.4.4.15 + // http://es5.github.com/#x15.4.4.15 + // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf + var hasFirefox2LastIndexOfBug = ArrayPrototype.lastIndexOf && [0, 1].lastIndexOf(0, -3) !== -1; + defineProperties(ArrayPrototype, { + lastIndexOf: function lastIndexOf(searchElement/*, fromIndex */) { + var self = splitString && isString(this) ? strSplit(this, '') : ES.ToObject(this); + var length = ES.ToUint32(self.length); + + if (length === 0) { + return -1; + } + var i = length - 1; + if (arguments.length > 1) { + i = min(i, ES.ToInteger(arguments[1])); + } + // handle negative indices + i = i >= 0 ? i : length - Math.abs(i); + for (; i >= 0; i--) { + if (i in self && searchElement === self[i]) { + return i; + } + } + return -1; + } + }, hasFirefox2LastIndexOfBug); + + // ES5 15.4.4.12 + // http://es5.github.com/#x15.4.4.12 + var spliceNoopReturnsEmptyArray = (function () { + var a = [1, 2]; + var result = a.splice(); + return a.length === 2 && isArray(result) && result.length === 0; + }()); + defineProperties(ArrayPrototype, { + // Safari 5.0 bug where .splice() returns undefined + splice: function splice(start, deleteCount) { + if (arguments.length === 0) { + return []; + } else { + return array_splice.apply(this, arguments); + } + } + }, !spliceNoopReturnsEmptyArray); + + var spliceWorksWithEmptyObject = (function () { + var obj = {}; + ArrayPrototype.splice.call(obj, 0, 0, 1); + return obj.length === 1; + }()); + defineProperties(ArrayPrototype, { + splice: function splice(start, deleteCount) { + if (arguments.length === 0) { + return []; + } + var args = arguments; + this.length = max(ES.ToInteger(this.length), 0); + if (arguments.length > 0 && typeof deleteCount !== 'number') { + args = arraySlice(arguments); + if (args.length < 2) { + pushCall(args, this.length - start); + } else { + args[1] = ES.ToInteger(deleteCount); + } + } + return array_splice.apply(this, args); + } + }, !spliceWorksWithEmptyObject); + var spliceWorksWithLargeSparseArrays = (function () { + // Per https://github.com/es-shims/es5-shim/issues/295 + // Safari 7/8 breaks with sparse arrays of size 1e5 or greater + var arr = new $Array(1e5); + // note: the index MUST be 8 or larger or the test will false pass + arr[8] = 'x'; + arr.splice(1, 1); + // note: this test must be defined *after* the indexOf shim + // per https://github.com/es-shims/es5-shim/issues/313 + return arr.indexOf('x') === 7; + }()); + var spliceWorksWithSmallSparseArrays = (function () { + // Per https://github.com/es-shims/es5-shim/issues/295 + // Opera 12.15 breaks on this, no idea why. + var n = 256; + var arr = []; + arr[n] = 'a'; + arr.splice(n + 1, 0, 'b'); + return arr[n] === 'a'; + }()); + defineProperties(ArrayPrototype, { + splice: function splice(start, deleteCount) { + var O = ES.ToObject(this); + var A = []; + var len = ES.ToUint32(O.length); + var relativeStart = ES.ToInteger(start); + var actualStart = relativeStart < 0 ? max((len + relativeStart), 0) : min(relativeStart, len); + var actualDeleteCount = min(max(ES.ToInteger(deleteCount), 0), len - actualStart); + + var k = 0; + var from; + while (k < actualDeleteCount) { + from = $String(actualStart + k); + if (owns(O, from)) { + A[k] = O[from]; + } + k += 1; + } + + var items = arraySlice(arguments, 2); + var itemCount = items.length; + var to; + if (itemCount < actualDeleteCount) { + k = actualStart; + var maxK = len - actualDeleteCount; + while (k < maxK) { + from = $String(k + actualDeleteCount); + to = $String(k + itemCount); + if (owns(O, from)) { + O[to] = O[from]; + } else { + delete O[to]; + } + k += 1; + } + k = len; + var minK = len - actualDeleteCount + itemCount; + while (k > minK) { + delete O[k - 1]; + k -= 1; + } + } else if (itemCount > actualDeleteCount) { + k = len - actualDeleteCount; + while (k > actualStart) { + from = $String(k + actualDeleteCount - 1); + to = $String(k + itemCount - 1); + if (owns(O, from)) { + O[to] = O[from]; + } else { + delete O[to]; + } + k -= 1; + } + } + k = actualStart; + for (var i = 0; i < items.length; ++i) { + O[k] = items[i]; + k += 1; + } + O.length = len - actualDeleteCount + itemCount; + + return A; + } + }, !spliceWorksWithLargeSparseArrays || !spliceWorksWithSmallSparseArrays); + + var originalJoin = ArrayPrototype.join; + var hasStringJoinBug; + try { + hasStringJoinBug = Array.prototype.join.call('123', ',') !== '1,2,3'; + } catch (e) { + hasStringJoinBug = true; + } + if (hasStringJoinBug) { + defineProperties(ArrayPrototype, { + join: function join(separator) { + var sep = typeof separator === 'undefined' ? ',' : separator; + return originalJoin.call(isString(this) ? strSplit(this, '') : this, sep); + } + }, hasStringJoinBug); + } + + var hasJoinUndefinedBug = [1, 2].join(undefined) !== '1,2'; + if (hasJoinUndefinedBug) { + defineProperties(ArrayPrototype, { + join: function join(separator) { + var sep = typeof separator === 'undefined' ? ',' : separator; + return originalJoin.call(this, sep); + } + }, hasJoinUndefinedBug); + } + + var pushShim = function push(item) { + var O = ES.ToObject(this); + var n = ES.ToUint32(O.length); + var i = 0; + while (i < arguments.length) { + O[n + i] = arguments[i]; + i += 1; + } + O.length = n + i; + return n + i; + }; + + var pushIsNotGeneric = (function () { + var obj = {}; + var result = Array.prototype.push.call(obj, undefined); + return result !== 1 || obj.length !== 1 || typeof obj[0] !== 'undefined' || !owns(obj, 0); + }()); + defineProperties(ArrayPrototype, { + push: function push(item) { + if (isArray(this)) { + return array_push.apply(this, arguments); + } + return pushShim.apply(this, arguments); + } + }, pushIsNotGeneric); + + // This fixes a very weird bug in Opera 10.6 when pushing `undefined + var pushUndefinedIsWeird = (function () { + var arr = []; + var result = arr.push(undefined); + return result !== 1 || arr.length !== 1 || typeof arr[0] !== 'undefined' || !owns(arr, 0); + }()); + defineProperties(ArrayPrototype, { push: pushShim }, pushUndefinedIsWeird); + + // ES5 15.2.3.14 + // http://es5.github.io/#x15.4.4.10 + // Fix boxed string bug + defineProperties(ArrayPrototype, { + slice: function (start, end) { + var arr = isString(this) ? strSplit(this, '') : this; + return arraySliceApply(arr, arguments); + } + }, splitString); + + var sortIgnoresNonFunctions = (function () { + try { + [1, 2].sort(null); + } catch (e) { + try { + [1, 2].sort({}); + } catch (e2) { + return false; + } + } + return true; + }()); + var sortThrowsOnRegex = (function () { + // this is a problem in Firefox 4, in which `typeof /a/ === 'function'` + try { + [1, 2].sort(/a/); + return false; + } catch (e) {} + return true; + }()); + var sortIgnoresUndefined = (function () { + // applies in IE 8, for one. + try { + [1, 2].sort(undefined); + return true; + } catch (e) {} + return false; + }()); + defineProperties(ArrayPrototype, { + sort: function sort(compareFn) { + if (typeof compareFn === 'undefined') { + return arraySort(this); + } + if (!isCallable(compareFn)) { + throw new TypeError('Array.prototype.sort callback must be a function'); + } + return arraySort(this, compareFn); + } + }, sortIgnoresNonFunctions || !sortIgnoresUndefined || !sortThrowsOnRegex); + + // + // Object + // ====== + // + + // ES5 15.2.3.14 + // http://es5.github.com/#x15.2.3.14 + + // http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation + var hasDontEnumBug = !isEnum({ 'toString': null }, 'toString'); // jscs:ignore disallowQuotedKeysInObjects + var hasProtoEnumBug = isEnum(function () {}, 'prototype'); + var hasStringEnumBug = !owns('x', '0'); + var equalsConstructorPrototype = function (o) { + var ctor = o.constructor; + return ctor && ctor.prototype === o; + }; + var excludedKeys = { + $applicationCache: true, + $console: true, + $external: true, + $frame: true, + $frameElement: true, + $frames: true, + $innerHeight: true, + $innerWidth: true, + $onmozfullscreenchange: true, + $onmozfullscreenerror: true, + $outerHeight: true, + $outerWidth: true, + $pageXOffset: true, + $pageYOffset: true, + $parent: true, + $scrollLeft: true, + $scrollTop: true, + $scrollX: true, + $scrollY: true, + $self: true, + $webkitIndexedDB: true, + $webkitStorageInfo: true, + $window: true, + + $width: true, + $height: true, + $top: true, + $localStorage: true + }; + var hasAutomationEqualityBug = (function () { + /* globals window */ + if (typeof window === 'undefined') { + return false; + } + for (var k in window) { + try { + if (!excludedKeys['$' + k] && owns(window, k) && window[k] !== null && typeof window[k] === 'object') { + equalsConstructorPrototype(window[k]); + } + } catch (e) { + return true; + } + } + return false; + }()); + var equalsConstructorPrototypeIfNotBuggy = function (object) { + if (typeof window === 'undefined' || !hasAutomationEqualityBug) { + return equalsConstructorPrototype(object); + } + try { + return equalsConstructorPrototype(object); + } catch (e) { + return false; + } + }; + var dontEnums = [ + 'toString', + 'toLocaleString', + 'valueOf', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'constructor' + ]; + var dontEnumsLength = dontEnums.length; + + // taken directly from https://github.com/ljharb/is-arguments/blob/master/index.js + // can be replaced with require('is-arguments') if we ever use a build process instead + var isStandardArguments = function isArguments(value) { + return toStr(value) === '[object Arguments]'; + }; + var isLegacyArguments = function isArguments(value) { + return value !== null + && typeof value === 'object' + && typeof value.length === 'number' + && value.length >= 0 + && !isArray(value) + && isCallable(value.callee); + }; + var isArguments = isStandardArguments(arguments) ? isStandardArguments : isLegacyArguments; + + defineProperties($Object, { + keys: function keys(object) { + var isFn = isCallable(object); + var isArgs = isArguments(object); + var isObject = object !== null && typeof object === 'object'; + var isStr = isObject && isString(object); + + if (!isObject && !isFn && !isArgs) { + throw new TypeError('Object.keys called on a non-object'); + } + + var theKeys = []; + var skipProto = hasProtoEnumBug && isFn; + if ((isStr && hasStringEnumBug) || isArgs) { + for (var i = 0; i < object.length; ++i) { + pushCall(theKeys, $String(i)); + } + } + + if (!isArgs) { + for (var name in object) { + if (!(skipProto && name === 'prototype') && owns(object, name)) { + pushCall(theKeys, $String(name)); + } + } + } + + if (hasDontEnumBug) { + var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object); + for (var j = 0; j < dontEnumsLength; j++) { + var dontEnum = dontEnums[j]; + if (!(skipConstructor && dontEnum === 'constructor') && owns(object, dontEnum)) { + pushCall(theKeys, dontEnum); + } + } + } + return theKeys; + } + }); + + var keysWorksWithArguments = $Object.keys && (function () { + // Safari 5.0 bug + return $Object.keys(arguments).length === 2; + }(1, 2)); + var keysHasArgumentsLengthBug = $Object.keys && (function () { + var argKeys = $Object.keys(arguments); + return arguments.length !== 1 || argKeys.length !== 1 || argKeys[0] !== 1; + }(1)); + var originalKeys = $Object.keys; + defineProperties($Object, { + keys: function keys(object) { + if (isArguments(object)) { + return originalKeys(arraySlice(object)); + } else { + return originalKeys(object); + } + } + }, !keysWorksWithArguments || keysHasArgumentsLengthBug); + + // + // Date + // ==== + // + + var hasNegativeMonthYearBug = new Date(-3509827329600292).getUTCMonth() !== 0; + var aNegativeTestDate = new Date(-1509842289600292); + var aPositiveTestDate = new Date(1449662400000); + var hasToUTCStringFormatBug = aNegativeTestDate.toUTCString() !== 'Mon, 01 Jan -45875 11:59:59 GMT'; + var hasToDateStringFormatBug; + var hasToStringFormatBug; + var timeZoneOffset = aNegativeTestDate.getTimezoneOffset(); + if (timeZoneOffset < -720) { + hasToDateStringFormatBug = aNegativeTestDate.toDateString() !== 'Tue Jan 02 -45875'; + hasToStringFormatBug = !(/^Thu Dec 10 2015 \d\d:\d\d:\d\d GMT[-+]\d\d\d\d(?: |$)/).test(String(aPositiveTestDate)); + } else { + hasToDateStringFormatBug = aNegativeTestDate.toDateString() !== 'Mon Jan 01 -45875'; + hasToStringFormatBug = !(/^Wed Dec 09 2015 \d\d:\d\d:\d\d GMT[-+]\d\d\d\d(?: |$)/).test(String(aPositiveTestDate)); + } + + var originalGetFullYear = call.bind(Date.prototype.getFullYear); + var originalGetMonth = call.bind(Date.prototype.getMonth); + var originalGetDate = call.bind(Date.prototype.getDate); + var originalGetUTCFullYear = call.bind(Date.prototype.getUTCFullYear); + var originalGetUTCMonth = call.bind(Date.prototype.getUTCMonth); + var originalGetUTCDate = call.bind(Date.prototype.getUTCDate); + var originalGetUTCDay = call.bind(Date.prototype.getUTCDay); + var originalGetUTCHours = call.bind(Date.prototype.getUTCHours); + var originalGetUTCMinutes = call.bind(Date.prototype.getUTCMinutes); + var originalGetUTCSeconds = call.bind(Date.prototype.getUTCSeconds); + var originalGetUTCMilliseconds = call.bind(Date.prototype.getUTCMilliseconds); + var dayName = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']; + var monthName = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']; + var daysInMonth = function daysInMonth(month, year) { + return originalGetDate(new Date(year, month, 0)); + }; + + defineProperties(Date.prototype, { + getFullYear: function getFullYear() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetFullYear(this); + if (year < 0 && originalGetMonth(this) > 11) { + return year + 1; + } + return year; + }, + getMonth: function getMonth() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetFullYear(this); + var month = originalGetMonth(this); + if (year < 0 && month > 11) { + return 0; + } + return month; + }, + getDate: function getDate() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetFullYear(this); + var month = originalGetMonth(this); + var date = originalGetDate(this); + if (year < 0 && month > 11) { + if (month === 12) { + return date; + } + var days = daysInMonth(0, year + 1); + return (days - date) + 1; + } + return date; + }, + getUTCFullYear: function getUTCFullYear() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetUTCFullYear(this); + if (year < 0 && originalGetUTCMonth(this) > 11) { + return year + 1; + } + return year; + }, + getUTCMonth: function getUTCMonth() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetUTCFullYear(this); + var month = originalGetUTCMonth(this); + if (year < 0 && month > 11) { + return 0; + } + return month; + }, + getUTCDate: function getUTCDate() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var year = originalGetUTCFullYear(this); + var month = originalGetUTCMonth(this); + var date = originalGetUTCDate(this); + if (year < 0 && month > 11) { + if (month === 12) { + return date; + } + var days = daysInMonth(0, year + 1); + return (days - date) + 1; + } + return date; + } + }, hasNegativeMonthYearBug); + + defineProperties(Date.prototype, { + toUTCString: function toUTCString() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var day = originalGetUTCDay(this); + var date = originalGetUTCDate(this); + var month = originalGetUTCMonth(this); + var year = originalGetUTCFullYear(this); + var hour = originalGetUTCHours(this); + var minute = originalGetUTCMinutes(this); + var second = originalGetUTCSeconds(this); + 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'; + } + }, hasNegativeMonthYearBug || hasToUTCStringFormatBug); + + // Opera 12 has `,` + defineProperties(Date.prototype, { + toDateString: function toDateString() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var day = this.getDay(); + var date = this.getDate(); + var month = this.getMonth(); + var year = this.getFullYear(); + return dayName[day] + ' ' + + monthName[month] + ' ' + + (date < 10 ? '0' + date : date) + ' ' + + year; + } + }, hasNegativeMonthYearBug || hasToDateStringFormatBug); + + // can't use defineProperties here because of toString enumeration issue in IE <= 8 + if (hasNegativeMonthYearBug || hasToStringFormatBug) { + Date.prototype.toString = function toString() { + if (!this || !(this instanceof Date)) { + throw new TypeError('this is not a Date object.'); + } + var day = this.getDay(); + var date = this.getDate(); + var month = this.getMonth(); + var year = this.getFullYear(); + var hour = this.getHours(); + var minute = this.getMinutes(); + var second = this.getSeconds(); + var timezoneOffset = this.getTimezoneOffset(); + var hoursOffset = Math.floor(Math.abs(timezoneOffset) / 60); + var minutesOffset = Math.floor(Math.abs(timezoneOffset) % 60); + 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); + }; + if (supportsDescriptors) { + $Object.defineProperty(Date.prototype, 'toString', { + configurable: true, + enumerable: false, + writable: true + }); + } + } + + // ES5 15.9.5.43 + // http://es5.github.com/#x15.9.5.43 + // This function returns a String value represent the instance in time + // represented by this Date object. The format of the String is the Date Time + // string format defined in 15.9.1.15. All fields are present in the String. + // The time zone is always UTC, denoted by the suffix Z. If the time value of + // this object is not a finite Number a RangeError exception is thrown. + var negativeDate = -62198755200000; + var negativeYearString = '-000001'; + var hasNegativeDateBug = Date.prototype.toISOString && new Date(negativeDate).toISOString().indexOf(negativeYearString) === -1; // eslint-disable-line max-len + var hasSafari51DateBug = Date.prototype.toISOString && new Date(-1).toISOString() !== '1969-12-31T23:59:59.999Z'; + + var getTime = call.bind(Date.prototype.getTime); + + defineProperties(Date.prototype, { + toISOString: function toISOString() { + if (!isFinite(this) || !isFinite(getTime(this))) { + // Adope Photoshop requires the second check. + throw new RangeError('Date.prototype.toISOString called on non-finite value.'); + } + + var year = originalGetUTCFullYear(this); + + var month = originalGetUTCMonth(this); + // see https://github.com/es-shims/es5-shim/issues/111 + year += Math.floor(month / 12); + month = ((month % 12) + 12) % 12; + + // the date time string format is specified in 15.9.1.15. + var result = [ + month + 1, + originalGetUTCDate(this), + originalGetUTCHours(this), + originalGetUTCMinutes(this), + originalGetUTCSeconds(this) + ]; + year = ( + (year < 0 ? '-' : (year > 9999 ? '+' : '')) + + strSlice('00000' + Math.abs(year), (0 <= year && year <= 9999) ? -4 : -6) + ); + + for (var i = 0; i < result.length; ++i) { + // pad months, days, hours, minutes, and seconds to have two digits. + result[i] = strSlice('00' + result[i], -2); + } + // pad milliseconds to have three digits. + return ( + year + '-' + arraySlice(result, 0, 2).join('-') + + 'T' + arraySlice(result, 2).join(':') + '.' + + strSlice('000' + originalGetUTCMilliseconds(this), -3) + 'Z' + ); + } + }, hasNegativeDateBug || hasSafari51DateBug); + + // ES5 15.9.5.44 + // http://es5.github.com/#x15.9.5.44 + // This function provides a String representation of a Date object for use by + // JSON.stringify (15.12.3). + var dateToJSONIsSupported = (function () { + try { + return Date.prototype.toJSON + && new Date(NaN).toJSON() === null + && new Date(negativeDate).toJSON().indexOf(negativeYearString) !== -1 + && Date.prototype.toJSON.call({ // generic + toISOString: function () { return true; } + }); + } catch (e) { + return false; + } + }()); + if (!dateToJSONIsSupported) { + Date.prototype.toJSON = function toJSON(key) { + // When the toJSON method is called with argument key, the following + // steps are taken: + + // 1. Let O be the result of calling ToObject, giving it the this + // value as its argument. + // 2. Let tv be ES.ToPrimitive(O, hint Number). + var O = $Object(this); + var tv = ES.ToPrimitive(O); + // 3. If tv is a Number and is not finite, return null. + if (typeof tv === 'number' && !isFinite(tv)) { + return null; + } + // 4. Let toISO be the result of calling the [[Get]] internal method of + // O with argument "toISOString". + var toISO = O.toISOString; + // 5. If IsCallable(toISO) is false, throw a TypeError exception. + if (!isCallable(toISO)) { + throw new TypeError('toISOString property is not callable'); + } + // 6. Return the result of calling the [[Call]] internal method of + // toISO with O as the this value and an empty argument list. + return toISO.call(O); + + // NOTE 1 The argument is ignored. + + // NOTE 2 The toJSON function is intentionally generic; it does not + // require that its this value be a Date object. Therefore, it can be + // transferred to other kinds of objects for use as a method. However, + // it does require that any such object have a toISOString method. An + // object is free to use the argument key to filter its + // stringification. + }; + } + + // ES5 15.9.4.2 + // http://es5.github.com/#x15.9.4.2 + // based on work shared by Daniel Friesen (dantman) + // http://gist.github.com/303249 + var supportsExtendedYears = Date.parse('+033658-09-27T01:46:40.000Z') === 1e15; + 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')); + var doesNotParseY2KNewYear = isNaN(Date.parse('2000-01-01T00:00:00.000Z')); + if (doesNotParseY2KNewYear || acceptsInvalidDates || !supportsExtendedYears) { + // XXX global assignment won't work in embeddings that use + // an alternate object for the context. + /* global Date: true */ + var maxSafeUnsigned32Bit = Math.pow(2, 31) - 1; + var hasSafariSignedIntBug = isActualNaN(new Date(1970, 0, 1, 0, 0, 0, maxSafeUnsigned32Bit + 1).getTime()); + // eslint-disable-next-line no-implicit-globals, no-global-assign + Date = (function (NativeDate) { + // Date.length === 7 + var DateShim = function Date(Y, M, D, h, m, s, ms) { + var length = arguments.length; + var date; + if (this instanceof NativeDate) { + var seconds = s; + var millis = ms; + if (hasSafariSignedIntBug && length >= 7 && ms > maxSafeUnsigned32Bit) { + // work around a Safari 8/9 bug where it treats the seconds as signed + var msToShift = Math.floor(ms / maxSafeUnsigned32Bit) * maxSafeUnsigned32Bit; + var sToShift = Math.floor(msToShift / 1e3); + seconds += sToShift; + millis -= sToShift * 1e3; + } + date = length === 1 && $String(Y) === Y // isString(Y) + // We explicitly pass it through parse: + ? new NativeDate(DateShim.parse(Y)) + // We have to manually make calls depending on argument + // length here + : 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(); + } else { + date = NativeDate.apply(this, arguments); + } + if (!isPrimitive(date)) { + // Prevent mixups with unfixed Date object + defineProperties(date, { constructor: DateShim }, true); + } + return date; + }; + + // 15.9.1.15 Date Time String Format. + var isoDateExpression = new RegExp('^' + + '(\\d{4}|[+-]\\d{6})' // four-digit year capture or sign + 6-digit extended year + + '(?:-(\\d{2})' // optional month capture + + '(?:-(\\d{2})' // optional day capture + + '(?:' // capture hours:minutes:seconds.milliseconds + + 'T(\\d{2})' // hours capture + + ':(\\d{2})' // minutes capture + + '(?:' // optional :seconds.milliseconds + + ':(\\d{2})' // seconds capture + + '(?:(\\.\\d{1,}))?' // milliseconds capture + + ')?' + + '(' // capture UTC offset component + + 'Z|' // UTC capture + + '(?:' // offset specifier +/-hours:minutes + + '([-+])' // sign capture + + '(\\d{2})' // hours offset capture + + ':(\\d{2})' // minutes offset capture + + ')' + + ')?)?)?)?' + + '$'); + + var months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365]; + + var dayFromMonth = function dayFromMonth(year, month) { + var t = month > 1 ? 1 : 0; + return ( + months[month] + + Math.floor((year - 1969 + t) / 4) + - Math.floor((year - 1901 + t) / 100) + + Math.floor((year - 1601 + t) / 400) + + (365 * (year - 1970)) + ); + }; + + var toUTC = function toUTC(t) { + var s = 0; + var ms = t; + if (hasSafariSignedIntBug && ms > maxSafeUnsigned32Bit) { + // work around a Safari 8/9 bug where it treats the seconds as signed + var msToShift = Math.floor(ms / maxSafeUnsigned32Bit) * maxSafeUnsigned32Bit; + var sToShift = Math.floor(msToShift / 1e3); + s += sToShift; + ms -= sToShift * 1e3; + } + return $Number(new NativeDate(1970, 0, 1, 0, 0, s, ms)); + }; + + // Copy any custom methods a 3rd party library may have added + for (var key in NativeDate) { + if (owns(NativeDate, key)) { + DateShim[key] = NativeDate[key]; + } + } + + // Copy "native" methods explicitly; they may be non-enumerable + defineProperties(DateShim, { + now: NativeDate.now, + UTC: NativeDate.UTC + }, true); + DateShim.prototype = NativeDate.prototype; + defineProperties(DateShim.prototype, { constructor: DateShim }, true); + + // Upgrade Date.parse to handle simplified ISO 8601 strings + var parseShim = function parse(string) { + var match = isoDateExpression.exec(string); + if (match) { + // parse months, days, hours, minutes, seconds, and milliseconds + // provide default values if necessary + // parse the UTC offset component + var year = $Number(match[1]), + month = $Number(match[2] || 1) - 1, + day = $Number(match[3] || 1) - 1, + hour = $Number(match[4] || 0), + minute = $Number(match[5] || 0), + second = $Number(match[6] || 0), + millisecond = Math.floor($Number(match[7] || 0) * 1000), + // When time zone is missed, local offset should be used + // (ES 5.1 bug) + // see https://bugs.ecmascript.org/show_bug.cgi?id=112 + isLocalTime = Boolean(match[4] && !match[8]), + signOffset = match[9] === '-' ? 1 : -1, + hourOffset = $Number(match[10] || 0), + minuteOffset = $Number(match[11] || 0), + result; + var hasMinutesOrSecondsOrMilliseconds = minute > 0 || second > 0 || millisecond > 0; + if ( + hour < (hasMinutesOrSecondsOrMilliseconds ? 24 : 25) + && minute < 60 && second < 60 && millisecond < 1000 + && month > -1 && month < 12 && hourOffset < 24 + && minuteOffset < 60 // detect invalid offsets + && day > -1 + && day < (dayFromMonth(year, month + 1) - dayFromMonth(year, month)) + ) { + result = ( + ((dayFromMonth(year, month) + day) * 24) + + hour + + (hourOffset * signOffset) + ) * 60; + result = (( + ((result + minute + (minuteOffset * signOffset)) * 60) + + second + ) * 1000) + millisecond; + if (isLocalTime) { + result = toUTC(result); + } + if (-8.64e15 <= result && result <= 8.64e15) { + return result; + } + } + return NaN; + } + return NativeDate.parse.apply(this, arguments); + }; + defineProperties(DateShim, { parse: parseShim }); + + return DateShim; + }(Date)); + /* global Date: false */ + } + + // ES5 15.9.4.4 + // http://es5.github.com/#x15.9.4.4 + if (!Date.now) { + Date.now = function now() { + return new Date().getTime(); + }; + } + + // + // Number + // ====== + // + + // ES5.1 15.7.4.5 + // http://es5.github.com/#x15.7.4.5 + 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' + ); + + var toFixedHelpers = { + base: 1e7, + size: 6, + data: [0, 0, 0, 0, 0, 0], + multiply: function multiply(n, c) { + var i = -1; + var c2 = c; + while (++i < toFixedHelpers.size) { + c2 += n * toFixedHelpers.data[i]; + toFixedHelpers.data[i] = c2 % toFixedHelpers.base; + c2 = Math.floor(c2 / toFixedHelpers.base); + } + }, + divide: function divide(n) { + var i = toFixedHelpers.size; + var c = 0; + while (--i >= 0) { + c += toFixedHelpers.data[i]; + toFixedHelpers.data[i] = Math.floor(c / n); + c = (c % n) * toFixedHelpers.base; + } + }, + numToString: function numToString() { + var i = toFixedHelpers.size; + var s = ''; + while (--i >= 0) { + if (s !== '' || i === 0 || toFixedHelpers.data[i] !== 0) { + var t = $String(toFixedHelpers.data[i]); + if (s === '') { + s = t; + } else { + s += strSlice('0000000', 0, 7 - t.length) + t; + } + } + } + return s; + }, + pow: function pow(x, n, acc) { + return (n === 0 ? acc : (n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc))); + }, + log: function log(x) { + var n = 0; + var x2 = x; + while (x2 >= 4096) { + n += 12; + x2 /= 4096; + } + while (x2 >= 2) { + n += 1; + x2 /= 2; + } + return n; + } + }; + + var toFixedShim = function toFixed(fractionDigits) { + var f, x, s, m, e, z, j, k; + + // Test for NaN and round fractionDigits down + f = $Number(fractionDigits); + f = isActualNaN(f) ? 0 : Math.floor(f); + + if (f < 0 || f > 20) { + throw new RangeError('Number.toFixed called with invalid number of decimals'); + } + + x = $Number(this); + + if (isActualNaN(x)) { + return 'NaN'; + } + + // If it is too big or small, return the string value of the number + if (x <= -1e21 || x >= 1e21) { + return $String(x); + } + + s = ''; + + if (x < 0) { + s = '-'; + x = -x; + } + + m = '0'; + + if (x > 1e-21) { + // 1e-21 < x < 1e21 + // -70 < log2(x) < 70 + e = toFixedHelpers.log(x * toFixedHelpers.pow(2, 69, 1)) - 69; + z = (e < 0 ? x * toFixedHelpers.pow(2, -e, 1) : x / toFixedHelpers.pow(2, e, 1)); + z *= 0x10000000000000; // Math.pow(2, 52); + e = 52 - e; + + // -18 < e < 122 + // x = z / 2 ^ e + if (e > 0) { + toFixedHelpers.multiply(0, z); + j = f; + + while (j >= 7) { + toFixedHelpers.multiply(1e7, 0); + j -= 7; + } + + toFixedHelpers.multiply(toFixedHelpers.pow(10, j, 1), 0); + j = e - 1; + + while (j >= 23) { + toFixedHelpers.divide(1 << 23); + j -= 23; + } + + toFixedHelpers.divide(1 << j); + toFixedHelpers.multiply(1, 1); + toFixedHelpers.divide(2); + m = toFixedHelpers.numToString(); + } else { + toFixedHelpers.multiply(0, z); + toFixedHelpers.multiply(1 << (-e), 0); + m = toFixedHelpers.numToString() + strSlice('0.00000000000000000000', 2, 2 + f); + } + } + + if (f > 0) { + k = m.length; + + if (k <= f) { + m = s + strSlice('0.0000000000000000000', 0, f - k + 2) + m; + } else { + m = s + strSlice(m, 0, k - f) + '.' + strSlice(m, k - f); + } + } else { + m = s + m; + } + + return m; + }; + defineProperties(NumberPrototype, { toFixed: toFixedShim }, hasToFixedBugs); + + var hasToPrecisionUndefinedBug = (function () { + try { + return 1.0.toPrecision(undefined) === '1'; + } catch (e) { + return true; + } + }()); + var originalToPrecision = NumberPrototype.toPrecision; + defineProperties(NumberPrototype, { + toPrecision: function toPrecision(precision) { + return typeof precision === 'undefined' ? originalToPrecision.call(this) : originalToPrecision.call(this, precision); + } + }, hasToPrecisionUndefinedBug); + + // + // String + // ====== + // + + // ES5 15.5.4.14 + // http://es5.github.com/#x15.5.4.14 + + // [bugfix, IE lt 9, firefox 4, Konqueror, Opera, obscure browsers] + // Many browsers do not split properly with regular expressions or they + // do not perform the split correctly under obscure conditions. + // See http://blog.stevenlevithan.com/archives/cross-browser-split + // I've tested in many browsers and this seems to cover the deviant ones: + // 'ab'.split(/(?:ab)*/) should be ["", ""], not [""] + // '.'.split(/(.?)(.?)/) should be ["", ".", "", ""], not ["", ""] + // 'tesst'.split(/(s)*/) should be ["t", undefined, "e", "s", "t"], not + // [undefined, "t", undefined, "e", ...] + // ''.split(/.?/) should be [], not [""] + // '.'.split(/()()/) should be ["."], not ["", "", "."] + + if ( + 'ab'.split(/(?:ab)*/).length !== 2 + || '.'.split(/(.?)(.?)/).length !== 4 + || 'tesst'.split(/(s)*/)[1] === 't' + || 'test'.split(/(?:)/, -1).length !== 4 + || ''.split(/.?/).length + || '.'.split(/()()/).length > 1 + ) { + (function () { + var compliantExecNpcg = typeof (/()??/).exec('')[1] === 'undefined'; // NPCG: nonparticipating capturing group + var maxSafe32BitInt = Math.pow(2, 32) - 1; + + StringPrototype.split = function (separator, limit) { + var string = String(this); + if (typeof separator === 'undefined' && limit === 0) { + return []; + } + + // If `separator` is not a regex, use native split + if (!isRegex(separator)) { + return strSplit(this, separator, limit); + } + + var output = []; + var flags = (separator.ignoreCase ? 'i' : '') + + (separator.multiline ? 'm' : '') + + (separator.unicode ? 'u' : '') // in ES6 + + (separator.sticky ? 'y' : ''), // Firefox 3+ and ES6 + lastLastIndex = 0, + // Make `global` and avoid `lastIndex` issues by working with a copy + separator2, match, lastIndex, lastLength; + var separatorCopy = new RegExp(separator.source, flags + 'g'); + if (!compliantExecNpcg) { + // Doesn't need flags gy, but they don't hurt + separator2 = new RegExp('^' + separatorCopy.source + '$(?!\\s)', flags); + } + /* Values for `limit`, per the spec: + * If undefined: 4294967295 // maxSafe32BitInt + * If 0, Infinity, or NaN: 0 + * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296; + * If negative number: 4294967296 - Math.floor(Math.abs(limit)) + * If other: Type-convert, then use the above rules + */ + var splitLimit = typeof limit === 'undefined' ? maxSafe32BitInt : ES.ToUint32(limit); + match = separatorCopy.exec(string); + while (match) { + // `separatorCopy.lastIndex` is not reliable cross-browser + lastIndex = match.index + match[0].length; + if (lastIndex > lastLastIndex) { + pushCall(output, strSlice(string, lastLastIndex, match.index)); + // Fix browsers whose `exec` methods don't consistently return `undefined` for + // nonparticipating capturing groups + if (!compliantExecNpcg && match.length > 1) { + /* eslint-disable no-loop-func */ + match[0].replace(separator2, function () { + for (var i = 1; i < arguments.length - 2; i++) { + if (typeof arguments[i] === 'undefined') { + match[i] = void 0; + } + } + }); + /* eslint-enable no-loop-func */ + } + if (match.length > 1 && match.index < string.length) { + array_push.apply(output, arraySlice(match, 1)); + } + lastLength = match[0].length; + lastLastIndex = lastIndex; + if (output.length >= splitLimit) { + break; + } + } + if (separatorCopy.lastIndex === match.index) { + separatorCopy.lastIndex++; // Avoid an infinite loop + } + match = separatorCopy.exec(string); + } + if (lastLastIndex === string.length) { + if (lastLength || !separatorCopy.test('')) { + pushCall(output, ''); + } + } else { + pushCall(output, strSlice(string, lastLastIndex)); + } + return output.length > splitLimit ? arraySlice(output, 0, splitLimit) : output; + }; + }()); + + // [bugfix, chrome] + // If separator is undefined, then the result array contains just one String, + // which is the this value (converted to a String). If limit is not undefined, + // then the output array is truncated so that it contains no more than limit + // elements. + // "0".split(undefined, 0) -> [] + } else if ('0'.split(void 0, 0).length) { + StringPrototype.split = function split(separator, limit) { + if (typeof separator === 'undefined' && limit === 0) { + return []; + } + return strSplit(this, separator, limit); + }; + } + + var str_replace = StringPrototype.replace; + var replaceReportsGroupsCorrectly = (function () { + var groups = []; + 'x'.replace(/x(.)?/g, function (match, group) { + pushCall(groups, group); + }); + return groups.length === 1 && typeof groups[0] === 'undefined'; + }()); + + if (!replaceReportsGroupsCorrectly) { + StringPrototype.replace = function replace(searchValue, replaceValue) { + var isFn = isCallable(replaceValue); + var hasCapturingGroups = isRegex(searchValue) && (/\)[*?]/).test(searchValue.source); + if (!isFn || !hasCapturingGroups) { + return str_replace.call(this, searchValue, replaceValue); + } else { + var wrappedReplaceValue = function (match) { + var length = arguments.length; + var originalLastIndex = searchValue.lastIndex; + searchValue.lastIndex = 0; + var args = searchValue.exec(match) || []; + searchValue.lastIndex = originalLastIndex; + pushCall(args, arguments[length - 2], arguments[length - 1]); + return replaceValue.apply(this, args); + }; + return str_replace.call(this, searchValue, wrappedReplaceValue); + } + }; + } + + // ECMA-262, 3rd B.2.3 + // Not an ECMAScript standard, although ECMAScript 3rd Edition has a + // non-normative section suggesting uniform semantics and it should be + // normalized across all browsers + // [bugfix, IE lt 9] IE < 9 substr() with negative value not working in IE + var string_substr = StringPrototype.substr; + var hasNegativeSubstrBug = ''.substr && '0b'.substr(-1) !== 'b'; + defineProperties(StringPrototype, { + substr: function substr(start, length) { + var normalizedStart = start; + if (start < 0) { + normalizedStart = max(this.length + start, 0); + } + return string_substr.call(this, normalizedStart, length); + } + }, hasNegativeSubstrBug); + + // ES5 15.5.4.20 + // whitespace from: http://es5.github.io/#x15.5.4.20 + var ws = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' + + '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028' + + '\u2029\uFEFF'; + var zeroWidth = '\u200b'; + var wsRegexChars = '[' + ws + ']'; + var trimBeginRegexp = new RegExp('^' + wsRegexChars + wsRegexChars + '*'); + var trimEndRegexp = new RegExp(wsRegexChars + wsRegexChars + '*$'); + var hasTrimWhitespaceBug = StringPrototype.trim && (ws.trim() || !zeroWidth.trim()); + defineProperties(StringPrototype, { + // http://blog.stevenlevithan.com/archives/faster-trim-javascript + // http://perfectionkills.com/whitespace-deviations/ + trim: function trim() { + if (typeof this === 'undefined' || this === null) { + throw new TypeError("can't convert " + this + ' to object'); + } + return $String(this).replace(trimBeginRegexp, '').replace(trimEndRegexp, ''); + } + }, hasTrimWhitespaceBug); + var trim = call.bind(String.prototype.trim); + + var hasLastIndexBug = StringPrototype.lastIndexOf && 'abcあい'.lastIndexOf('あい', 2) !== -1; + defineProperties(StringPrototype, { + lastIndexOf: function lastIndexOf(searchString) { + if (typeof this === 'undefined' || this === null) { + throw new TypeError("can't convert " + this + ' to object'); + } + var S = $String(this); + var searchStr = $String(searchString); + var numPos = arguments.length > 1 ? $Number(arguments[1]) : NaN; + var pos = isActualNaN(numPos) ? Infinity : ES.ToInteger(numPos); + var start = min(max(pos, 0), S.length); + var searchLen = searchStr.length; + var k = start + searchLen; + while (k > 0) { + k = max(0, k - searchLen); + var index = strIndexOf(strSlice(S, k, start + searchLen), searchStr); + if (index !== -1) { + return k + index; + } + } + return -1; + } + }, hasLastIndexBug); + + var originalLastIndexOf = StringPrototype.lastIndexOf; + defineProperties(StringPrototype, { + lastIndexOf: function lastIndexOf(searchString) { + return originalLastIndexOf.apply(this, arguments); + } + }, StringPrototype.lastIndexOf.length !== 1); + + // ES-5 15.1.2.2 + // eslint-disable-next-line radix + if (parseInt(ws + '08') !== 8 || parseInt(ws + '0x16') !== 22) { + /* global parseInt: true */ + parseInt = (function (origParseInt) { + var hexRegex = /^[-+]?0[xX]/; + return function parseInt(str, radix) { + if (typeof str === 'symbol') { + // handle Symbols in node 8.3/8.4 + // eslint-disable-next-line no-implicit-coercion, no-unused-expressions + '' + str; // jscs:ignore disallowImplicitTypeConversion + } + + var string = trim(String(str)); + var defaultedRadix = $Number(radix) || (hexRegex.test(string) ? 16 : 10); + return origParseInt(string, defaultedRadix); + }; + }(parseInt)); + } + + // https://es5.github.io/#x15.1.2.3 + if (1 / parseFloat('-0') !== -Infinity) { + /* global parseFloat: true */ + parseFloat = (function (origParseFloat) { + return function parseFloat(string) { + var inputString = trim(String(string)); + var result = origParseFloat(inputString); + return result === 0 && strSlice(inputString, 0, 1) === '-' ? -0 : result; + }; + }(parseFloat)); + } + + if (String(new RangeError('test')) !== 'RangeError: test') { + var errorToStringShim = function toString() { + if (typeof this === 'undefined' || this === null) { + throw new TypeError("can't convert " + this + ' to object'); + } + var name = this.name; + if (typeof name === 'undefined') { + name = 'Error'; + } else if (typeof name !== 'string') { + name = $String(name); + } + var msg = this.message; + if (typeof msg === 'undefined') { + msg = ''; + } else if (typeof msg !== 'string') { + msg = $String(msg); + } + if (!name) { + return msg; + } + if (!msg) { + return name; + } + return name + ': ' + msg; + }; + // can't use defineProperties here because of toString enumeration issue in IE <= 8 + Error.prototype.toString = errorToStringShim; + } + + if (supportsDescriptors) { + var ensureNonEnumerable = function (obj, prop) { + if (isEnum(obj, prop)) { + var desc = Object.getOwnPropertyDescriptor(obj, prop); + if (desc.configurable) { + desc.enumerable = false; + Object.defineProperty(obj, prop, desc); + } + } + }; + ensureNonEnumerable(Error.prototype, 'message'); + if (Error.prototype.message !== '') { + Error.prototype.message = ''; + } + ensureNonEnumerable(Error.prototype, 'name'); + } + + if (String(/a/mig) !== '/a/gim') { + var regexToString = function toString() { + var str = '/' + this.source + '/'; + if (this.global) { + str += 'g'; + } + if (this.ignoreCase) { + str += 'i'; + } + if (this.multiline) { + str += 'm'; + } + return str; + }; + // can't use defineProperties here because of toString enumeration issue in IE <= 8 + RegExp.prototype.toString = regexToString; + } +})); +}); diff --git a/test/form/samples/supports-es5-shim/main.js b/test/form/samples/supports-es5-shim/main.js new file mode 100644 index 00000000000..200d2ebcb69 --- /dev/null +++ b/test/form/samples/supports-es5-shim/main.js @@ -0,0 +1 @@ +import 'es5-shim'; diff --git a/test/form/samples/supports-es6-shim/_config.js b/test/form/samples/supports-es6-shim/_config.js new file mode 100644 index 00000000000..3097ca1d006 --- /dev/null +++ b/test/form/samples/supports-es6-shim/_config.js @@ -0,0 +1,13 @@ +module.exports = { + description: 'supports es6-shim', + options: { + onwarn(warning) { + if (warning.code !== 'THIS_IS_UNDEFINED') { + throw new Error(warning.message); + } + }, + // check against tree-shake: false when updating the shim + treeshake: true, + plugins: [require('rollup-plugin-node-resolve')(), require('rollup-plugin-commonjs')()] + } +}; diff --git a/test/form/samples/supports-es6-shim/_expected.js b/test/form/samples/supports-es6-shim/_expected.js new file mode 100644 index 00000000000..a5152302f6e --- /dev/null +++ b/test/form/samples/supports-es6-shim/_expected.js @@ -0,0 +1,3890 @@ +var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +function createCommonjsModule(fn, module) { + return module = { exports: {} }, fn(module, module.exports), module.exports; +} + +var es6Shim = createCommonjsModule(function (module, exports) { +/*! + * https://github.com/paulmillr/es6-shim + * @license es6-shim Copyright 2013-2016 by Paul Miller (http://paulmillr.com) + * and contributors, MIT License + * es6-shim: v0.35.4 + * see https://github.com/paulmillr/es6-shim/blob/0.35.3/LICENSE + * Details and documentation: + * https://github.com/paulmillr/es6-shim/ + */ + +// UMD (Universal Module Definition) +// see https://github.com/umdjs/umd/blob/master/returnExports.js +(function (root, factory) { + /*global define, module, exports */ + { + // Node. Does not work with strict CommonJS, but + // only CommonJS-like environments that support module.exports, + // like Node. + module.exports = factory(); + } +}(commonjsGlobal, function () { + + var _apply = Function.call.bind(Function.apply); + var _call = Function.call.bind(Function.call); + var isArray = Array.isArray; + var keys = Object.keys; + + var not = function notThunker(func) { + return function notThunk() { + return !_apply(func, this, arguments); + }; + }; + var throwsError = function (func) { + try { + func(); + return false; + } catch (e) { + return true; + } + }; + var valueOrFalseIfThrows = function valueOrFalseIfThrows(func) { + try { + return func(); + } catch (e) { + return false; + } + }; + + var isCallableWithoutNew = not(throwsError); + var arePropertyDescriptorsSupported = function () { + // if Object.defineProperty exists but throws, it's IE 8 + return !throwsError(function () { + return Object.defineProperty({}, 'x', { get: function () { } }); // eslint-disable-line getter-return + }); + }; + var supportsDescriptors = !!Object.defineProperty && arePropertyDescriptorsSupported(); + var functionsHaveNames = (function foo() {}).name === 'foo'; // eslint-disable-line no-extra-parens + + var _forEach = Function.call.bind(Array.prototype.forEach); + var _reduce = Function.call.bind(Array.prototype.reduce); + var _filter = Function.call.bind(Array.prototype.filter); + var _some = Function.call.bind(Array.prototype.some); + + var defineProperty = function (object, name, value, force) { + if (!force && name in object) { return; } + if (supportsDescriptors) { + Object.defineProperty(object, name, { + configurable: true, + enumerable: false, + writable: true, + value: value + }); + } else { + object[name] = value; + } + }; + + // Define configurable, writable and non-enumerable props + // if they don’t exist. + var defineProperties = function (object, map, forceOverride) { + _forEach(keys(map), function (name) { + var method = map[name]; + defineProperty(object, name, method, !!forceOverride); + }); + }; + + var _toString = Function.call.bind(Object.prototype.toString); + var isCallable = typeof /abc/ === 'function' ? function IsCallableSlow(x) { + // Some old browsers (IE, FF) say that typeof /abc/ === 'function' + return typeof x === 'function' && _toString(x) === '[object Function]'; + } : function IsCallableFast(x) { return typeof x === 'function'; }; + + var Value = { + getter: function (object, name, getter) { + if (!supportsDescriptors) { + throw new TypeError('getters require true ES5 support'); + } + Object.defineProperty(object, name, { + configurable: true, + enumerable: false, + get: getter + }); + }, + proxy: function (originalObject, key, targetObject) { + if (!supportsDescriptors) { + throw new TypeError('getters require true ES5 support'); + } + var originalDescriptor = Object.getOwnPropertyDescriptor(originalObject, key); + Object.defineProperty(targetObject, key, { + configurable: originalDescriptor.configurable, + enumerable: originalDescriptor.enumerable, + get: function getKey() { return originalObject[key]; }, + set: function setKey(value) { originalObject[key] = value; } + }); + }, + redefine: function (object, property, newValue) { + if (supportsDescriptors) { + var descriptor = Object.getOwnPropertyDescriptor(object, property); + descriptor.value = newValue; + Object.defineProperty(object, property, descriptor); + } else { + object[property] = newValue; + } + }, + defineByDescriptor: function (object, property, descriptor) { + if (supportsDescriptors) { + Object.defineProperty(object, property, descriptor); + } else if ('value' in descriptor) { + object[property] = descriptor.value; + } + }, + preserveToString: function (target, source) { + if (source && isCallable(source.toString)) { + defineProperty(target, 'toString', source.toString.bind(source), true); + } + } + }; + + // Simple shim for Object.create on ES3 browsers + // (unlike real shim, no attempt to support `prototype === null`) + var create = Object.create || function (prototype, properties) { + var Prototype = function Prototype() {}; + Prototype.prototype = prototype; + var object = new Prototype(); + if (typeof properties !== 'undefined') { + keys(properties).forEach(function (key) { + Value.defineByDescriptor(object, key, properties[key]); + }); + } + return object; + }; + + var supportsSubclassing = function (C, f) { + if (!Object.setPrototypeOf) { return false; /* skip test on IE < 11 */ } + return valueOrFalseIfThrows(function () { + var Sub = function Subclass(arg) { + var o = new C(arg); + Object.setPrototypeOf(o, Subclass.prototype); + return o; + }; + Object.setPrototypeOf(Sub, C); + Sub.prototype = create(C.prototype, { + constructor: { value: Sub } + }); + return f(Sub); + }); + }; + + var getGlobal = function () { + /* global self, window, global */ + // the only reliable means to get the global object is + // `Function('return this')()` + // However, this causes CSP violations in Chrome apps. + if (typeof self !== 'undefined') { return self; } + if (typeof window !== 'undefined') { return window; } + if (typeof commonjsGlobal !== 'undefined') { return commonjsGlobal; } + throw new Error('unable to locate global object'); + }; + + var globals = getGlobal(); + var globalIsFinite = globals.isFinite; + var _indexOf = Function.call.bind(String.prototype.indexOf); + var _arrayIndexOfApply = Function.apply.bind(Array.prototype.indexOf); + var _concat = Function.call.bind(Array.prototype.concat); + // var _sort = Function.call.bind(Array.prototype.sort); + var _strSlice = Function.call.bind(String.prototype.slice); + var _push = Function.call.bind(Array.prototype.push); + var _pushApply = Function.apply.bind(Array.prototype.push); + var _shift = Function.call.bind(Array.prototype.shift); + var _max = Math.max; + var _min = Math.min; + var _floor = Math.floor; + var _abs = Math.abs; + var _exp = Math.exp; + var _log = Math.log; + var _sqrt = Math.sqrt; + var _hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty); + var ArrayIterator; // make our implementation private + var noop = function () {}; + + var OrigMap = globals.Map; + var origMapDelete = OrigMap && OrigMap.prototype['delete']; + var origMapGet = OrigMap && OrigMap.prototype.get; + var origMapHas = OrigMap && OrigMap.prototype.has; + var origMapSet = OrigMap && OrigMap.prototype.set; + + var Symbol = globals.Symbol || {}; + var symbolSpecies = Symbol.species || '@@species'; + + var numberIsNaN = Number.isNaN || function isNaN(value) { + // NaN !== NaN, but they are identical. + // NaNs are the only non-reflexive value, i.e., if x !== x, + // then x is NaN. + // isNaN is broken: it converts its argument to number, so + // isNaN('foo') => true + return value !== value; + }; + var numberIsFinite = Number.isFinite || function isFinite(value) { + return typeof value === 'number' && globalIsFinite(value); + }; + var _sign = isCallable(Math.sign) ? Math.sign : function sign(value) { + var number = Number(value); + if (number === 0) { return number; } + if (numberIsNaN(number)) { return number; } + return number < 0 ? -1 : 1; + }; + var _log1p = function log1p(value) { + var x = Number(value); + if (x < -1 || numberIsNaN(x)) { return NaN; } + if (x === 0 || x === Infinity) { return x; } + if (x === -1) { return -Infinity; } + + return (1 + x) - 1 === 0 ? x : x * (_log(1 + x) / ((1 + x) - 1)); + }; + + // taken directly from https://github.com/ljharb/is-arguments/blob/master/index.js + // can be replaced with require('is-arguments') if we ever use a build process instead + var isStandardArguments = function isArguments(value) { + return _toString(value) === '[object Arguments]'; + }; + var isLegacyArguments = function isArguments(value) { + return value !== null && + typeof value === 'object' && + typeof value.length === 'number' && + value.length >= 0 && + _toString(value) !== '[object Array]' && + _toString(value.callee) === '[object Function]'; + }; + var isArguments = isStandardArguments(arguments) ? isStandardArguments : isLegacyArguments; + + var Type = { + primitive: function (x) { return x === null || (typeof x !== 'function' && typeof x !== 'object'); }, + string: function (x) { return _toString(x) === '[object String]'; }, + regex: function (x) { return _toString(x) === '[object RegExp]'; }, + symbol: function (x) { + return typeof globals.Symbol === 'function' && typeof x === 'symbol'; + } + }; + + var overrideNative = function overrideNative(object, property, replacement) { + var original = object[property]; + defineProperty(object, property, replacement, true); + Value.preserveToString(object[property], original); + }; + + // eslint-disable-next-line no-restricted-properties + 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]' + // we're going to use an arbitrary _-prefixed name to make our shims + // work properly with each other, even though we don't have full Iterator + // support. That is, `Array.from(map.keys())` will work, but we don't + // pretend to export a "real" Iterator interface. + var $iterator$ = Type.symbol(Symbol.iterator) ? Symbol.iterator : '_es6-shim iterator_'; + // Firefox ships a partial implementation using the name @@iterator. + // https://bugzilla.mozilla.org/show_bug.cgi?id=907077#c14 + // So use that name if we detect it. + if (globals.Set && typeof new globals.Set()['@@iterator'] === 'function') { + $iterator$ = '@@iterator'; + } + + // Reflect + if (!globals.Reflect) { + defineProperty(globals, 'Reflect', {}, true); + } + var Reflect = globals.Reflect; + + var $String = String; + + /* global document */ + var domAll = (typeof document === 'undefined' || !document) ? null : document.all; + var isNullOrUndefined = domAll == null ? function isNullOrUndefined(x) { + return x == null; + } : function isNullOrUndefinedAndNotDocumentAll(x) { + return x == null && x !== domAll; + }; + + var ES = { + // http://www.ecma-international.org/ecma-262/6.0/#sec-call + Call: function Call(F, V) { + var args = arguments.length > 2 ? arguments[2] : []; + if (!ES.IsCallable(F)) { + throw new TypeError(F + ' is not a function'); + } + return _apply(F, V, args); + }, + + RequireObjectCoercible: function (x, optMessage) { + if (isNullOrUndefined(x)) { + throw new TypeError(optMessage || 'Cannot call method on ' + x); + } + return x; + }, + + // This might miss the "(non-standard exotic and does not implement + // [[Call]])" case from + // http://www.ecma-international.org/ecma-262/6.0/#sec-typeof-operator-runtime-semantics-evaluation + // but we can't find any evidence these objects exist in practice. + // If we find some in the future, you could test `Object(x) === x`, + // which is reliable according to + // http://www.ecma-international.org/ecma-262/6.0/#sec-toobject + // but is not well optimized by runtimes and creates an object + // whenever it returns false, and thus is very slow. + TypeIsObject: function (x) { + if (x === void 0 || x === null || x === true || x === false) { + return false; + } + return typeof x === 'function' || typeof x === 'object' || x === domAll; + }, + + ToObject: function (o, optMessage) { + return Object(ES.RequireObjectCoercible(o, optMessage)); + }, + + IsCallable: isCallable, + + IsConstructor: function (x) { + // We can't tell callables from constructors in ES5 + return ES.IsCallable(x); + }, + + ToInt32: function (x) { + return ES.ToNumber(x) >> 0; + }, + + ToUint32: function (x) { + return ES.ToNumber(x) >>> 0; + }, + + ToNumber: function (value) { + if (_toString(value) === '[object Symbol]') { + throw new TypeError('Cannot convert a Symbol value to a number'); + } + return +value; + }, + + ToInteger: function (value) { + var number = ES.ToNumber(value); + if (numberIsNaN(number)) { return 0; } + if (number === 0 || !numberIsFinite(number)) { return number; } + return (number > 0 ? 1 : -1) * _floor(_abs(number)); + }, + + ToLength: function (value) { + var len = ES.ToInteger(value); + if (len <= 0) { return 0; } // includes converting -0 to +0 + if (len > Number.MAX_SAFE_INTEGER) { return Number.MAX_SAFE_INTEGER; } + return len; + }, + + SameValue: function (a, b) { + if (a === b) { + // 0 === -0, but they are not identical. + if (a === 0) { return 1 / a === 1 / b; } + return true; + } + return numberIsNaN(a) && numberIsNaN(b); + }, + + SameValueZero: function (a, b) { + // same as SameValue except for SameValueZero(+0, -0) == true + return (a === b) || (numberIsNaN(a) && numberIsNaN(b)); + }, + + IsIterable: function (o) { + return ES.TypeIsObject(o) && (typeof o[$iterator$] !== 'undefined' || isArguments(o)); + }, + + GetIterator: function (o) { + if (isArguments(o)) { + // special case support for `arguments` + return new ArrayIterator(o, 'value'); + } + var itFn = ES.GetMethod(o, $iterator$); + if (!ES.IsCallable(itFn)) { + // Better diagnostics if itFn is null or undefined + throw new TypeError('value is not an iterable'); + } + var it = ES.Call(itFn, o); + if (!ES.TypeIsObject(it)) { + throw new TypeError('bad iterator'); + } + return it; + }, + + GetMethod: function (o, p) { + var func = ES.ToObject(o)[p]; + if (isNullOrUndefined(func)) { + return void 0; + } + if (!ES.IsCallable(func)) { + throw new TypeError('Method not callable: ' + p); + } + return func; + }, + + IteratorComplete: function (iterResult) { + return !!iterResult.done; + }, + + IteratorClose: function (iterator, completionIsThrow) { + var returnMethod = ES.GetMethod(iterator, 'return'); + if (returnMethod === void 0) { + return; + } + var innerResult, innerException; + try { + innerResult = ES.Call(returnMethod, iterator); + } catch (e) { + innerException = e; + } + if (completionIsThrow) { + return; + } + if (innerException) { + throw innerException; + } + if (!ES.TypeIsObject(innerResult)) { + throw new TypeError("Iterator's return method returned a non-object."); + } + }, + + IteratorNext: function (it) { + var result = arguments.length > 1 ? it.next(arguments[1]) : it.next(); + if (!ES.TypeIsObject(result)) { + throw new TypeError('bad iterator'); + } + return result; + }, + + IteratorStep: function (it) { + var result = ES.IteratorNext(it); + var done = ES.IteratorComplete(result); + return done ? false : result; + }, + + Construct: function (C, args, newTarget, isES6internal) { + var target = typeof newTarget === 'undefined' ? C : newTarget; + + if (!isES6internal && Reflect.construct) { + // Try to use Reflect.construct if available + return Reflect.construct(C, args, target); + } + // OK, we have to fake it. This will only work if the + // C.[[ConstructorKind]] == "base" -- but that's the only + // kind we can make in ES5 code anyway. + + // OrdinaryCreateFromConstructor(target, "%ObjectPrototype%") + var proto = target.prototype; + if (!ES.TypeIsObject(proto)) { + proto = Object.prototype; + } + var obj = create(proto); + // Call the constructor. + var result = ES.Call(C, obj, args); + return ES.TypeIsObject(result) ? result : obj; + }, + + SpeciesConstructor: function (O, defaultConstructor) { + var C = O.constructor; + if (C === void 0) { + return defaultConstructor; + } + if (!ES.TypeIsObject(C)) { + throw new TypeError('Bad constructor'); + } + var S = C[symbolSpecies]; + if (isNullOrUndefined(S)) { + return defaultConstructor; + } + if (!ES.IsConstructor(S)) { + throw new TypeError('Bad @@species'); + } + return S; + }, + + CreateHTML: function (string, tag, attribute, value) { + var S = ES.ToString(string); + var p1 = '<' + tag; + if (attribute !== '') { + var V = ES.ToString(value); + var escapedV = V.replace(/"/g, '"'); + p1 += ' ' + attribute + '="' + escapedV + '"'; + } + var p2 = p1 + '>'; + var p3 = p2 + S; + return p3 + ''; + }, + + IsRegExp: function IsRegExp(argument) { + if (!ES.TypeIsObject(argument)) { + return false; + } + var isRegExp = argument[Symbol.match]; + if (typeof isRegExp !== 'undefined') { + return !!isRegExp; + } + return Type.regex(argument); + }, + + ToString: function ToString(string) { + return $String(string); + } + }; + + // Well-known Symbol shims + if (supportsDescriptors && hasSymbols) { + var defineWellKnownSymbol = function defineWellKnownSymbol(name) { + if (Type.symbol(Symbol[name])) { + return Symbol[name]; + } + // eslint-disable-next-line no-restricted-properties + var sym = Symbol['for']('Symbol.' + name); + Object.defineProperty(Symbol, name, { + configurable: false, + enumerable: false, + writable: false, + value: sym + }); + return sym; + }; + if (!Type.symbol(Symbol.search)) { + var symbolSearch = defineWellKnownSymbol('search'); + var originalSearch = String.prototype.search; + defineProperty(RegExp.prototype, symbolSearch, function search(string) { + return ES.Call(originalSearch, string, [this]); + }); + var searchShim = function search(regexp) { + var O = ES.RequireObjectCoercible(this); + if (!isNullOrUndefined(regexp)) { + var searcher = ES.GetMethod(regexp, symbolSearch); + if (typeof searcher !== 'undefined') { + return ES.Call(searcher, regexp, [O]); + } + } + return ES.Call(originalSearch, O, [ES.ToString(regexp)]); + }; + overrideNative(String.prototype, 'search', searchShim); + } + if (!Type.symbol(Symbol.replace)) { + var symbolReplace = defineWellKnownSymbol('replace'); + var originalReplace = String.prototype.replace; + defineProperty(RegExp.prototype, symbolReplace, function replace(string, replaceValue) { + return ES.Call(originalReplace, string, [this, replaceValue]); + }); + var replaceShim = function replace(searchValue, replaceValue) { + var O = ES.RequireObjectCoercible(this); + if (!isNullOrUndefined(searchValue)) { + var replacer = ES.GetMethod(searchValue, symbolReplace); + if (typeof replacer !== 'undefined') { + return ES.Call(replacer, searchValue, [O, replaceValue]); + } + } + return ES.Call(originalReplace, O, [ES.ToString(searchValue), replaceValue]); + }; + overrideNative(String.prototype, 'replace', replaceShim); + } + if (!Type.symbol(Symbol.split)) { + var symbolSplit = defineWellKnownSymbol('split'); + var originalSplit = String.prototype.split; + defineProperty(RegExp.prototype, symbolSplit, function split(string, limit) { + return ES.Call(originalSplit, string, [this, limit]); + }); + var splitShim = function split(separator, limit) { + var O = ES.RequireObjectCoercible(this); + if (!isNullOrUndefined(separator)) { + var splitter = ES.GetMethod(separator, symbolSplit); + if (typeof splitter !== 'undefined') { + return ES.Call(splitter, separator, [O, limit]); + } + } + return ES.Call(originalSplit, O, [ES.ToString(separator), limit]); + }; + overrideNative(String.prototype, 'split', splitShim); + } + var symbolMatchExists = Type.symbol(Symbol.match); + var stringMatchIgnoresSymbolMatch = symbolMatchExists && (function () { + // Firefox 41, through Nightly 45 has Symbol.match, but String#match ignores it. + // Firefox 40 and below have Symbol.match but String#match works fine. + var o = {}; + o[Symbol.match] = function () { return 42; }; + return 'a'.match(o) !== 42; + }()); + if (!symbolMatchExists || stringMatchIgnoresSymbolMatch) { + var symbolMatch = defineWellKnownSymbol('match'); + + var originalMatch = String.prototype.match; + defineProperty(RegExp.prototype, symbolMatch, function match(string) { + return ES.Call(originalMatch, string, [this]); + }); + + var matchShim = function match(regexp) { + var O = ES.RequireObjectCoercible(this); + if (!isNullOrUndefined(regexp)) { + var matcher = ES.GetMethod(regexp, symbolMatch); + if (typeof matcher !== 'undefined') { + return ES.Call(matcher, regexp, [O]); + } + } + return ES.Call(originalMatch, O, [ES.ToString(regexp)]); + }; + overrideNative(String.prototype, 'match', matchShim); + } + } + + var wrapConstructor = function wrapConstructor(original, replacement, keysToSkip) { + Value.preserveToString(replacement, original); + if (Object.setPrototypeOf) { + // sets up proper prototype chain where possible + Object.setPrototypeOf(original, replacement); + } + if (supportsDescriptors) { + _forEach(Object.getOwnPropertyNames(original), function (key) { + if (key in noop || keysToSkip[key]) { return; } + Value.proxy(original, key, replacement); + }); + } else { + _forEach(Object.keys(original), function (key) { + if (key in noop || keysToSkip[key]) { return; } + replacement[key] = original[key]; + }); + } + replacement.prototype = original.prototype; + Value.redefine(original.prototype, 'constructor', replacement); + }; + + var defaultSpeciesGetter = function () { return this; }; + var addDefaultSpecies = function (C) { + if (supportsDescriptors && !_hasOwnProperty(C, symbolSpecies)) { + Value.getter(C, symbolSpecies, defaultSpeciesGetter); + } + }; + + var addIterator = function (prototype, impl) { + var implementation = impl || function iterator() { return this; }; + defineProperty(prototype, $iterator$, implementation); + if (!prototype[$iterator$] && Type.symbol($iterator$)) { + // implementations are buggy when $iterator$ is a Symbol + prototype[$iterator$] = implementation; + } + }; + + var createDataProperty = function createDataProperty(object, name, value) { + if (supportsDescriptors) { + Object.defineProperty(object, name, { + configurable: true, + enumerable: true, + writable: true, + value: value + }); + } else { + object[name] = value; + } + }; + var createDataPropertyOrThrow = function createDataPropertyOrThrow(object, name, value) { + createDataProperty(object, name, value); + if (!ES.SameValue(object[name], value)) { + throw new TypeError('property is nonconfigurable'); + } + }; + + var emulateES6construct = function (o, defaultNewTarget, defaultProto, slots) { + // This is an es5 approximation to es6 construct semantics. in es6, + // 'new Foo' invokes Foo.[[Construct]] which (for almost all objects) + // just sets the internal variable NewTarget (in es6 syntax `new.target`) + // to Foo and then returns Foo(). + + // Many ES6 object then have constructors of the form: + // 1. If NewTarget is undefined, throw a TypeError exception + // 2. Let xxx by OrdinaryCreateFromConstructor(NewTarget, yyy, zzz) + + // So we're going to emulate those first two steps. + if (!ES.TypeIsObject(o)) { + throw new TypeError('Constructor requires `new`: ' + defaultNewTarget.name); + } + var proto = defaultNewTarget.prototype; + if (!ES.TypeIsObject(proto)) { + proto = defaultProto; + } + var obj = create(proto); + for (var name in slots) { + if (_hasOwnProperty(slots, name)) { + var value = slots[name]; + defineProperty(obj, name, value, true); + } + } + return obj; + }; + + // Firefox 31 reports this function's length as 0 + // https://bugzilla.mozilla.org/show_bug.cgi?id=1062484 + if (String.fromCodePoint && String.fromCodePoint.length !== 1) { + var originalFromCodePoint = String.fromCodePoint; + overrideNative(String, 'fromCodePoint', function fromCodePoint(codePoints) { + return ES.Call(originalFromCodePoint, this, arguments); + }); + } + + var StringShims = { + fromCodePoint: function fromCodePoint(codePoints) { + var result = []; + var next; + for (var i = 0, length = arguments.length; i < length; i++) { + next = Number(arguments[i]); + if (!ES.SameValue(next, ES.ToInteger(next)) || next < 0 || next > 0x10FFFF) { + throw new RangeError('Invalid code point ' + next); + } + + if (next < 0x10000) { + _push(result, String.fromCharCode(next)); + } else { + next -= 0x10000; + _push(result, String.fromCharCode((next >> 10) + 0xD800)); + _push(result, String.fromCharCode((next % 0x400) + 0xDC00)); + } + } + return result.join(''); + }, + + raw: function raw(callSite) { + var cooked = ES.ToObject(callSite, 'bad callSite'); + var rawString = ES.ToObject(cooked.raw, 'bad raw value'); + var len = rawString.length; + var literalsegments = ES.ToLength(len); + if (literalsegments <= 0) { + return ''; + } + + var stringElements = []; + var nextIndex = 0; + var nextKey, next, nextSeg, nextSub; + while (nextIndex < literalsegments) { + nextKey = ES.ToString(nextIndex); + nextSeg = ES.ToString(rawString[nextKey]); + _push(stringElements, nextSeg); + if (nextIndex + 1 >= literalsegments) { + break; + } + next = nextIndex + 1 < arguments.length ? arguments[nextIndex + 1] : ''; + nextSub = ES.ToString(next); + _push(stringElements, nextSub); + nextIndex += 1; + } + return stringElements.join(''); + } + }; + if (String.raw && String.raw({ raw: { 0: 'x', 1: 'y', length: 2 } }) !== 'xy') { + // IE 11 TP has a broken String.raw implementation + overrideNative(String, 'raw', StringShims.raw); + } + defineProperties(String, StringShims); + + // Fast repeat, uses the `Exponentiation by squaring` algorithm. + // Perf: http://jsperf.com/string-repeat2/2 + var stringRepeat = function repeat(s, times) { + if (times < 1) { return ''; } + if (times % 2) { return repeat(s, times - 1) + s; } + var half = repeat(s, times / 2); + return half + half; + }; + var stringMaxLength = Infinity; + + var StringPrototypeShims = { + repeat: function repeat(times) { + var thisStr = ES.ToString(ES.RequireObjectCoercible(this)); + var numTimes = ES.ToInteger(times); + if (numTimes < 0 || numTimes >= stringMaxLength) { + throw new RangeError('repeat count must be less than infinity and not overflow maximum string size'); + } + return stringRepeat(thisStr, numTimes); + }, + + startsWith: function startsWith(searchString) { + var S = ES.ToString(ES.RequireObjectCoercible(this)); + if (ES.IsRegExp(searchString)) { + throw new TypeError('Cannot call method "startsWith" with a regex'); + } + var searchStr = ES.ToString(searchString); + var position; + if (arguments.length > 1) { + position = arguments[1]; + } + var start = _max(ES.ToInteger(position), 0); + return _strSlice(S, start, start + searchStr.length) === searchStr; + }, + + endsWith: function endsWith(searchString) { + var S = ES.ToString(ES.RequireObjectCoercible(this)); + if (ES.IsRegExp(searchString)) { + throw new TypeError('Cannot call method "endsWith" with a regex'); + } + var searchStr = ES.ToString(searchString); + var len = S.length; + var endPosition; + if (arguments.length > 1) { + endPosition = arguments[1]; + } + var pos = typeof endPosition === 'undefined' ? len : ES.ToInteger(endPosition); + var end = _min(_max(pos, 0), len); + return _strSlice(S, end - searchStr.length, end) === searchStr; + }, + + includes: function includes(searchString) { + if (ES.IsRegExp(searchString)) { + throw new TypeError('"includes" does not accept a RegExp'); + } + var searchStr = ES.ToString(searchString); + var position; + if (arguments.length > 1) { + position = arguments[1]; + } + // Somehow this trick makes method 100% compat with the spec. + return _indexOf(this, searchStr, position) !== -1; + }, + + codePointAt: function codePointAt(pos) { + var thisStr = ES.ToString(ES.RequireObjectCoercible(this)); + var position = ES.ToInteger(pos); + var length = thisStr.length; + if (position >= 0 && position < length) { + var first = thisStr.charCodeAt(position); + var isEnd = position + 1 === length; + if (first < 0xD800 || first > 0xDBFF || isEnd) { return first; } + var second = thisStr.charCodeAt(position + 1); + if (second < 0xDC00 || second > 0xDFFF) { return first; } + return ((first - 0xD800) * 1024) + (second - 0xDC00) + 0x10000; + } + } + }; + if (String.prototype.includes && 'a'.includes('a', Infinity) !== false) { + overrideNative(String.prototype, 'includes', StringPrototypeShims.includes); + } + + if (String.prototype.startsWith && String.prototype.endsWith) { + var startsWithRejectsRegex = throwsError(function () { + /* throws if spec-compliant */ + return '/a/'.startsWith(/a/); + }); + var startsWithHandlesInfinity = valueOrFalseIfThrows(function () { + return 'abc'.startsWith('a', Infinity) === false; + }); + if (!startsWithRejectsRegex || !startsWithHandlesInfinity) { + // Firefox (< 37?) and IE 11 TP have a noncompliant startsWith implementation + overrideNative(String.prototype, 'startsWith', StringPrototypeShims.startsWith); + overrideNative(String.prototype, 'endsWith', StringPrototypeShims.endsWith); + } + } + if (hasSymbols) { + var startsWithSupportsSymbolMatch = valueOrFalseIfThrows(function () { + var re = /a/; + re[Symbol.match] = false; + return '/a/'.startsWith(re); + }); + if (!startsWithSupportsSymbolMatch) { + overrideNative(String.prototype, 'startsWith', StringPrototypeShims.startsWith); + } + var endsWithSupportsSymbolMatch = valueOrFalseIfThrows(function () { + var re = /a/; + re[Symbol.match] = false; + return '/a/'.endsWith(re); + }); + if (!endsWithSupportsSymbolMatch) { + overrideNative(String.prototype, 'endsWith', StringPrototypeShims.endsWith); + } + var includesSupportsSymbolMatch = valueOrFalseIfThrows(function () { + var re = /a/; + re[Symbol.match] = false; + return '/a/'.includes(re); + }); + if (!includesSupportsSymbolMatch) { + overrideNative(String.prototype, 'includes', StringPrototypeShims.includes); + } + } + + defineProperties(String.prototype, StringPrototypeShims); + + // whitespace from: http://es5.github.io/#x15.5.4.20 + // implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324 + var ws = [ + '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003', + '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028', + '\u2029\uFEFF' + ].join(''); + var trimRegexp = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g'); + var trimShim = function trim() { + return ES.ToString(ES.RequireObjectCoercible(this)).replace(trimRegexp, ''); + }; + var nonWS = ['\u0085', '\u200b', '\ufffe'].join(''); + var nonWSregex = new RegExp('[' + nonWS + ']', 'g'); + var isBadHexRegex = /^[-+]0x[0-9a-f]+$/i; + var hasStringTrimBug = nonWS.trim().length !== nonWS.length; + defineProperty(String.prototype, 'trim', trimShim, hasStringTrimBug); + + // Given an argument x, it will return an IteratorResult object, + // with value set to x and done to false. + // Given no arguments, it will return an iterator completion object. + var iteratorResult = function (x) { + return { value: x, done: arguments.length === 0 }; + }; + + // see http://www.ecma-international.org/ecma-262/6.0/#sec-string.prototype-@@iterator + var StringIterator = function (s) { + ES.RequireObjectCoercible(s); + this._s = ES.ToString(s); + this._i = 0; + }; + StringIterator.prototype.next = function () { + var s = this._s; + var i = this._i; + if (typeof s === 'undefined' || i >= s.length) { + this._s = void 0; + return iteratorResult(); + } + var first = s.charCodeAt(i); + var second, len; + if (first < 0xD800 || first > 0xDBFF || (i + 1) === s.length) { + len = 1; + } else { + second = s.charCodeAt(i + 1); + len = (second < 0xDC00 || second > 0xDFFF) ? 1 : 2; + } + this._i = i + len; + return iteratorResult(s.substr(i, len)); + }; + addIterator(StringIterator.prototype); + addIterator(String.prototype, function () { + return new StringIterator(this); + }); + + var ArrayShims = { + from: function from(items) { + var C = this; + var mapFn; + if (arguments.length > 1) { + mapFn = arguments[1]; + } + var mapping, T; + if (typeof mapFn === 'undefined') { + mapping = false; + } else { + if (!ES.IsCallable(mapFn)) { + throw new TypeError('Array.from: when provided, the second argument must be a function'); + } + if (arguments.length > 2) { + T = arguments[2]; + } + mapping = true; + } + + // Note that that Arrays will use ArrayIterator: + // https://bugs.ecmascript.org/show_bug.cgi?id=2416 + var usingIterator = typeof (isArguments(items) || ES.GetMethod(items, $iterator$)) !== 'undefined'; + + var length, result, i; + if (usingIterator) { + result = ES.IsConstructor(C) ? Object(new C()) : []; + var iterator = ES.GetIterator(items); + var next, nextValue; + + i = 0; + while (true) { + next = ES.IteratorStep(iterator); + if (next === false) { + break; + } + nextValue = next.value; + try { + if (mapping) { + nextValue = typeof T === 'undefined' ? mapFn(nextValue, i) : _call(mapFn, T, nextValue, i); + } + result[i] = nextValue; + } catch (e) { + ES.IteratorClose(iterator, true); + throw e; + } + i += 1; + } + length = i; + } else { + var arrayLike = ES.ToObject(items); + length = ES.ToLength(arrayLike.length); + result = ES.IsConstructor(C) ? Object(new C(length)) : new Array(length); + var value; + for (i = 0; i < length; ++i) { + value = arrayLike[i]; + if (mapping) { + value = typeof T === 'undefined' ? mapFn(value, i) : _call(mapFn, T, value, i); + } + createDataPropertyOrThrow(result, i, value); + } + } + + result.length = length; + return result; + }, + + of: function of() { + var len = arguments.length; + var C = this; + var A = isArray(C) || !ES.IsCallable(C) ? new Array(len) : ES.Construct(C, [len]); + for (var k = 0; k < len; ++k) { + createDataPropertyOrThrow(A, k, arguments[k]); + } + A.length = len; + return A; + } + }; + defineProperties(Array, ArrayShims); + addDefaultSpecies(Array); + + // Our ArrayIterator is private; see + // https://github.com/paulmillr/es6-shim/issues/252 + ArrayIterator = function (array, kind) { + this.i = 0; + this.array = array; + this.kind = kind; + }; + + defineProperties(ArrayIterator.prototype, { + next: function () { + var i = this.i; + var array = this.array; + if (!(this instanceof ArrayIterator)) { + throw new TypeError('Not an ArrayIterator'); + } + if (typeof array !== 'undefined') { + var len = ES.ToLength(array.length); + for (; i < len; i++) { + var kind = this.kind; + var retval; + if (kind === 'key') { + retval = i; + } else if (kind === 'value') { + retval = array[i]; + } else if (kind === 'entry') { + retval = [i, array[i]]; + } + this.i = i + 1; + return iteratorResult(retval); + } + } + this.array = void 0; + return iteratorResult(); + } + }); + addIterator(ArrayIterator.prototype); + + /* + var orderKeys = function orderKeys(a, b) { + var aNumeric = String(ES.ToInteger(a)) === a; + var bNumeric = String(ES.ToInteger(b)) === b; + if (aNumeric && bNumeric) { + return b - a; + } else if (aNumeric && !bNumeric) { + return -1; + } else if (!aNumeric && bNumeric) { + return 1; + } else { + return a.localeCompare(b); + } + }; + + var getAllKeys = function getAllKeys(object) { + var ownKeys = []; + var keys = []; + + for (var key in object) { + _push(_hasOwnProperty(object, key) ? ownKeys : keys, key); + } + _sort(ownKeys, orderKeys); + _sort(keys, orderKeys); + + return _concat(ownKeys, keys); + }; + */ + + // note: this is positioned here because it depends on ArrayIterator + var arrayOfSupportsSubclassing = Array.of === ArrayShims.of || (function () { + // Detects a bug in Webkit nightly r181886 + var Foo = function Foo(len) { this.length = len; }; + Foo.prototype = []; + var fooArr = Array.of.apply(Foo, [1, 2]); + return fooArr instanceof Foo && fooArr.length === 2; + }()); + if (!arrayOfSupportsSubclassing) { + overrideNative(Array, 'of', ArrayShims.of); + } + + var ArrayPrototypeShims = { + copyWithin: function copyWithin(target, start) { + var o = ES.ToObject(this); + var len = ES.ToLength(o.length); + var relativeTarget = ES.ToInteger(target); + var relativeStart = ES.ToInteger(start); + var to = relativeTarget < 0 ? _max(len + relativeTarget, 0) : _min(relativeTarget, len); + var from = relativeStart < 0 ? _max(len + relativeStart, 0) : _min(relativeStart, len); + var end; + if (arguments.length > 2) { + end = arguments[2]; + } + var relativeEnd = typeof end === 'undefined' ? len : ES.ToInteger(end); + var finalItem = relativeEnd < 0 ? _max(len + relativeEnd, 0) : _min(relativeEnd, len); + var count = _min(finalItem - from, len - to); + var direction = 1; + if (from < to && to < (from + count)) { + direction = -1; + from += count - 1; + to += count - 1; + } + while (count > 0) { + if (from in o) { + o[to] = o[from]; + } else { + delete o[to]; + } + from += direction; + to += direction; + count -= 1; + } + return o; + }, + + fill: function fill(value) { + var start; + if (arguments.length > 1) { + start = arguments[1]; + } + var end; + if (arguments.length > 2) { + end = arguments[2]; + } + var O = ES.ToObject(this); + var len = ES.ToLength(O.length); + start = ES.ToInteger(typeof start === 'undefined' ? 0 : start); + end = ES.ToInteger(typeof end === 'undefined' ? len : end); + + var relativeStart = start < 0 ? _max(len + start, 0) : _min(start, len); + var relativeEnd = end < 0 ? len + end : end; + + for (var i = relativeStart; i < len && i < relativeEnd; ++i) { + O[i] = value; + } + return O; + }, + + find: function find(predicate) { + var list = ES.ToObject(this); + var length = ES.ToLength(list.length); + if (!ES.IsCallable(predicate)) { + throw new TypeError('Array#find: predicate must be a function'); + } + var thisArg = arguments.length > 1 ? arguments[1] : null; + for (var i = 0, value; i < length; i++) { + value = list[i]; + if (thisArg) { + if (_call(predicate, thisArg, value, i, list)) { + return value; + } + } else if (predicate(value, i, list)) { + return value; + } + } + }, + + findIndex: function findIndex(predicate) { + var list = ES.ToObject(this); + var length = ES.ToLength(list.length); + if (!ES.IsCallable(predicate)) { + throw new TypeError('Array#findIndex: predicate must be a function'); + } + var thisArg = arguments.length > 1 ? arguments[1] : null; + for (var i = 0; i < length; i++) { + if (thisArg) { + if (_call(predicate, thisArg, list[i], i, list)) { + return i; + } + } else if (predicate(list[i], i, list)) { + return i; + } + } + return -1; + }, + + keys: function keys() { + return new ArrayIterator(this, 'key'); + }, + + values: function values() { + return new ArrayIterator(this, 'value'); + }, + + entries: function entries() { + return new ArrayIterator(this, 'entry'); + } + }; + // Safari 7.1 defines Array#keys and Array#entries natively, + // but the resulting ArrayIterator objects don't have a "next" method. + if (Array.prototype.keys && !ES.IsCallable([1].keys().next)) { + delete Array.prototype.keys; + } + if (Array.prototype.entries && !ES.IsCallable([1].entries().next)) { + delete Array.prototype.entries; + } + + // Chrome 38 defines Array#keys and Array#entries, and Array#@@iterator, but not Array#values + if (Array.prototype.keys && Array.prototype.entries && !Array.prototype.values && Array.prototype[$iterator$]) { + defineProperties(Array.prototype, { + values: Array.prototype[$iterator$] + }); + if (Type.symbol(Symbol.unscopables)) { + Array.prototype[Symbol.unscopables].values = true; + } + } + // Chrome 40 defines Array#values with the incorrect name, although Array#{keys,entries} have the correct name + if (functionsHaveNames && Array.prototype.values && Array.prototype.values.name !== 'values') { + var originalArrayPrototypeValues = Array.prototype.values; + overrideNative(Array.prototype, 'values', function values() { return ES.Call(originalArrayPrototypeValues, this, arguments); }); + defineProperty(Array.prototype, $iterator$, Array.prototype.values, true); + } + defineProperties(Array.prototype, ArrayPrototypeShims); + + if (1 / [true].indexOf(true, -0) < 0) { + // indexOf when given a position arg of -0 should return +0. + // https://github.com/tc39/ecma262/pull/316 + defineProperty(Array.prototype, 'indexOf', function indexOf(searchElement) { + var value = _arrayIndexOfApply(this, arguments); + if (value === 0 && (1 / value) < 0) { + return 0; + } + return value; + }, true); + } + + addIterator(Array.prototype, function () { return this.values(); }); + // Chrome defines keys/values/entries on Array, but doesn't give us + // any way to identify its iterator. So add our own shimmed field. + if (Object.getPrototypeOf) { + addIterator(Object.getPrototypeOf([].values())); + } + + // note: this is positioned here because it relies on Array#entries + var arrayFromSwallowsNegativeLengths = (function () { + // Detects a Firefox bug in v32 + // https://bugzilla.mozilla.org/show_bug.cgi?id=1063993 + return valueOrFalseIfThrows(function () { + return Array.from({ length: -1 }).length === 0; + }); + }()); + var arrayFromHandlesIterables = (function () { + // Detects a bug in Webkit nightly r181886 + var arr = Array.from([0].entries()); + return arr.length === 1 && isArray(arr[0]) && arr[0][0] === 0 && arr[0][1] === 0; + }()); + if (!arrayFromSwallowsNegativeLengths || !arrayFromHandlesIterables) { + overrideNative(Array, 'from', ArrayShims.from); + } + var arrayFromHandlesUndefinedMapFunction = (function () { + // Microsoft Edge v0.11 throws if the mapFn argument is *provided* but undefined, + // but the spec doesn't care if it's provided or not - undefined doesn't throw. + return valueOrFalseIfThrows(function () { + return Array.from([0], void 0); + }); + }()); + if (!arrayFromHandlesUndefinedMapFunction) { + var origArrayFrom = Array.from; + overrideNative(Array, 'from', function from(items) { + if (arguments.length > 1 && typeof arguments[1] !== 'undefined') { + return ES.Call(origArrayFrom, this, arguments); + } else { + return _call(origArrayFrom, this, items); + } + }); + } + + var int32sAsOne = -(Math.pow(2, 32) - 1); + var toLengthsCorrectly = function (method, reversed) { + var obj = { length: int32sAsOne }; + obj[reversed ? (obj.length >>> 0) - 1 : 0] = true; + return valueOrFalseIfThrows(function () { + _call(method, obj, function () { + // note: in nonconforming browsers, this will be called + // -1 >>> 0 times, which is 4294967295, so the throw matters. + throw new RangeError('should not reach here'); + }, []); + return true; + }); + }; + if (!toLengthsCorrectly(Array.prototype.forEach)) { + var originalForEach = Array.prototype.forEach; + overrideNative(Array.prototype, 'forEach', function forEach(callbackFn) { + return ES.Call(originalForEach, this.length >= 0 ? this : [], arguments); + }); + } + if (!toLengthsCorrectly(Array.prototype.map)) { + var originalMap = Array.prototype.map; + overrideNative(Array.prototype, 'map', function map(callbackFn) { + return ES.Call(originalMap, this.length >= 0 ? this : [], arguments); + }); + } + if (!toLengthsCorrectly(Array.prototype.filter)) { + var originalFilter = Array.prototype.filter; + overrideNative(Array.prototype, 'filter', function filter(callbackFn) { + return ES.Call(originalFilter, this.length >= 0 ? this : [], arguments); + }); + } + if (!toLengthsCorrectly(Array.prototype.some)) { + var originalSome = Array.prototype.some; + overrideNative(Array.prototype, 'some', function some(callbackFn) { + return ES.Call(originalSome, this.length >= 0 ? this : [], arguments); + }); + } + if (!toLengthsCorrectly(Array.prototype.every)) { + var originalEvery = Array.prototype.every; + overrideNative(Array.prototype, 'every', function every(callbackFn) { + return ES.Call(originalEvery, this.length >= 0 ? this : [], arguments); + }); + } + if (!toLengthsCorrectly(Array.prototype.reduce)) { + var originalReduce = Array.prototype.reduce; + overrideNative(Array.prototype, 'reduce', function reduce(callbackFn) { + return ES.Call(originalReduce, this.length >= 0 ? this : [], arguments); + }); + } + if (!toLengthsCorrectly(Array.prototype.reduceRight, true)) { + var originalReduceRight = Array.prototype.reduceRight; + overrideNative(Array.prototype, 'reduceRight', function reduceRight(callbackFn) { + return ES.Call(originalReduceRight, this.length >= 0 ? this : [], arguments); + }); + } + + var lacksOctalSupport = Number('0o10') !== 8; + var lacksBinarySupport = Number('0b10') !== 2; + var trimsNonWhitespace = _some(nonWS, function (c) { + return Number(c + 0 + c) === 0; + }); + if (lacksOctalSupport || lacksBinarySupport || trimsNonWhitespace) { + var OrigNumber = Number; + var binaryRegex = /^0b[01]+$/i; + 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. + var isBinary = binaryRegex.test.bind(binaryRegex); + var isOctal = octalRegex.test.bind(octalRegex); + var toPrimitive = function (O) { // need to replace this with `es-to-primitive/es6` + var result; + if (typeof O.valueOf === 'function') { + result = O.valueOf(); + if (Type.primitive(result)) { + return result; + } + } + if (typeof O.toString === 'function') { + result = O.toString(); + if (Type.primitive(result)) { + return result; + } + } + throw new TypeError('No default value'); + }; + var hasNonWS = nonWSregex.test.bind(nonWSregex); + var isBadHex = isBadHexRegex.test.bind(isBadHexRegex); + var NumberShim = (function () { + // this is wrapped in an IIFE because of IE 6-8's wacky scoping issues with named function expressions. + var NumberShim = function Number(value) { + var primValue; + if (arguments.length > 0) { + primValue = Type.primitive(value) ? value : toPrimitive(value, 'number'); + } else { + primValue = 0; + } + if (typeof primValue === 'string') { + primValue = ES.Call(trimShim, primValue); + if (isBinary(primValue)) { + primValue = parseInt(_strSlice(primValue, 2), 2); + } else if (isOctal(primValue)) { + primValue = parseInt(_strSlice(primValue, 2), 8); + } else if (hasNonWS(primValue) || isBadHex(primValue)) { + primValue = NaN; + } + } + var receiver = this; + var valueOfSucceeds = valueOrFalseIfThrows(function () { + OrigNumber.prototype.valueOf.call(receiver); + return true; + }); + if (receiver instanceof NumberShim && !valueOfSucceeds) { + return new OrigNumber(primValue); + } + return OrigNumber(primValue); + }; + return NumberShim; + }()); + wrapConstructor(OrigNumber, NumberShim, {}); + // this is necessary for ES3 browsers, where these properties are non-enumerable. + defineProperties(NumberShim, { + NaN: OrigNumber.NaN, + MAX_VALUE: OrigNumber.MAX_VALUE, + MIN_VALUE: OrigNumber.MIN_VALUE, + NEGATIVE_INFINITY: OrigNumber.NEGATIVE_INFINITY, + POSITIVE_INFINITY: OrigNumber.POSITIVE_INFINITY + }); + /* globals Number: true */ + /* eslint-disable no-undef, no-global-assign */ + Number = NumberShim; + Value.redefine(globals, 'Number', NumberShim); + /* eslint-enable no-undef, no-global-assign */ + /* globals Number: false */ + } + + var maxSafeInteger = Math.pow(2, 53) - 1; + defineProperties(Number, { + MAX_SAFE_INTEGER: maxSafeInteger, + MIN_SAFE_INTEGER: -maxSafeInteger, + EPSILON: 2.220446049250313e-16, + + parseInt: globals.parseInt, + parseFloat: globals.parseFloat, + + isFinite: numberIsFinite, + + isInteger: function isInteger(value) { + return numberIsFinite(value) && ES.ToInteger(value) === value; + }, + + isSafeInteger: function isSafeInteger(value) { + return Number.isInteger(value) && _abs(value) <= Number.MAX_SAFE_INTEGER; + }, + + isNaN: numberIsNaN + }); + // Firefox 37 has a conforming Number.parseInt, but it's not === to the global parseInt (fixed in v40) + defineProperty(Number, 'parseInt', globals.parseInt, Number.parseInt !== globals.parseInt); + + // Work around bugs in Array#find and Array#findIndex -- early + // implementations skipped holes in sparse arrays. (Note that the + // implementations of find/findIndex indirectly use shimmed + // methods of Number, so this test has to happen down here.) + /* eslint-disable no-sparse-arrays */ + if ([, 1].find(function () { return true; }) === 1) { + overrideNative(Array.prototype, 'find', ArrayPrototypeShims.find); + } + if ([, 1].findIndex(function () { return true; }) !== 0) { + overrideNative(Array.prototype, 'findIndex', ArrayPrototypeShims.findIndex); + } + /* eslint-enable no-sparse-arrays */ + + var isEnumerableOn = Function.bind.call(Function.bind, Object.prototype.propertyIsEnumerable); + var ensureEnumerable = function ensureEnumerable(obj, prop) { + if (supportsDescriptors && isEnumerableOn(obj, prop)) { + Object.defineProperty(obj, prop, { enumerable: false }); + } + }; + var sliceArgs = function sliceArgs() { + // per https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments + // and https://gist.github.com/WebReflection/4327762cb87a8c634a29 + var initial = Number(this); + var len = arguments.length; + var desiredArgCount = len - initial; + var args = new Array(desiredArgCount < 0 ? 0 : desiredArgCount); + for (var i = initial; i < len; ++i) { + args[i - initial] = arguments[i]; + } + return args; + }; + var assignTo = function assignTo(source) { + return function assignToSource(target, key) { + target[key] = source[key]; + return target; + }; + }; + var assignReducer = function (target, source) { + var sourceKeys = keys(Object(source)); + var symbols; + if (ES.IsCallable(Object.getOwnPropertySymbols)) { + symbols = _filter(Object.getOwnPropertySymbols(Object(source)), isEnumerableOn(source)); + } + return _reduce(_concat(sourceKeys, symbols || []), assignTo(source), target); + }; + + var ObjectShims = { + // 19.1.3.1 + assign: function (target, source) { + var to = ES.ToObject(target, 'Cannot convert undefined or null to object'); + return _reduce(ES.Call(sliceArgs, 1, arguments), assignReducer, to); + }, + + // Added in WebKit in https://bugs.webkit.org/show_bug.cgi?id=143865 + is: function is(a, b) { + return ES.SameValue(a, b); + } + }; + var assignHasPendingExceptions = Object.assign && Object.preventExtensions && (function () { + // Firefox 37 still has "pending exception" logic in its Object.assign implementation, + // which is 72% slower than our shim, and Firefox 40's native implementation. + var thrower = Object.preventExtensions({ 1: 2 }); + try { + Object.assign(thrower, 'xy'); + } catch (e) { + return thrower[1] === 'y'; + } + }()); + if (assignHasPendingExceptions) { + overrideNative(Object, 'assign', ObjectShims.assign); + } + defineProperties(Object, ObjectShims); + + if (supportsDescriptors) { + var ES5ObjectShims = { + // 19.1.3.9 + // shim from https://gist.github.com/WebReflection/5593554 + setPrototypeOf: (function (Object, magic) { + var set; + + var checkArgs = function (O, proto) { + if (!ES.TypeIsObject(O)) { + throw new TypeError('cannot set prototype on a non-object'); + } + if (!(proto === null || ES.TypeIsObject(proto))) { + throw new TypeError('can only set prototype to an object or null' + proto); + } + }; + + var setPrototypeOf = function (O, proto) { + checkArgs(O, proto); + _call(set, O, proto); + return O; + }; + + try { + // this works already in Firefox and Safari + set = Object.getOwnPropertyDescriptor(Object.prototype, magic).set; + _call(set, {}, null); + } catch (e) { + if (Object.prototype !== {}[magic]) { + // IE < 11 cannot be shimmed + return; + } + // probably Chrome or some old Mobile stock browser + set = function (proto) { + this[magic] = proto; + }; + // please note that this will **not** work + // in those browsers that do not inherit + // __proto__ by mistake from Object.prototype + // in these cases we should probably throw an error + // or at least be informed about the issue + setPrototypeOf.polyfill = setPrototypeOf( + setPrototypeOf({}, null), + Object.prototype + ) instanceof Object; + // setPrototypeOf.polyfill === true means it works as meant + // setPrototypeOf.polyfill === false means it's not 100% reliable + // setPrototypeOf.polyfill === undefined + // or + // setPrototypeOf.polyfill == null means it's not a polyfill + // which means it works as expected + // we can even delete Object.prototype.__proto__; + } + return setPrototypeOf; + }(Object, '__proto__')) + }; + + defineProperties(Object, ES5ObjectShims); + } + + // Workaround bug in Opera 12 where setPrototypeOf(x, null) doesn't work, + // but Object.create(null) does. + if (Object.setPrototypeOf && Object.getPrototypeOf && + Object.getPrototypeOf(Object.setPrototypeOf({}, null)) !== null && + Object.getPrototypeOf(Object.create(null)) === null) { + (function () { + var FAKENULL = Object.create(null); + var gpo = Object.getPrototypeOf; + var spo = Object.setPrototypeOf; + Object.getPrototypeOf = function (o) { + var result = gpo(o); + return result === FAKENULL ? null : result; + }; + Object.setPrototypeOf = function (o, p) { + var proto = p === null ? FAKENULL : p; + return spo(o, proto); + }; + Object.setPrototypeOf.polyfill = false; + }()); + } + + var objectKeysAcceptsPrimitives = !throwsError(function () { return Object.keys('foo'); }); + if (!objectKeysAcceptsPrimitives) { + var originalObjectKeys = Object.keys; + overrideNative(Object, 'keys', function keys(value) { + return originalObjectKeys(ES.ToObject(value)); + }); + keys = Object.keys; + } + var objectKeysRejectsRegex = throwsError(function () { return Object.keys(/a/g); }); + if (objectKeysRejectsRegex) { + var regexRejectingObjectKeys = Object.keys; + overrideNative(Object, 'keys', function keys(value) { + if (Type.regex(value)) { + var regexKeys = []; + for (var k in value) { + if (_hasOwnProperty(value, k)) { + _push(regexKeys, k); + } + } + return regexKeys; + } + return regexRejectingObjectKeys(value); + }); + keys = Object.keys; + } + + if (Object.getOwnPropertyNames) { + var objectGOPNAcceptsPrimitives = !throwsError(function () { return Object.getOwnPropertyNames('foo'); }); + if (!objectGOPNAcceptsPrimitives) { + var cachedWindowNames = typeof window === 'object' ? Object.getOwnPropertyNames(window) : []; + var originalObjectGetOwnPropertyNames = Object.getOwnPropertyNames; + overrideNative(Object, 'getOwnPropertyNames', function getOwnPropertyNames(value) { + var val = ES.ToObject(value); + if (_toString(val) === '[object Window]') { + try { + return originalObjectGetOwnPropertyNames(val); + } catch (e) { + // IE bug where layout engine calls userland gOPN for cross-domain `window` objects + return _concat([], cachedWindowNames); + } + } + return originalObjectGetOwnPropertyNames(val); + }); + } + } + if (Object.getOwnPropertyDescriptor) { + var objectGOPDAcceptsPrimitives = !throwsError(function () { return Object.getOwnPropertyDescriptor('foo', 'bar'); }); + if (!objectGOPDAcceptsPrimitives) { + var originalObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + overrideNative(Object, 'getOwnPropertyDescriptor', function getOwnPropertyDescriptor(value, property) { + return originalObjectGetOwnPropertyDescriptor(ES.ToObject(value), property); + }); + } + } + if (Object.seal) { + var objectSealAcceptsPrimitives = !throwsError(function () { return Object.seal('foo'); }); + if (!objectSealAcceptsPrimitives) { + var originalObjectSeal = Object.seal; + overrideNative(Object, 'seal', function seal(value) { + if (!ES.TypeIsObject(value)) { return value; } + return originalObjectSeal(value); + }); + } + } + if (Object.isSealed) { + var objectIsSealedAcceptsPrimitives = !throwsError(function () { return Object.isSealed('foo'); }); + if (!objectIsSealedAcceptsPrimitives) { + var originalObjectIsSealed = Object.isSealed; + overrideNative(Object, 'isSealed', function isSealed(value) { + if (!ES.TypeIsObject(value)) { return true; } + return originalObjectIsSealed(value); + }); + } + } + if (Object.freeze) { + var objectFreezeAcceptsPrimitives = !throwsError(function () { return Object.freeze('foo'); }); + if (!objectFreezeAcceptsPrimitives) { + var originalObjectFreeze = Object.freeze; + overrideNative(Object, 'freeze', function freeze(value) { + if (!ES.TypeIsObject(value)) { return value; } + return originalObjectFreeze(value); + }); + } + } + if (Object.isFrozen) { + var objectIsFrozenAcceptsPrimitives = !throwsError(function () { return Object.isFrozen('foo'); }); + if (!objectIsFrozenAcceptsPrimitives) { + var originalObjectIsFrozen = Object.isFrozen; + overrideNative(Object, 'isFrozen', function isFrozen(value) { + if (!ES.TypeIsObject(value)) { return true; } + return originalObjectIsFrozen(value); + }); + } + } + if (Object.preventExtensions) { + var objectPreventExtensionsAcceptsPrimitives = !throwsError(function () { return Object.preventExtensions('foo'); }); + if (!objectPreventExtensionsAcceptsPrimitives) { + var originalObjectPreventExtensions = Object.preventExtensions; + overrideNative(Object, 'preventExtensions', function preventExtensions(value) { + if (!ES.TypeIsObject(value)) { return value; } + return originalObjectPreventExtensions(value); + }); + } + } + if (Object.isExtensible) { + var objectIsExtensibleAcceptsPrimitives = !throwsError(function () { return Object.isExtensible('foo'); }); + if (!objectIsExtensibleAcceptsPrimitives) { + var originalObjectIsExtensible = Object.isExtensible; + overrideNative(Object, 'isExtensible', function isExtensible(value) { + if (!ES.TypeIsObject(value)) { return false; } + return originalObjectIsExtensible(value); + }); + } + } + if (Object.getPrototypeOf) { + var objectGetProtoAcceptsPrimitives = !throwsError(function () { return Object.getPrototypeOf('foo'); }); + if (!objectGetProtoAcceptsPrimitives) { + var originalGetProto = Object.getPrototypeOf; + overrideNative(Object, 'getPrototypeOf', function getPrototypeOf(value) { + return originalGetProto(ES.ToObject(value)); + }); + } + } + + var hasFlags = supportsDescriptors && (function () { + var desc = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags'); + return desc && ES.IsCallable(desc.get); + }()); + if (supportsDescriptors && !hasFlags) { + var regExpFlagsGetter = function flags() { + if (!ES.TypeIsObject(this)) { + throw new TypeError('Method called on incompatible type: must be an object.'); + } + var result = ''; + if (this.global) { + result += 'g'; + } + if (this.ignoreCase) { + result += 'i'; + } + if (this.multiline) { + result += 'm'; + } + if (this.unicode) { + result += 'u'; + } + if (this.sticky) { + result += 'y'; + } + return result; + }; + + Value.getter(RegExp.prototype, 'flags', regExpFlagsGetter); + } + + var regExpSupportsFlagsWithRegex = supportsDescriptors && valueOrFalseIfThrows(function () { + return String(new RegExp(/a/g, 'i')) === '/a/i'; + }); + var regExpNeedsToSupportSymbolMatch = hasSymbols && supportsDescriptors && (function () { + // Edge 0.12 supports flags fully, but does not support Symbol.match + var regex = /./; + regex[Symbol.match] = false; + return RegExp(regex) === regex; + }()); + + var regexToStringIsGeneric = valueOrFalseIfThrows(function () { + return RegExp.prototype.toString.call({ source: 'abc' }) === '/abc/'; + }); + var regexToStringSupportsGenericFlags = regexToStringIsGeneric && valueOrFalseIfThrows(function () { + return RegExp.prototype.toString.call({ source: 'a', flags: 'b' }) === '/a/b'; + }); + if (!regexToStringIsGeneric || !regexToStringSupportsGenericFlags) { + var origRegExpToString = RegExp.prototype.toString; + defineProperty(RegExp.prototype, 'toString', function toString() { + var R = ES.RequireObjectCoercible(this); + if (Type.regex(R)) { + return _call(origRegExpToString, R); + } + var pattern = $String(R.source); + var flags = $String(R.flags); + return '/' + pattern + '/' + flags; + }, true); + Value.preserveToString(RegExp.prototype.toString, origRegExpToString); + } + + if (supportsDescriptors && (!regExpSupportsFlagsWithRegex || regExpNeedsToSupportSymbolMatch)) { + var flagsGetter = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get; + var sourceDesc = Object.getOwnPropertyDescriptor(RegExp.prototype, 'source') || {}; + var legacySourceGetter = function () { + // prior to it being a getter, it's own + nonconfigurable + return this.source; + }; + var sourceGetter = ES.IsCallable(sourceDesc.get) ? sourceDesc.get : legacySourceGetter; + + var OrigRegExp = RegExp; + var RegExpShim = (function () { + return function RegExp(pattern, flags) { + var patternIsRegExp = ES.IsRegExp(pattern); + var calledWithNew = this instanceof RegExp; + if (!calledWithNew && patternIsRegExp && typeof flags === 'undefined' && pattern.constructor === RegExp) { + return pattern; + } + + var P = pattern; + var F = flags; + if (Type.regex(pattern)) { + P = ES.Call(sourceGetter, pattern); + F = typeof flags === 'undefined' ? ES.Call(flagsGetter, pattern) : flags; + return new RegExp(P, F); + } else if (patternIsRegExp) { + P = pattern.source; + F = typeof flags === 'undefined' ? pattern.flags : flags; + } + return new OrigRegExp(pattern, flags); + }; + }()); + wrapConstructor(OrigRegExp, RegExpShim, { + $input: true // Chrome < v39 & Opera < 26 have a nonstandard "$input" property + }); + /* globals RegExp: true */ + /* eslint-disable no-undef, no-global-assign */ + RegExp = RegExpShim; + Value.redefine(globals, 'RegExp', RegExpShim); + /* eslint-enable no-undef, no-global-assign */ + /* globals RegExp: false */ + } + + if (supportsDescriptors) { + var regexGlobals = { + input: '$_', + lastMatch: '$&', + lastParen: '$+', + leftContext: '$`', + rightContext: '$\'' + }; + _forEach(keys(regexGlobals), function (prop) { + if (prop in RegExp && !(regexGlobals[prop] in RegExp)) { + Value.getter(RegExp, regexGlobals[prop], function get() { + return RegExp[prop]; + }); + } + }); + } + addDefaultSpecies(RegExp); + + var inverseEpsilon = 1 / Number.EPSILON; + var roundTiesToEven = function roundTiesToEven(n) { + // Even though this reduces down to `return n`, it takes advantage of built-in rounding. + return (n + inverseEpsilon) - inverseEpsilon; + }; + var BINARY_32_EPSILON = Math.pow(2, -23); + var BINARY_32_MAX_VALUE = Math.pow(2, 127) * (2 - BINARY_32_EPSILON); + var BINARY_32_MIN_VALUE = Math.pow(2, -126); + var E = Math.E; + var LOG2E = Math.LOG2E; + var LOG10E = Math.LOG10E; + var numberCLZ = Number.prototype.clz; + delete Number.prototype.clz; // Safari 8 has Number#clz + + var MathShims = { + acosh: function acosh(value) { + var x = Number(value); + if (numberIsNaN(x) || value < 1) { return NaN; } + if (x === 1) { return 0; } + if (x === Infinity) { return x; } + + var xInvSquared = 1 / (x * x); + if (x < 2) { + return _log1p(x - 1 + (_sqrt(1 - xInvSquared) * x)); + } + var halfX = x / 2; + return _log1p(halfX + (_sqrt(1 - xInvSquared) * halfX) - 1) + (1 / LOG2E); + }, + + asinh: function asinh(value) { + var x = Number(value); + if (x === 0 || !globalIsFinite(x)) { + return x; + } + + var a = _abs(x); + var aSquared = a * a; + var s = _sign(x); + if (a < 1) { + return s * _log1p(a + (aSquared / (_sqrt(aSquared + 1) + 1))); + } + return s * (_log1p((a / 2) + (_sqrt(1 + (1 / aSquared)) * a / 2) - 1) + (1 / LOG2E)); + }, + + atanh: function atanh(value) { + var x = Number(value); + + if (x === 0) { return x; } + if (x === -1) { return -Infinity; } + if (x === 1) { return Infinity; } + if (numberIsNaN(x) || x < -1 || x > 1) { + return NaN; + } + + var a = _abs(x); + return _sign(x) * _log1p(2 * a / (1 - a)) / 2; + }, + + cbrt: function cbrt(value) { + var x = Number(value); + if (x === 0) { return x; } + var negate = x < 0; + var result; + if (negate) { x = -x; } + if (x === Infinity) { + result = Infinity; + } else { + result = _exp(_log(x) / 3); + // from http://en.wikipedia.org/wiki/Cube_root#Numerical_methods + result = ((x / (result * result)) + (2 * result)) / 3; + } + return negate ? -result : result; + }, + + clz32: function clz32(value) { + // See https://bugs.ecmascript.org/show_bug.cgi?id=2465 + var x = Number(value); + var number = ES.ToUint32(x); + if (number === 0) { + return 32; + } + return numberCLZ ? ES.Call(numberCLZ, number) : 31 - _floor(_log(number + 0.5) * LOG2E); + }, + + cosh: function cosh(value) { + var x = Number(value); + if (x === 0) { return 1; } // +0 or -0 + if (numberIsNaN(x)) { return NaN; } + if (!globalIsFinite(x)) { return Infinity; } + + var t = _exp(_abs(x) - 1); + return (t + (1 / (t * E * E))) * (E / 2); + }, + + expm1: function expm1(value) { + var x = Number(value); + if (x === -Infinity) { return -1; } + if (!globalIsFinite(x) || x === 0) { return x; } + if (_abs(x) > 0.5) { + return _exp(x) - 1; + } + // A more precise approximation using Taylor series expansion + // from https://github.com/paulmillr/es6-shim/issues/314#issuecomment-70293986 + var t = x; + var sum = 0; + var n = 1; + while (sum + t !== sum) { + sum += t; + n += 1; + t *= x / n; + } + return sum; + }, + + hypot: function hypot(x, y) { + var result = 0; + var largest = 0; + for (var i = 0; i < arguments.length; ++i) { + var value = _abs(Number(arguments[i])); + if (largest < value) { + result *= (largest / value) * (largest / value); + result += 1; + largest = value; + } else { + result += value > 0 ? (value / largest) * (value / largest) : value; + } + } + return largest === Infinity ? Infinity : largest * _sqrt(result); + }, + + log2: function log2(value) { + return _log(value) * LOG2E; + }, + + log10: function log10(value) { + return _log(value) * LOG10E; + }, + + log1p: _log1p, + + sign: _sign, + + sinh: function sinh(value) { + var x = Number(value); + if (!globalIsFinite(x) || x === 0) { return x; } + + var a = _abs(x); + if (a < 1) { + var u = Math.expm1(a); + return _sign(x) * u * (1 + (1 / (u + 1))) / 2; + } + var t = _exp(a - 1); + return _sign(x) * (t - (1 / (t * E * E))) * (E / 2); + }, + + tanh: function tanh(value) { + var x = Number(value); + if (numberIsNaN(x) || x === 0) { return x; } + // can exit early at +-20 as JS loses precision for true value at this integer + if (x >= 20) { return 1; } + if (x <= -20) { return -1; } + + return (Math.expm1(x) - Math.expm1(-x)) / (_exp(x) + _exp(-x)); + }, + + trunc: function trunc(value) { + var x = Number(value); + return x < 0 ? -_floor(-x) : _floor(x); + }, + + imul: function imul(x, y) { + // taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul + var a = ES.ToUint32(x); + var b = ES.ToUint32(y); + var ah = (a >>> 16) & 0xffff; + var al = a & 0xffff; + var bh = (b >>> 16) & 0xffff; + var bl = b & 0xffff; + // the shift by 0 fixes the sign on the high part + // the final |0 converts the unsigned value into a signed value + return (al * bl) + ((((ah * bl) + (al * bh)) << 16) >>> 0) | 0; + }, + + fround: function fround(x) { + var v = Number(x); + if (v === 0 || v === Infinity || v === -Infinity || numberIsNaN(v)) { + return v; + } + var sign = _sign(v); + var abs = _abs(v); + if (abs < BINARY_32_MIN_VALUE) { + return sign * roundTiesToEven(abs / BINARY_32_MIN_VALUE / BINARY_32_EPSILON) * BINARY_32_MIN_VALUE * BINARY_32_EPSILON; + } + // Veltkamp's splitting (?) + var a = (1 + (BINARY_32_EPSILON / Number.EPSILON)) * abs; + var result = a - (a - abs); + if (result > BINARY_32_MAX_VALUE || numberIsNaN(result)) { + return sign * Infinity; + } + return sign * result; + } + }; + + var withinULPDistance = function withinULPDistance(result, expected, distance) { + return _abs(1 - (result / expected)) / Number.EPSILON < (distance || 8); + }; + + defineProperties(Math, MathShims); + // Chrome < 40 sinh returns ∞ for large numbers + defineProperty(Math, 'sinh', MathShims.sinh, Math.sinh(710) === Infinity); + // Chrome < 40 cosh returns ∞ for large numbers + defineProperty(Math, 'cosh', MathShims.cosh, Math.cosh(710) === Infinity); + // IE 11 TP has an imprecise log1p: reports Math.log1p(-1e-17) as 0 + 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) + defineProperty(Math, 'asinh', MathShims.asinh, Math.asinh(-1e7) !== -Math.asinh(1e7)); + // Chrome < 54 asinh returns ∞ for large numbers and should not + defineProperty(Math, 'asinh', MathShims.asinh, Math.asinh(1e+300) === Infinity); + // Chrome < 54 atanh incorrectly returns 0 for large numbers + defineProperty(Math, 'atanh', MathShims.atanh, Math.atanh(1e-300) === 0); + // Chrome 40 has an imprecise Math.tanh with very small numbers + defineProperty(Math, 'tanh', MathShims.tanh, Math.tanh(-2e-17) !== -2e-17); + // Chrome 40 loses Math.acosh precision with high numbers + defineProperty(Math, 'acosh', MathShims.acosh, Math.acosh(Number.MAX_VALUE) === Infinity); + // Chrome < 54 has an inaccurate acosh for EPSILON deltas + defineProperty(Math, 'acosh', MathShims.acosh, !withinULPDistance(Math.acosh(1 + Number.EPSILON), Math.sqrt(2 * Number.EPSILON))); + // Firefox 38 on Windows + defineProperty(Math, 'cbrt', MathShims.cbrt, !withinULPDistance(Math.cbrt(1e-300), 1e-100)); + // node 0.11 has an imprecise Math.sinh with very small numbers + defineProperty(Math, 'sinh', MathShims.sinh, Math.sinh(-2e-17) !== -2e-17); + // FF 35 on Linux reports 22025.465794806725 for Math.expm1(10) + var expm1OfTen = Math.expm1(10); + defineProperty(Math, 'expm1', MathShims.expm1, expm1OfTen > 22025.465794806719 || expm1OfTen < 22025.4657948067165168); + + var origMathRound = Math.round; + // breaks in e.g. Safari 8, Internet Explorer 11, Opera 12 + 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. + // This behavior should be governed by "round to nearest, ties to even mode" + // see http://www.ecma-international.org/ecma-262/6.0/#sec-terms-and-definitions-number-type + // These are the boundary cases where it breaks. + var smallestPositiveNumberWhereRoundBreaks = inverseEpsilon + 1; + var largestPositiveNumberWhereRoundBreaks = (2 * inverseEpsilon) - 1; + var roundDoesNotIncreaseIntegers = [ + smallestPositiveNumberWhereRoundBreaks, + largestPositiveNumberWhereRoundBreaks + ].every(function (num) { + return Math.round(num) === num; + }); + defineProperty(Math, 'round', function round(x) { + var floor = _floor(x); + var ceil = floor === -1 ? -0 : floor + 1; + return x - floor < 0.5 ? floor : ceil; + }, !roundHandlesBoundaryConditions || !roundDoesNotIncreaseIntegers); + Value.preserveToString(Math.round, origMathRound); + + var origImul = Math.imul; + if (Math.imul(0xffffffff, 5) !== -5) { + // Safari 6.1, at least, reports "0" for this value + Math.imul = MathShims.imul; + Value.preserveToString(Math.imul, origImul); + } + if (Math.imul.length !== 2) { + // Safari 8.0.4 has a length of 1 + // fixed in https://bugs.webkit.org/show_bug.cgi?id=143658 + overrideNative(Math, 'imul', function imul(x, y) { + return ES.Call(origImul, Math, arguments); + }); + } + + // Promises + // Simplest possible implementation; use a 3rd-party library if you + // want the best possible speed and/or long stack traces. + var PromiseShim = (function () { + var setTimeout = globals.setTimeout; + // some environments don't have setTimeout - no way to shim here. + if (typeof setTimeout !== 'function' && typeof setTimeout !== 'object') { return; } + + ES.IsPromise = function (promise) { + if (!ES.TypeIsObject(promise)) { + return false; + } + if (typeof promise._promise === 'undefined') { + return false; // uninitialized, or missing our hidden field. + } + return true; + }; + + // "PromiseCapability" in the spec is what most promise implementations + // call a "deferred". + var PromiseCapability = function (C) { + if (!ES.IsConstructor(C)) { + throw new TypeError('Bad promise constructor'); + } + var capability = this; + var resolver = function (resolve, reject) { + if (capability.resolve !== void 0 || capability.reject !== void 0) { + throw new TypeError('Bad Promise implementation!'); + } + capability.resolve = resolve; + capability.reject = reject; + }; + // Initialize fields to inform optimizers about the object shape. + capability.resolve = void 0; + capability.reject = void 0; + capability.promise = new C(resolver); + if (!(ES.IsCallable(capability.resolve) && ES.IsCallable(capability.reject))) { + throw new TypeError('Bad promise constructor'); + } + }; + + // find an appropriate setImmediate-alike + var makeZeroTimeout; + /*global window */ + if (typeof window !== 'undefined' && ES.IsCallable(window.postMessage)) { + makeZeroTimeout = function () { + // from http://dbaron.org/log/20100309-faster-timeouts + var timeouts = []; + var messageName = 'zero-timeout-message'; + var setZeroTimeout = function (fn) { + _push(timeouts, fn); + window.postMessage(messageName, '*'); + }; + var handleMessage = function (event) { + if (event.source === window && event.data === messageName) { + event.stopPropagation(); + if (timeouts.length === 0) { return; } + var fn = _shift(timeouts); + fn(); + } + }; + window.addEventListener('message', handleMessage, true); + return setZeroTimeout; + }; + } + var makePromiseAsap = function () { + // An efficient task-scheduler based on a pre-existing Promise + // implementation, which we can use even if we override the + // global Promise below (in order to workaround bugs) + // https://github.com/Raynos/observ-hash/issues/2#issuecomment-35857671 + var P = globals.Promise; + var pr = P && P.resolve && P.resolve(); + return pr && function (task) { + return pr.then(task); + }; + }; + /*global process */ + var enqueue = ES.IsCallable(globals.setImmediate) ? + globals.setImmediate : + typeof process === 'object' && process.nextTick ? process.nextTick : makePromiseAsap() || + (ES.IsCallable(makeZeroTimeout) ? makeZeroTimeout() : function (task) { setTimeout(task, 0); }); // fallback + + // Constants for Promise implementation + var PROMISE_IDENTITY = function (x) { return x; }; + var PROMISE_THROWER = function (e) { throw e; }; + var PROMISE_PENDING = 0; + var PROMISE_FULFILLED = 1; + var PROMISE_REJECTED = 2; + // We store fulfill/reject handlers and capabilities in a single array. + var PROMISE_FULFILL_OFFSET = 0; + var PROMISE_REJECT_OFFSET = 1; + var PROMISE_CAPABILITY_OFFSET = 2; + // This is used in an optimization for chaining promises via then. + var PROMISE_FAKE_CAPABILITY = {}; + + var enqueuePromiseReactionJob = function (handler, capability, argument) { + enqueue(function () { + promiseReactionJob(handler, capability, argument); + }); + }; + + var promiseReactionJob = function (handler, promiseCapability, argument) { + var handlerResult, f; + if (promiseCapability === PROMISE_FAKE_CAPABILITY) { + // Fast case, when we don't actually need to chain through to a + // (real) promiseCapability. + return handler(argument); + } + try { + handlerResult = handler(argument); + f = promiseCapability.resolve; + } catch (e) { + handlerResult = e; + f = promiseCapability.reject; + } + f(handlerResult); + }; + + var fulfillPromise = function (promise, value) { + var _promise = promise._promise; + var length = _promise.reactionLength; + if (length > 0) { + enqueuePromiseReactionJob( + _promise.fulfillReactionHandler0, + _promise.reactionCapability0, + value + ); + _promise.fulfillReactionHandler0 = void 0; + _promise.rejectReactions0 = void 0; + _promise.reactionCapability0 = void 0; + if (length > 1) { + for (var i = 1, idx = 0; i < length; i++, idx += 3) { + enqueuePromiseReactionJob( + _promise[idx + PROMISE_FULFILL_OFFSET], + _promise[idx + PROMISE_CAPABILITY_OFFSET], + value + ); + promise[idx + PROMISE_FULFILL_OFFSET] = void 0; + promise[idx + PROMISE_REJECT_OFFSET] = void 0; + promise[idx + PROMISE_CAPABILITY_OFFSET] = void 0; + } + } + } + _promise.result = value; + _promise.state = PROMISE_FULFILLED; + _promise.reactionLength = 0; + }; + + var rejectPromise = function (promise, reason) { + var _promise = promise._promise; + var length = _promise.reactionLength; + if (length > 0) { + enqueuePromiseReactionJob( + _promise.rejectReactionHandler0, + _promise.reactionCapability0, + reason + ); + _promise.fulfillReactionHandler0 = void 0; + _promise.rejectReactions0 = void 0; + _promise.reactionCapability0 = void 0; + if (length > 1) { + for (var i = 1, idx = 0; i < length; i++, idx += 3) { + enqueuePromiseReactionJob( + _promise[idx + PROMISE_REJECT_OFFSET], + _promise[idx + PROMISE_CAPABILITY_OFFSET], + reason + ); + promise[idx + PROMISE_FULFILL_OFFSET] = void 0; + promise[idx + PROMISE_REJECT_OFFSET] = void 0; + promise[idx + PROMISE_CAPABILITY_OFFSET] = void 0; + } + } + } + _promise.result = reason; + _promise.state = PROMISE_REJECTED; + _promise.reactionLength = 0; + }; + + var createResolvingFunctions = function (promise) { + var alreadyResolved = false; + var resolve = function (resolution) { + var then; + if (alreadyResolved) { return; } + alreadyResolved = true; + if (resolution === promise) { + return rejectPromise(promise, new TypeError('Self resolution')); + } + if (!ES.TypeIsObject(resolution)) { + return fulfillPromise(promise, resolution); + } + try { + then = resolution.then; + } catch (e) { + return rejectPromise(promise, e); + } + if (!ES.IsCallable(then)) { + return fulfillPromise(promise, resolution); + } + enqueue(function () { + promiseResolveThenableJob(promise, resolution, then); + }); + }; + var reject = function (reason) { + if (alreadyResolved) { return; } + alreadyResolved = true; + return rejectPromise(promise, reason); + }; + return { resolve: resolve, reject: reject }; + }; + + var optimizedThen = function (then, thenable, resolve, reject) { + // Optimization: since we discard the result, we can pass our + // own then implementation a special hint to let it know it + // doesn't have to create it. (The PROMISE_FAKE_CAPABILITY + // object is local to this implementation and unforgeable outside.) + if (then === Promise$prototype$then) { + _call(then, thenable, resolve, reject, PROMISE_FAKE_CAPABILITY); + } else { + _call(then, thenable, resolve, reject); + } + }; + var promiseResolveThenableJob = function (promise, thenable, then) { + var resolvingFunctions = createResolvingFunctions(promise); + var resolve = resolvingFunctions.resolve; + var reject = resolvingFunctions.reject; + try { + optimizedThen(then, thenable, resolve, reject); + } catch (e) { + reject(e); + } + }; + + var Promise$prototype, Promise$prototype$then; + var Promise = (function () { + var PromiseShim = function Promise(resolver) { + if (!(this instanceof PromiseShim)) { + throw new TypeError('Constructor Promise requires "new"'); + } + if (this && this._promise) { + throw new TypeError('Bad construction'); + } + // see https://bugs.ecmascript.org/show_bug.cgi?id=2482 + if (!ES.IsCallable(resolver)) { + throw new TypeError('not a valid resolver'); + } + var promise = emulateES6construct(this, PromiseShim, Promise$prototype, { + _promise: { + result: void 0, + state: PROMISE_PENDING, + // The first member of the "reactions" array is inlined here, + // since most promises only have one reaction. + // We've also exploded the 'reaction' object to inline the + // "handler" and "capability" fields, since both fulfill and + // reject reactions share the same capability. + reactionLength: 0, + fulfillReactionHandler0: void 0, + rejectReactionHandler0: void 0, + reactionCapability0: void 0 + } + }); + var resolvingFunctions = createResolvingFunctions(promise); + var reject = resolvingFunctions.reject; + try { + resolver(resolvingFunctions.resolve, reject); + } catch (e) { + reject(e); + } + return promise; + }; + return PromiseShim; + }()); + Promise$prototype = Promise.prototype; + + var _promiseAllResolver = function (index, values, capability, remaining) { + var alreadyCalled = false; + return function (x) { + if (alreadyCalled) { return; } + alreadyCalled = true; + values[index] = x; + if ((--remaining.count) === 0) { + var resolve = capability.resolve; + resolve(values); // call w/ this===undefined + } + }; + }; + + var performPromiseAll = function (iteratorRecord, C, resultCapability) { + var it = iteratorRecord.iterator; + var values = []; + var remaining = { count: 1 }; + var next, nextValue; + var index = 0; + while (true) { + try { + next = ES.IteratorStep(it); + if (next === false) { + iteratorRecord.done = true; + break; + } + nextValue = next.value; + } catch (e) { + iteratorRecord.done = true; + throw e; + } + values[index] = void 0; + var nextPromise = C.resolve(nextValue); + var resolveElement = _promiseAllResolver( + index, + values, + resultCapability, + remaining + ); + remaining.count += 1; + optimizedThen(nextPromise.then, nextPromise, resolveElement, resultCapability.reject); + index += 1; + } + if ((--remaining.count) === 0) { + var resolve = resultCapability.resolve; + resolve(values); // call w/ this===undefined + } + return resultCapability.promise; + }; + + var performPromiseRace = function (iteratorRecord, C, resultCapability) { + var it = iteratorRecord.iterator; + var next, nextValue, nextPromise; + while (true) { + try { + next = ES.IteratorStep(it); + if (next === false) { + // NOTE: If iterable has no items, resulting promise will never + // resolve; see: + // https://github.com/domenic/promises-unwrapping/issues/75 + // https://bugs.ecmascript.org/show_bug.cgi?id=2515 + iteratorRecord.done = true; + break; + } + nextValue = next.value; + } catch (e) { + iteratorRecord.done = true; + throw e; + } + nextPromise = C.resolve(nextValue); + optimizedThen(nextPromise.then, nextPromise, resultCapability.resolve, resultCapability.reject); + } + return resultCapability.promise; + }; + + defineProperties(Promise, { + all: function all(iterable) { + var C = this; + if (!ES.TypeIsObject(C)) { + throw new TypeError('Promise is not object'); + } + var capability = new PromiseCapability(C); + var iterator, iteratorRecord; + try { + iterator = ES.GetIterator(iterable); + iteratorRecord = { iterator: iterator, done: false }; + return performPromiseAll(iteratorRecord, C, capability); + } catch (e) { + var exception = e; + if (iteratorRecord && !iteratorRecord.done) { + try { + ES.IteratorClose(iterator, true); + } catch (ee) { + exception = ee; + } + } + var reject = capability.reject; + reject(exception); + return capability.promise; + } + }, + + race: function race(iterable) { + var C = this; + if (!ES.TypeIsObject(C)) { + throw new TypeError('Promise is not object'); + } + var capability = new PromiseCapability(C); + var iterator, iteratorRecord; + try { + iterator = ES.GetIterator(iterable); + iteratorRecord = { iterator: iterator, done: false }; + return performPromiseRace(iteratorRecord, C, capability); + } catch (e) { + var exception = e; + if (iteratorRecord && !iteratorRecord.done) { + try { + ES.IteratorClose(iterator, true); + } catch (ee) { + exception = ee; + } + } + var reject = capability.reject; + reject(exception); + return capability.promise; + } + }, + + reject: function reject(reason) { + var C = this; + if (!ES.TypeIsObject(C)) { + throw new TypeError('Bad promise constructor'); + } + var capability = new PromiseCapability(C); + var rejectFunc = capability.reject; + rejectFunc(reason); // call with this===undefined + return capability.promise; + }, + + resolve: function resolve(v) { + // See https://esdiscuss.org/topic/fixing-promise-resolve for spec + var C = this; + if (!ES.TypeIsObject(C)) { + throw new TypeError('Bad promise constructor'); + } + if (ES.IsPromise(v)) { + var constructor = v.constructor; + if (constructor === C) { + return v; + } + } + var capability = new PromiseCapability(C); + var resolveFunc = capability.resolve; + resolveFunc(v); // call with this===undefined + return capability.promise; + } + }); + + defineProperties(Promise$prototype, { + 'catch': function (onRejected) { + return this.then(null, onRejected); + }, + + then: function then(onFulfilled, onRejected) { + var promise = this; + if (!ES.IsPromise(promise)) { throw new TypeError('not a promise'); } + var C = ES.SpeciesConstructor(promise, Promise); + var resultCapability; + var returnValueIsIgnored = arguments.length > 2 && arguments[2] === PROMISE_FAKE_CAPABILITY; + if (returnValueIsIgnored && C === Promise) { + resultCapability = PROMISE_FAKE_CAPABILITY; + } else { + resultCapability = new PromiseCapability(C); + } + // PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability) + // Note that we've split the 'reaction' object into its two + // components, "capabilities" and "handler" + // "capabilities" is always equal to `resultCapability` + var fulfillReactionHandler = ES.IsCallable(onFulfilled) ? onFulfilled : PROMISE_IDENTITY; + var rejectReactionHandler = ES.IsCallable(onRejected) ? onRejected : PROMISE_THROWER; + var _promise = promise._promise; + var value; + if (_promise.state === PROMISE_PENDING) { + if (_promise.reactionLength === 0) { + _promise.fulfillReactionHandler0 = fulfillReactionHandler; + _promise.rejectReactionHandler0 = rejectReactionHandler; + _promise.reactionCapability0 = resultCapability; + } else { + var idx = 3 * (_promise.reactionLength - 1); + _promise[idx + PROMISE_FULFILL_OFFSET] = fulfillReactionHandler; + _promise[idx + PROMISE_REJECT_OFFSET] = rejectReactionHandler; + _promise[idx + PROMISE_CAPABILITY_OFFSET] = resultCapability; + } + _promise.reactionLength += 1; + } else if (_promise.state === PROMISE_FULFILLED) { + value = _promise.result; + enqueuePromiseReactionJob( + fulfillReactionHandler, + resultCapability, + value + ); + } else if (_promise.state === PROMISE_REJECTED) { + value = _promise.result; + enqueuePromiseReactionJob( + rejectReactionHandler, + resultCapability, + value + ); + } else { + throw new TypeError('unexpected Promise state'); + } + return resultCapability.promise; + } + }); + // This helps the optimizer by ensuring that methods which take + // capabilities aren't polymorphic. + PROMISE_FAKE_CAPABILITY = new PromiseCapability(Promise); + Promise$prototype$then = Promise$prototype.then; + + return Promise; + }()); + + // Chrome's native Promise has extra methods that it shouldn't have. Let's remove them. + if (globals.Promise) { + delete globals.Promise.accept; + delete globals.Promise.defer; + delete globals.Promise.prototype.chain; + } + + if (typeof PromiseShim === 'function') { + // export the Promise constructor. + defineProperties(globals, { Promise: PromiseShim }); + // In Chrome 33 (and thereabouts) Promise is defined, but the + // implementation is buggy in a number of ways. Let's check subclassing + // support to see if we have a buggy implementation. + var promiseSupportsSubclassing = supportsSubclassing(globals.Promise, function (S) { + return S.resolve(42).then(function () {}) instanceof S; + }); + var promiseIgnoresNonFunctionThenCallbacks = !throwsError(function () { + return globals.Promise.reject(42).then(null, 5).then(null, noop); + }); + var promiseRequiresObjectContext = throwsError(function () { return globals.Promise.call(3, noop); }); + // Promise.resolve() was errata'ed late in the ES6 process. + // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1170742 + // https://code.google.com/p/v8/issues/detail?id=4161 + // It serves as a proxy for a number of other bugs in early Promise + // implementations. + var promiseResolveBroken = (function (Promise) { + var p = Promise.resolve(5); + p.constructor = {}; + var p2 = Promise.resolve(p); + try { + p2.then(null, noop).then(null, noop); // avoid "uncaught rejection" warnings in console + } catch (e) { + return true; // v8 native Promises break here https://code.google.com/p/chromium/issues/detail?id=575314 + } + return p === p2; // This *should* be false! + }(globals.Promise)); + + // Chrome 46 (probably older too) does not retrieve a thenable's .then synchronously + var getsThenSynchronously = supportsDescriptors && (function () { + var count = 0; + // eslint-disable-next-line getter-return + var thenable = Object.defineProperty({}, 'then', { get: function () { count += 1; } }); + return count === 1; + }()); + + var BadResolverPromise = function BadResolverPromise(executor) { + var p = new Promise(executor); + executor(3, function () {}); + this.then = p.then; + this.constructor = BadResolverPromise; + }; + BadResolverPromise.prototype = Promise.prototype; + BadResolverPromise.all = Promise.all; + // Chrome Canary 49 (probably older too) has some implementation bugs + var hasBadResolverPromise = valueOrFalseIfThrows(function () { + return !!BadResolverPromise.all([1, 2]); + }); + + if (!promiseSupportsSubclassing || !promiseIgnoresNonFunctionThenCallbacks || + !promiseRequiresObjectContext || promiseResolveBroken || + !getsThenSynchronously || hasBadResolverPromise) { + /* globals Promise: true */ + /* eslint-disable no-undef, no-global-assign */ + Promise = PromiseShim; + /* eslint-enable no-undef, no-global-assign */ + /* globals Promise: false */ + overrideNative(globals, 'Promise', PromiseShim); + } + if (Promise.all.length !== 1) { + var origAll = Promise.all; + overrideNative(Promise, 'all', function all(iterable) { + return ES.Call(origAll, this, arguments); + }); + } + if (Promise.race.length !== 1) { + var origRace = Promise.race; + overrideNative(Promise, 'race', function race(iterable) { + return ES.Call(origRace, this, arguments); + }); + } + if (Promise.resolve.length !== 1) { + var origResolve = Promise.resolve; + overrideNative(Promise, 'resolve', function resolve(x) { + return ES.Call(origResolve, this, arguments); + }); + } + if (Promise.reject.length !== 1) { + var origReject = Promise.reject; + overrideNative(Promise, 'reject', function reject(r) { + return ES.Call(origReject, this, arguments); + }); + } + ensureEnumerable(Promise, 'all'); + ensureEnumerable(Promise, 'race'); + ensureEnumerable(Promise, 'resolve'); + ensureEnumerable(Promise, 'reject'); + addDefaultSpecies(Promise); + } + + // Map and Set require a true ES5 environment + // Their fast path also requires that the environment preserve + // property insertion order, which is not guaranteed by the spec. + var testOrder = function (a) { + var b = keys(_reduce(a, function (o, k) { + o[k] = true; + return o; + }, {})); + return a.join(':') === b.join(':'); + }; + var preservesInsertionOrder = testOrder(['z', 'a', 'bb']); + // some engines (eg, Chrome) only preserve insertion order for string keys + var preservesNumericInsertionOrder = testOrder(['z', 1, 'a', '3', 2]); + + if (supportsDescriptors) { + + var fastkey = function fastkey(key, skipInsertionOrderCheck) { + if (!skipInsertionOrderCheck && !preservesInsertionOrder) { + return null; + } + if (isNullOrUndefined(key)) { + return '^' + ES.ToString(key); + } else if (typeof key === 'string') { + return '$' + key; + } else if (typeof key === 'number') { + // note that -0 will get coerced to "0" when used as a property key + if (!preservesNumericInsertionOrder) { + return 'n' + key; + } + return key; + } else if (typeof key === 'boolean') { + return 'b' + key; + } + return null; + }; + + var emptyObject = function emptyObject() { + // accomodate some older not-quite-ES5 browsers + return Object.create ? Object.create(null) : {}; + }; + + var addIterableToMap = function addIterableToMap(MapConstructor, map, iterable) { + if (isArray(iterable) || Type.string(iterable)) { + _forEach(iterable, function (entry) { + if (!ES.TypeIsObject(entry)) { + throw new TypeError('Iterator value ' + entry + ' is not an entry object'); + } + map.set(entry[0], entry[1]); + }); + } else if (iterable instanceof MapConstructor) { + _call(MapConstructor.prototype.forEach, iterable, function (value, key) { + map.set(key, value); + }); + } else { + var iter, adder; + if (!isNullOrUndefined(iterable)) { + adder = map.set; + if (!ES.IsCallable(adder)) { throw new TypeError('bad map'); } + iter = ES.GetIterator(iterable); + } + if (typeof iter !== 'undefined') { + while (true) { + var next = ES.IteratorStep(iter); + if (next === false) { break; } + var nextItem = next.value; + try { + if (!ES.TypeIsObject(nextItem)) { + throw new TypeError('Iterator value ' + nextItem + ' is not an entry object'); + } + _call(adder, map, nextItem[0], nextItem[1]); + } catch (e) { + ES.IteratorClose(iter, true); + throw e; + } + } + } + } + }; + var addIterableToSet = function addIterableToSet(SetConstructor, set, iterable) { + if (isArray(iterable) || Type.string(iterable)) { + _forEach(iterable, function (value) { + set.add(value); + }); + } else if (iterable instanceof SetConstructor) { + _call(SetConstructor.prototype.forEach, iterable, function (value) { + set.add(value); + }); + } else { + var iter, adder; + if (!isNullOrUndefined(iterable)) { + adder = set.add; + if (!ES.IsCallable(adder)) { throw new TypeError('bad set'); } + iter = ES.GetIterator(iterable); + } + if (typeof iter !== 'undefined') { + while (true) { + var next = ES.IteratorStep(iter); + if (next === false) { break; } + var nextValue = next.value; + try { + _call(adder, set, nextValue); + } catch (e) { + ES.IteratorClose(iter, true); + throw e; + } + } + } + } + }; + + var collectionShims = { + Map: (function () { + + var empty = {}; + + var MapEntry = function MapEntry(key, value) { + this.key = key; + this.value = value; + this.next = null; + this.prev = null; + }; + + MapEntry.prototype.isRemoved = function isRemoved() { + return this.key === empty; + }; + + var isMap = function isMap(map) { + return !!map._es6map; + }; + + var requireMapSlot = function requireMapSlot(map, method) { + if (!ES.TypeIsObject(map) || !isMap(map)) { + throw new TypeError('Method Map.prototype.' + method + ' called on incompatible receiver ' + ES.ToString(map)); + } + }; + + var MapIterator = function MapIterator(map, kind) { + requireMapSlot(map, '[[MapIterator]]'); + this.head = map._head; + this.i = this.head; + this.kind = kind; + }; + + MapIterator.prototype = { + isMapIterator: true, + next: function next() { + if (!this.isMapIterator) { + throw new TypeError('Not a MapIterator'); + } + var i = this.i; + var kind = this.kind; + var head = this.head; + if (typeof this.i === 'undefined') { + return iteratorResult(); + } + while (i.isRemoved() && i !== head) { + // back up off of removed entries + i = i.prev; + } + // advance to next unreturned element. + var result; + while (i.next !== head) { + i = i.next; + if (!i.isRemoved()) { + if (kind === 'key') { + result = i.key; + } else if (kind === 'value') { + result = i.value; + } else { + result = [i.key, i.value]; + } + this.i = i; + return iteratorResult(result); + } + } + // once the iterator is done, it is done forever. + this.i = void 0; + return iteratorResult(); + } + }; + addIterator(MapIterator.prototype); + + var Map$prototype; + var MapShim = function Map() { + if (!(this instanceof Map)) { + throw new TypeError('Constructor Map requires "new"'); + } + if (this && this._es6map) { + throw new TypeError('Bad construction'); + } + var map = emulateES6construct(this, Map, Map$prototype, { + _es6map: true, + _head: null, + _map: OrigMap ? new OrigMap() : null, + _size: 0, + _storage: emptyObject() + }); + + var head = new MapEntry(null, null); + // circular doubly-linked list. + /* eslint no-multi-assign: 1 */ + head.next = head.prev = head; + map._head = head; + + // Optionally initialize map from iterable + if (arguments.length > 0) { + addIterableToMap(Map, map, arguments[0]); + } + return map; + }; + Map$prototype = MapShim.prototype; + + Value.getter(Map$prototype, 'size', function () { + if (typeof this._size === 'undefined') { + throw new TypeError('size method called on incompatible Map'); + } + return this._size; + }); + + defineProperties(Map$prototype, { + get: function get(key) { + requireMapSlot(this, 'get'); + var entry; + var fkey = fastkey(key, true); + if (fkey !== null) { + // fast O(1) path + entry = this._storage[fkey]; + if (entry) { + return entry.value; + } else { + return; + } + } + if (this._map) { + // fast object key path + entry = origMapGet.call(this._map, key); + if (entry) { + return entry.value; + } else { + return; + } + } + var head = this._head; + var i = head; + while ((i = i.next) !== head) { + if (ES.SameValueZero(i.key, key)) { + return i.value; + } + } + }, + + has: function has(key) { + requireMapSlot(this, 'has'); + var fkey = fastkey(key, true); + if (fkey !== null) { + // fast O(1) path + return typeof this._storage[fkey] !== 'undefined'; + } + if (this._map) { + // fast object key path + return origMapHas.call(this._map, key); + } + var head = this._head; + var i = head; + while ((i = i.next) !== head) { + if (ES.SameValueZero(i.key, key)) { + return true; + } + } + return false; + }, + + set: function set(key, value) { + requireMapSlot(this, 'set'); + var head = this._head; + var i = head; + var entry; + var fkey = fastkey(key, true); + if (fkey !== null) { + // fast O(1) path + if (typeof this._storage[fkey] !== 'undefined') { + this._storage[fkey].value = value; + return this; + } else { + entry = this._storage[fkey] = new MapEntry(key, value); /* eslint no-multi-assign: 1 */ + i = head.prev; + // fall through + } + } else if (this._map) { + // fast object key path + if (origMapHas.call(this._map, key)) { + origMapGet.call(this._map, key).value = value; + } else { + entry = new MapEntry(key, value); + origMapSet.call(this._map, key, entry); + i = head.prev; + // fall through + } + } + while ((i = i.next) !== head) { + if (ES.SameValueZero(i.key, key)) { + i.value = value; + return this; + } + } + entry = entry || new MapEntry(key, value); + if (ES.SameValue(-0, key)) { + entry.key = +0; // coerce -0 to +0 in entry + } + entry.next = this._head; + entry.prev = this._head.prev; + entry.prev.next = entry; + entry.next.prev = entry; + this._size += 1; + return this; + }, + + 'delete': function (key) { + requireMapSlot(this, 'delete'); + var head = this._head; + var i = head; + var fkey = fastkey(key, true); + if (fkey !== null) { + // fast O(1) path + if (typeof this._storage[fkey] === 'undefined') { + return false; + } + i = this._storage[fkey].prev; + delete this._storage[fkey]; + // fall through + } else if (this._map) { + // fast object key path + if (!origMapHas.call(this._map, key)) { + return false; + } + i = origMapGet.call(this._map, key).prev; + origMapDelete.call(this._map, key); + // fall through + } + while ((i = i.next) !== head) { + if (ES.SameValueZero(i.key, key)) { + i.key = empty; + i.value = empty; + i.prev.next = i.next; + i.next.prev = i.prev; + this._size -= 1; + return true; + } + } + return false; + }, + + clear: function clear() { + /* eslint no-multi-assign: 1 */ + requireMapSlot(this, 'clear'); + this._map = OrigMap ? new OrigMap() : null; + this._size = 0; + this._storage = emptyObject(); + var head = this._head; + var i = head; + var p = i.next; + while ((i = p) !== head) { + i.key = empty; + i.value = empty; + p = i.next; + i.next = i.prev = head; + } + head.next = head.prev = head; + }, + + keys: function keys() { + requireMapSlot(this, 'keys'); + return new MapIterator(this, 'key'); + }, + + values: function values() { + requireMapSlot(this, 'values'); + return new MapIterator(this, 'value'); + }, + + entries: function entries() { + requireMapSlot(this, 'entries'); + return new MapIterator(this, 'key+value'); + }, + + forEach: function forEach(callback) { + requireMapSlot(this, 'forEach'); + var context = arguments.length > 1 ? arguments[1] : null; + var it = this.entries(); + for (var entry = it.next(); !entry.done; entry = it.next()) { + if (context) { + _call(callback, context, entry.value[1], entry.value[0], this); + } else { + callback(entry.value[1], entry.value[0], this); + } + } + } + }); + addIterator(Map$prototype, Map$prototype.entries); + + return MapShim; + }()), + + Set: (function () { + var isSet = function isSet(set) { + return set._es6set && typeof set._storage !== 'undefined'; + }; + var requireSetSlot = function requireSetSlot(set, method) { + if (!ES.TypeIsObject(set) || !isSet(set)) { + // https://github.com/paulmillr/es6-shim/issues/176 + throw new TypeError('Set.prototype.' + method + ' called on incompatible receiver ' + ES.ToString(set)); + } + }; + + // Creating a Map is expensive. To speed up the common case of + // Sets containing only string or numeric keys, we use an object + // as backing storage and lazily create a full Map only when + // required. + var Set$prototype; + var SetShim = function Set() { + if (!(this instanceof Set)) { + throw new TypeError('Constructor Set requires "new"'); + } + if (this && this._es6set) { + throw new TypeError('Bad construction'); + } + var set = emulateES6construct(this, Set, Set$prototype, { + _es6set: true, + '[[SetData]]': null, + _storage: emptyObject() + }); + if (!set._es6set) { + throw new TypeError('bad set'); + } + + // Optionally initialize Set from iterable + if (arguments.length > 0) { + addIterableToSet(Set, set, arguments[0]); + } + return set; + }; + Set$prototype = SetShim.prototype; + + var decodeKey = function (key) { + var k = key; + if (k === '^null') { + return null; + } else if (k === '^undefined') { + return void 0; + } else { + var first = k.charAt(0); + if (first === '$') { + return _strSlice(k, 1); + } else if (first === 'n') { + return +_strSlice(k, 1); + } else if (first === 'b') { + return k === 'btrue'; + } + } + return +k; + }; + // Switch from the object backing storage to a full Map. + var ensureMap = function ensureMap(set) { + if (!set['[[SetData]]']) { + var m = new collectionShims.Map(); + set['[[SetData]]'] = m; + _forEach(keys(set._storage), function (key) { + var k = decodeKey(key); + m.set(k, k); + }); + set['[[SetData]]'] = m; + } + set._storage = null; // free old backing storage + }; + + Value.getter(SetShim.prototype, 'size', function () { + requireSetSlot(this, 'size'); + if (this._storage) { + return keys(this._storage).length; + } + ensureMap(this); + return this['[[SetData]]'].size; + }); + + defineProperties(SetShim.prototype, { + has: function has(key) { + requireSetSlot(this, 'has'); + var fkey; + if (this._storage && (fkey = fastkey(key)) !== null) { + return !!this._storage[fkey]; + } + ensureMap(this); + return this['[[SetData]]'].has(key); + }, + + add: function add(key) { + requireSetSlot(this, 'add'); + var fkey; + if (this._storage && (fkey = fastkey(key)) !== null) { + this._storage[fkey] = true; + return this; + } + ensureMap(this); + this['[[SetData]]'].set(key, key); + return this; + }, + + 'delete': function (key) { + requireSetSlot(this, 'delete'); + var fkey; + if (this._storage && (fkey = fastkey(key)) !== null) { + var hasFKey = _hasOwnProperty(this._storage, fkey); + return (delete this._storage[fkey]) && hasFKey; + } + ensureMap(this); + return this['[[SetData]]']['delete'](key); + }, + + clear: function clear() { + requireSetSlot(this, 'clear'); + if (this._storage) { + this._storage = emptyObject(); + } + if (this['[[SetData]]']) { + this['[[SetData]]'].clear(); + } + }, + + values: function values() { + requireSetSlot(this, 'values'); + ensureMap(this); + return new SetIterator(this['[[SetData]]'].values()); + }, + + entries: function entries() { + requireSetSlot(this, 'entries'); + ensureMap(this); + return new SetIterator(this['[[SetData]]'].entries()); + }, + + forEach: function forEach(callback) { + requireSetSlot(this, 'forEach'); + var context = arguments.length > 1 ? arguments[1] : null; + var entireSet = this; + ensureMap(entireSet); + this['[[SetData]]'].forEach(function (value, key) { + if (context) { + _call(callback, context, key, key, entireSet); + } else { + callback(key, key, entireSet); + } + }); + } + }); + defineProperty(SetShim.prototype, 'keys', SetShim.prototype.values, true); + addIterator(SetShim.prototype, SetShim.prototype.values); + + var SetIterator = function SetIterator(it) { + this.it = it; + }; + SetIterator.prototype = { + isSetIterator: true, + next: function next() { + if (!this.isSetIterator) { + throw new TypeError('Not a SetIterator'); + } + return this.it.next(); + } + }; + addIterator(SetIterator.prototype); + + return SetShim; + }()) + }; + + var isGoogleTranslate = globals.Set && !Set.prototype['delete'] && Set.prototype.remove && Set.prototype.items && Set.prototype.map && Array.isArray(new Set().keys); + if (isGoogleTranslate) { + // special-case force removal of wildly invalid Set implementation in Google Translate iframes + // see https://github.com/paulmillr/es6-shim/issues/438 / https://twitter.com/ljharb/status/849335573114363904 + globals.Set = collectionShims.Set; + } + if (globals.Map || globals.Set) { + // Safari 8, for example, doesn't accept an iterable. + var mapAcceptsArguments = valueOrFalseIfThrows(function () { return new Map([[1, 2]]).get(1) === 2; }); + if (!mapAcceptsArguments) { + globals.Map = function Map() { + if (!(this instanceof Map)) { + throw new TypeError('Constructor Map requires "new"'); + } + var m = new OrigMap(); + if (arguments.length > 0) { + addIterableToMap(Map, m, arguments[0]); + } + delete m.constructor; + Object.setPrototypeOf(m, globals.Map.prototype); + return m; + }; + globals.Map.prototype = create(OrigMap.prototype); + defineProperty(globals.Map.prototype, 'constructor', globals.Map, true); + Value.preserveToString(globals.Map, OrigMap); + } + var testMap = new Map(); + var mapUsesSameValueZero = (function () { + // Chrome 38-42, node 0.11/0.12, iojs 1/2 also have a bug when the Map has a size > 4 + var m = new Map([[1, 0], [2, 0], [3, 0], [4, 0]]); + m.set(-0, m); + return m.get(0) === m && m.get(-0) === m && m.has(0) && m.has(-0); + }()); + var mapSupportsChaining = testMap.set(1, 2) === testMap; + if (!mapUsesSameValueZero || !mapSupportsChaining) { + overrideNative(Map.prototype, 'set', function set(k, v) { + _call(origMapSet, this, k === 0 ? 0 : k, v); + return this; + }); + } + if (!mapUsesSameValueZero) { + defineProperties(Map.prototype, { + get: function get(k) { + return _call(origMapGet, this, k === 0 ? 0 : k); + }, + has: function has(k) { + return _call(origMapHas, this, k === 0 ? 0 : k); + } + }, true); + Value.preserveToString(Map.prototype.get, origMapGet); + Value.preserveToString(Map.prototype.has, origMapHas); + } + var testSet = new Set(); + var setUsesSameValueZero = Set.prototype['delete'] && Set.prototype.add && Set.prototype.has && (function (s) { + s['delete'](0); + s.add(-0); + return !s.has(0); + }(testSet)); + var setSupportsChaining = testSet.add(1) === testSet; + if (!setUsesSameValueZero || !setSupportsChaining) { + var origSetAdd = Set.prototype.add; + Set.prototype.add = function add(v) { + _call(origSetAdd, this, v === 0 ? 0 : v); + return this; + }; + Value.preserveToString(Set.prototype.add, origSetAdd); + } + if (!setUsesSameValueZero) { + var origSetHas = Set.prototype.has; + Set.prototype.has = function has(v) { + return _call(origSetHas, this, v === 0 ? 0 : v); + }; + Value.preserveToString(Set.prototype.has, origSetHas); + var origSetDel = Set.prototype['delete']; + Set.prototype['delete'] = function SetDelete(v) { + return _call(origSetDel, this, v === 0 ? 0 : v); + }; + Value.preserveToString(Set.prototype['delete'], origSetDel); + } + var mapSupportsSubclassing = supportsSubclassing(globals.Map, function (M) { + var m = new M([]); + // Firefox 32 is ok with the instantiating the subclass but will + // throw when the map is used. + m.set(42, 42); + return m instanceof M; + }); + // without Object.setPrototypeOf, subclassing is not possible + var mapFailsToSupportSubclassing = Object.setPrototypeOf && !mapSupportsSubclassing; + var mapRequiresNew = (function () { + try { + return !(globals.Map() instanceof globals.Map); + } catch (e) { + return e instanceof TypeError; + } + }()); + if (globals.Map.length !== 0 || mapFailsToSupportSubclassing || !mapRequiresNew) { + globals.Map = function Map() { + if (!(this instanceof Map)) { + throw new TypeError('Constructor Map requires "new"'); + } + var m = new OrigMap(); + if (arguments.length > 0) { + addIterableToMap(Map, m, arguments[0]); + } + delete m.constructor; + Object.setPrototypeOf(m, Map.prototype); + return m; + }; + globals.Map.prototype = OrigMap.prototype; + defineProperty(globals.Map.prototype, 'constructor', globals.Map, true); + Value.preserveToString(globals.Map, OrigMap); + } + var setSupportsSubclassing = supportsSubclassing(globals.Set, function (S) { + var s = new S([]); + s.add(42, 42); + return s instanceof S; + }); + // without Object.setPrototypeOf, subclassing is not possible + var setFailsToSupportSubclassing = Object.setPrototypeOf && !setSupportsSubclassing; + var setRequiresNew = (function () { + try { + return !(globals.Set() instanceof globals.Set); + } catch (e) { + return e instanceof TypeError; + } + }()); + if (globals.Set.length !== 0 || setFailsToSupportSubclassing || !setRequiresNew) { + var OrigSet = globals.Set; + globals.Set = function Set() { + if (!(this instanceof Set)) { + throw new TypeError('Constructor Set requires "new"'); + } + var s = new OrigSet(); + if (arguments.length > 0) { + addIterableToSet(Set, s, arguments[0]); + } + delete s.constructor; + Object.setPrototypeOf(s, Set.prototype); + return s; + }; + globals.Set.prototype = OrigSet.prototype; + defineProperty(globals.Set.prototype, 'constructor', globals.Set, true); + Value.preserveToString(globals.Set, OrigSet); + } + var newMap = new globals.Map(); + var mapIterationThrowsStopIterator = !valueOrFalseIfThrows(function () { + return newMap.keys().next().done; + }); + /* + - In Firefox < 23, Map#size is a function. + - In all current Firefox, Set#entries/keys/values & Map#clear do not exist + - https://bugzilla.mozilla.org/show_bug.cgi?id=869996 + - In Firefox 24, Map and Set do not implement forEach + - In Firefox 25 at least, Map and Set are callable without "new" + */ + 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 + mapIterationThrowsStopIterator || // Firefox 25 + !mapSupportsSubclassing + ) { + defineProperties(globals, { + Map: collectionShims.Map, + Set: collectionShims.Set + }, true); + } + + if (globals.Set.prototype.keys !== globals.Set.prototype.values) { + // Fixed in WebKit with https://bugs.webkit.org/show_bug.cgi?id=144190 + defineProperty(globals.Set.prototype, 'keys', globals.Set.prototype.values, true); + } + + // Shim incomplete iterator implementations. + addIterator(Object.getPrototypeOf((new globals.Map()).keys())); + addIterator(Object.getPrototypeOf((new globals.Set()).keys())); + + if (functionsHaveNames && globals.Set.prototype.has.name !== 'has') { + // Microsoft Edge v0.11.10074.0 is missing a name on Set#has + var anonymousSetHas = globals.Set.prototype.has; + overrideNative(globals.Set.prototype, 'has', function has(key) { + return _call(anonymousSetHas, this, key); + }); + } + } + defineProperties(globals, collectionShims); + addDefaultSpecies(globals.Map); + addDefaultSpecies(globals.Set); + } + + var throwUnlessTargetIsObject = function throwUnlessTargetIsObject(target) { + if (!ES.TypeIsObject(target)) { + throw new TypeError('target must be an object'); + } + }; + + // Some Reflect methods are basically the same as + // those on the Object global, except that a TypeError is thrown if + // target isn't an object. As well as returning a boolean indicating + // the success of the operation. + var ReflectShims = { + // Apply method in a functional form. + apply: function apply() { + return ES.Call(ES.Call, null, arguments); + }, + + // New operator in a functional form. + construct: function construct(constructor, args) { + if (!ES.IsConstructor(constructor)) { + throw new TypeError('First argument must be a constructor.'); + } + var newTarget = arguments.length > 2 ? arguments[2] : constructor; + if (!ES.IsConstructor(newTarget)) { + throw new TypeError('new.target must be a constructor.'); + } + return ES.Construct(constructor, args, newTarget, 'internal'); + }, + + // When deleting a non-existent or configurable property, + // true is returned. + // When attempting to delete a non-configurable property, + // it will return false. + deleteProperty: function deleteProperty(target, key) { + throwUnlessTargetIsObject(target); + if (supportsDescriptors) { + var desc = Object.getOwnPropertyDescriptor(target, key); + + if (desc && !desc.configurable) { + return false; + } + } + + // Will return true. + return delete target[key]; + }, + + has: function has(target, key) { + throwUnlessTargetIsObject(target); + return key in target; + } + }; + + if (Object.getOwnPropertyNames) { + Object.assign(ReflectShims, { + // Basically the result of calling the internal [[OwnPropertyKeys]]. + // Concatenating propertyNames and propertySymbols should do the trick. + // This should continue to work together with a Symbol shim + // which overrides Object.getOwnPropertyNames and implements + // Object.getOwnPropertySymbols. + ownKeys: function ownKeys(target) { + throwUnlessTargetIsObject(target); + var keys = Object.getOwnPropertyNames(target); + + if (ES.IsCallable(Object.getOwnPropertySymbols)) { + _pushApply(keys, Object.getOwnPropertySymbols(target)); + } + + return keys; + } + }); + } + + var callAndCatchException = function ConvertExceptionToBoolean(func) { + return !throwsError(func); + }; + + if (Object.preventExtensions) { + Object.assign(ReflectShims, { + isExtensible: function isExtensible(target) { + throwUnlessTargetIsObject(target); + return Object.isExtensible(target); + }, + preventExtensions: function preventExtensions(target) { + throwUnlessTargetIsObject(target); + return callAndCatchException(function () { + return Object.preventExtensions(target); + }); + } + }); + } + + if (supportsDescriptors) { + var internalGet = function get(target, key, receiver) { + var desc = Object.getOwnPropertyDescriptor(target, key); + + if (!desc) { + var parent = Object.getPrototypeOf(target); + + if (parent === null) { + return void 0; + } + + return internalGet(parent, key, receiver); + } + + if ('value' in desc) { + return desc.value; + } + + if (desc.get) { + return ES.Call(desc.get, receiver); + } + + return void 0; + }; + + var internalSet = function set(target, key, value, receiver) { + var desc = Object.getOwnPropertyDescriptor(target, key); + + if (!desc) { + var parent = Object.getPrototypeOf(target); + + if (parent !== null) { + return internalSet(parent, key, value, receiver); + } + + desc = { + value: void 0, + writable: true, + enumerable: true, + configurable: true + }; + } + + if ('value' in desc) { + if (!desc.writable) { + return false; + } + + if (!ES.TypeIsObject(receiver)) { + return false; + } + + var existingDesc = Object.getOwnPropertyDescriptor(receiver, key); + + if (existingDesc) { + return Reflect.defineProperty(receiver, key, { + value: value + }); + } else { + return Reflect.defineProperty(receiver, key, { + value: value, + writable: true, + enumerable: true, + configurable: true + }); + } + } + + if (desc.set) { + _call(desc.set, receiver, value); + return true; + } + + return false; + }; + + Object.assign(ReflectShims, { + defineProperty: function defineProperty(target, propertyKey, attributes) { + throwUnlessTargetIsObject(target); + return callAndCatchException(function () { + return Object.defineProperty(target, propertyKey, attributes); + }); + }, + + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) { + throwUnlessTargetIsObject(target); + return Object.getOwnPropertyDescriptor(target, propertyKey); + }, + + // Syntax in a functional form. + get: function get(target, key) { + throwUnlessTargetIsObject(target); + var receiver = arguments.length > 2 ? arguments[2] : target; + + return internalGet(target, key, receiver); + }, + + set: function set(target, key, value) { + throwUnlessTargetIsObject(target); + var receiver = arguments.length > 3 ? arguments[3] : target; + + return internalSet(target, key, value, receiver); + } + }); + } + + if (Object.getPrototypeOf) { + var objectDotGetPrototypeOf = Object.getPrototypeOf; + ReflectShims.getPrototypeOf = function getPrototypeOf(target) { + throwUnlessTargetIsObject(target); + return objectDotGetPrototypeOf(target); + }; + } + + if (Object.setPrototypeOf && ReflectShims.getPrototypeOf) { + var willCreateCircularPrototype = function (object, lastProto) { + var proto = lastProto; + while (proto) { + if (object === proto) { + return true; + } + proto = ReflectShims.getPrototypeOf(proto); + } + return false; + }; + + Object.assign(ReflectShims, { + // Sets the prototype of the given object. + // Returns true on success, otherwise false. + setPrototypeOf: function setPrototypeOf(object, proto) { + throwUnlessTargetIsObject(object); + if (proto !== null && !ES.TypeIsObject(proto)) { + throw new TypeError('proto must be an object or null'); + } + + // If they already are the same, we're done. + if (proto === Reflect.getPrototypeOf(object)) { + return true; + } + + // Cannot alter prototype if object not extensible. + if (Reflect.isExtensible && !Reflect.isExtensible(object)) { + return false; + } + + // Ensure that we do not create a circular prototype chain. + if (willCreateCircularPrototype(object, proto)) { + return false; + } + + Object.setPrototypeOf(object, proto); + + return true; + } + }); + } + var defineOrOverrideReflectProperty = function (key, shim) { + if (!ES.IsCallable(globals.Reflect[key])) { + defineProperty(globals.Reflect, key, shim); + } else { + var acceptsPrimitives = valueOrFalseIfThrows(function () { + globals.Reflect[key](1); + globals.Reflect[key](NaN); + globals.Reflect[key](true); + return true; + }); + if (acceptsPrimitives) { + overrideNative(globals.Reflect, key, shim); + } + } + }; + Object.keys(ReflectShims).forEach(function (key) { + defineOrOverrideReflectProperty(key, ReflectShims[key]); + }); + var originalReflectGetProto = globals.Reflect.getPrototypeOf; + if (functionsHaveNames && originalReflectGetProto && originalReflectGetProto.name !== 'getPrototypeOf') { + overrideNative(globals.Reflect, 'getPrototypeOf', function getPrototypeOf(target) { + return _call(originalReflectGetProto, globals.Reflect, target); + }); + } + if (globals.Reflect.setPrototypeOf) { + if (valueOrFalseIfThrows(function () { + globals.Reflect.setPrototypeOf(1, {}); + return true; + })) { + overrideNative(globals.Reflect, 'setPrototypeOf', ReflectShims.setPrototypeOf); + } + } + if (globals.Reflect.defineProperty) { + if (!valueOrFalseIfThrows(function () { + var basic = !globals.Reflect.defineProperty(1, 'test', { value: 1 }); + // "extensible" fails on Edge 0.12 + var extensible = typeof Object.preventExtensions !== 'function' || !globals.Reflect.defineProperty(Object.preventExtensions({}), 'test', {}); + return basic && extensible; + })) { + overrideNative(globals.Reflect, 'defineProperty', ReflectShims.defineProperty); + } + } + if (globals.Reflect.construct) { + if (!valueOrFalseIfThrows(function () { + var F = function F() {}; + return globals.Reflect.construct(function () {}, [], F) instanceof F; + })) { + overrideNative(globals.Reflect, 'construct', ReflectShims.construct); + } + } + + if (String(new Date(NaN)) !== 'Invalid Date') { + var dateToString = Date.prototype.toString; + var shimmedDateToString = function toString() { + var valueOf = +this; + if (valueOf !== valueOf) { + return 'Invalid Date'; + } + return ES.Call(dateToString, this); + }; + overrideNative(Date.prototype, 'toString', shimmedDateToString); + } + + // Annex B HTML methods + // http://www.ecma-international.org/ecma-262/6.0/#sec-additional-properties-of-the-string.prototype-object + var stringHTMLshims = { + anchor: function anchor(name) { return ES.CreateHTML(this, 'a', 'name', name); }, + big: function big() { return ES.CreateHTML(this, 'big', '', ''); }, + blink: function blink() { return ES.CreateHTML(this, 'blink', '', ''); }, + bold: function bold() { return ES.CreateHTML(this, 'b', '', ''); }, + fixed: function fixed() { return ES.CreateHTML(this, 'tt', '', ''); }, + fontcolor: function fontcolor(color) { return ES.CreateHTML(this, 'font', 'color', color); }, + fontsize: function fontsize(size) { return ES.CreateHTML(this, 'font', 'size', size); }, + italics: function italics() { return ES.CreateHTML(this, 'i', '', ''); }, + link: function link(url) { return ES.CreateHTML(this, 'a', 'href', url); }, + small: function small() { return ES.CreateHTML(this, 'small', '', ''); }, + strike: function strike() { return ES.CreateHTML(this, 'strike', '', ''); }, + sub: function sub() { return ES.CreateHTML(this, 'sub', '', ''); }, + sup: function sub() { return ES.CreateHTML(this, 'sup', '', ''); } + }; + _forEach(Object.keys(stringHTMLshims), function (key) { + var method = String.prototype[key]; + var shouldOverwrite = false; + if (ES.IsCallable(method)) { + var output = _call(method, '', ' " '); + var quotesCount = _concat([], output.match(/"/g)).length; + shouldOverwrite = output !== output.toLowerCase() || quotesCount > 2; + } else { + shouldOverwrite = true; + } + if (shouldOverwrite) { + overrideNative(String.prototype, key, stringHTMLshims[key]); + } + }); + + var JSONstringifiesSymbols = (function () { + // Microsoft Edge v0.12 stringifies Symbols incorrectly + if (!hasSymbols) { return false; } // Symbols are not supported + var stringify = typeof JSON === 'object' && typeof JSON.stringify === 'function' ? JSON.stringify : null; + if (!stringify) { return false; } // JSON.stringify is not supported + if (typeof stringify(Symbol()) !== 'undefined') { return true; } // Symbols should become `undefined` + if (stringify([Symbol()]) !== '[null]') { return true; } // Symbols in arrays should become `null` + var obj = { a: Symbol() }; + obj[Symbol()] = true; + if (stringify(obj) !== '{}') { return true; } // Symbol-valued keys *and* Symbol-valued properties should be omitted + return false; + }()); + var JSONstringifyAcceptsObjectSymbol = valueOrFalseIfThrows(function () { + // Chrome 45 throws on stringifying object symbols + if (!hasSymbols) { return true; } // Symbols are not supported + return JSON.stringify(Object(Symbol())) === '{}' && JSON.stringify([Object(Symbol())]) === '[{}]'; + }); + if (JSONstringifiesSymbols || !JSONstringifyAcceptsObjectSymbol) { + var origStringify = JSON.stringify; + overrideNative(JSON, 'stringify', function stringify(value) { + if (typeof value === 'symbol') { return; } + var replacer; + if (arguments.length > 1) { + replacer = arguments[1]; + } + var args = [value]; + if (!isArray(replacer)) { + var replaceFn = ES.IsCallable(replacer) ? replacer : null; + var wrappedReplacer = function (key, val) { + var parsedValue = replaceFn ? _call(replaceFn, this, key, val) : val; + if (typeof parsedValue !== 'symbol') { + if (Type.symbol(parsedValue)) { + return assignTo({})(parsedValue); + } else { + return parsedValue; + } + } + }; + args.push(wrappedReplacer); + } else { + // create wrapped replacer that handles an array replacer? + args.push(replacer); + } + if (arguments.length > 2) { + args.push(arguments[2]); + } + return origStringify.apply(this, args); + }); + } + + return globals; +})); +}); diff --git a/test/form/samples/supports-es6-shim/main.js b/test/form/samples/supports-es6-shim/main.js new file mode 100644 index 00000000000..0617f5e3063 --- /dev/null +++ b/test/form/samples/supports-es6-shim/main.js @@ -0,0 +1 @@ +import 'es6-shim'; diff --git a/test/form/samples/try-statement-deoptimization/follow-parameters/_expected.js b/test/form/samples/try-statement-deoptimization/follow-parameters/_expected.js index 6a420fb59e4..48c6ccc5b32 100644 --- a/test/form/samples/try-statement-deoptimization/follow-parameters/_expected.js +++ b/test/form/samples/try-statement-deoptimization/follow-parameters/_expected.js @@ -1,12 +1,4 @@ -function callGlobalRemoved1() { -} - -function callGlobalRemoved2() { -} - -function callGlobalRetained() { - Object.create(null); - callGlobalRemoved1(); +function properlyTreeshaken() { } function tryIt(other, callback) { @@ -15,7 +7,7 @@ function tryIt(other, callback) { } catch {} } -tryIt(callGlobalRemoved2, callGlobalRetained); +tryIt(properlyTreeshaken, properlyTreeshaken); tryIt( () => { diff --git a/test/form/samples/try-statement-deoptimization/follow-parameters/main.js b/test/form/samples/try-statement-deoptimization/follow-parameters/main.js index 5d27061fb90..430ac3a90e1 100644 --- a/test/form/samples/try-statement-deoptimization/follow-parameters/main.js +++ b/test/form/samples/try-statement-deoptimization/follow-parameters/main.js @@ -1,29 +1,14 @@ -function callGlobalTreeshaken() { +function properlyTreeshaken() { Object.create(null); } -function callGlobalRemoved1() { - Object.create(null); - callGlobalTreeshaken(); -} - -function callGlobalRemoved2() { - Object.create(null); - callGlobalTreeshaken(); -} - -function callGlobalRetained() { - Object.create(null); - callGlobalRemoved1(); -} - function tryIt(other, callback) { try { callback(); } catch {} } -tryIt(callGlobalRemoved2, callGlobalRetained); +tryIt(properlyTreeshaken, properlyTreeshaken); tryIt( () => { diff --git a/test/form/samples/try-statement-deoptimization/follow-pattern-parameters/_expected.js b/test/form/samples/try-statement-deoptimization/follow-pattern-parameters/_expected.js index b60287c802c..44439f5b5ba 100644 --- a/test/form/samples/try-statement-deoptimization/follow-pattern-parameters/_expected.js +++ b/test/form/samples/try-statement-deoptimization/follow-pattern-parameters/_expected.js @@ -1,4 +1,4 @@ -function callGlobalRetained() { +function properlyTreeshaken() { } function tryIt({ callback }) { @@ -7,7 +7,7 @@ function tryIt({ callback }) { } catch {} } -tryIt({ callback: callGlobalRetained }); +tryIt({ callback: properlyTreeshaken }); tryIt({ callback: () => { diff --git a/test/form/samples/try-statement-deoptimization/follow-pattern-parameters/main.js b/test/form/samples/try-statement-deoptimization/follow-pattern-parameters/main.js index 00360093661..cfc626909e4 100644 --- a/test/form/samples/try-statement-deoptimization/follow-pattern-parameters/main.js +++ b/test/form/samples/try-statement-deoptimization/follow-pattern-parameters/main.js @@ -1,19 +1,14 @@ -function callGlobalRemoved() { +function properlyTreeshaken() { Object.create(null); } -function callGlobalRetained() { - Object.create(null); - callGlobalRemoved(); -} - function tryIt({ callback }) { try { callback(); } catch {} } -tryIt({ callback: callGlobalRetained }); +tryIt({ callback: properlyTreeshaken }); tryIt({ callback: () => { diff --git a/test/form/samples/try-statement-deoptimization/follow-variables/_config.js b/test/form/samples/try-statement-deoptimization/follow-variables/_config.js index f9aca82d54c..7422ae5cf03 100644 --- a/test/form/samples/try-statement-deoptimization/follow-variables/_config.js +++ b/test/form/samples/try-statement-deoptimization/follow-variables/_config.js @@ -1,3 +1,3 @@ module.exports = { - description: 'retains side-effect-free code in functions called from try-statement-blocks' + description: 'does not retain side-effect-free code in functions called from try-statement-blocks' }; diff --git a/test/form/samples/try-statement-deoptimization/follow-variables/_expected.js b/test/form/samples/try-statement-deoptimization/follow-variables/_expected.js index 1310d726a07..b25ab22dca7 100644 --- a/test/form/samples/try-statement-deoptimization/follow-variables/_expected.js +++ b/test/form/samples/try-statement-deoptimization/follow-variables/_expected.js @@ -1,11 +1,6 @@ -function callGlobalRemoved() { -} - -function callGlobalRetained() { - Object.create(null); - callGlobalRemoved(); +function properlyTreeshaken() { } try { - callGlobalRetained(); + properlyTreeshaken(); } catch {} diff --git a/test/form/samples/try-statement-deoptimization/follow-variables/main.js b/test/form/samples/try-statement-deoptimization/follow-variables/main.js index 84773829f78..5a46759d394 100644 --- a/test/form/samples/try-statement-deoptimization/follow-variables/main.js +++ b/test/form/samples/try-statement-deoptimization/follow-variables/main.js @@ -1,17 +1,7 @@ -function callGlobalTreeshaken() { +function properlyTreeshaken() { Object.create(null); } -function callGlobalRemoved() { - Object.create(null); - callGlobalTreeshaken(); -} - -function callGlobalRetained() { - Object.create(null); - callGlobalRemoved(); -} - try { - callGlobalRetained(); + properlyTreeshaken(); } catch {}