| (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){ |
| 'use strict'; |
| |
| var keys = require('object-keys').shim(); |
| delete keys.shim; |
| |
| var assign = require('./'); |
| |
| module.exports = assign.shim(); |
| |
| delete assign.shim; |
| |
| },{"./":3,"object-keys":14}],2:[function(require,module,exports){ |
| 'use strict'; |
| |
| // modified from https://github.com/es-shims/es6-shim |
| var keys = require('object-keys'); |
| var canBeObject = function (obj) { |
| return typeof obj !== 'undefined' && obj !== null; |
| }; |
| var hasSymbols = require('has-symbols/shams')(); |
| var callBound = require('call-bind/callBound'); |
| var toObject = Object; |
| var $push = callBound('Array.prototype.push'); |
| var $propIsEnumerable = callBound('Object.prototype.propertyIsEnumerable'); |
| var originalGetSymbols = hasSymbols ? Object.getOwnPropertySymbols : null; |
| |
| // eslint-disable-next-line no-unused-vars |
| module.exports = function assign(target, source1) { |
| if (!canBeObject(target)) { throw new TypeError('target must be an object'); } |
| var objTarget = toObject(target); |
| var s, source, i, props, syms, value, key; |
| for (s = 1; s < arguments.length; ++s) { |
| source = toObject(arguments[s]); |
| props = keys(source); |
| var getSymbols = hasSymbols && (Object.getOwnPropertySymbols || originalGetSymbols); |
| if (getSymbols) { |
| syms = getSymbols(source); |
| for (i = 0; i < syms.length; ++i) { |
| key = syms[i]; |
| if ($propIsEnumerable(source, key)) { |
| $push(props, key); |
| } |
| } |
| } |
| for (i = 0; i < props.length; ++i) { |
| key = props[i]; |
| value = source[key]; |
| if ($propIsEnumerable(source, key)) { |
| objTarget[key] = value; |
| } |
| } |
| } |
| return objTarget; |
| }; |
| |
| },{"call-bind/callBound":4,"has-symbols/shams":11,"object-keys":14}],3:[function(require,module,exports){ |
| 'use strict'; |
| |
| var defineProperties = require('define-properties'); |
| var callBind = require('call-bind'); |
| |
| var implementation = require('./implementation'); |
| var getPolyfill = require('./polyfill'); |
| var shim = require('./shim'); |
| |
| var polyfill = callBind.apply(getPolyfill()); |
| // eslint-disable-next-line no-unused-vars |
| var bound = function assign(target, source1) { |
| return polyfill(Object, arguments); |
| }; |
| |
| defineProperties(bound, { |
| getPolyfill: getPolyfill, |
| implementation: implementation, |
| shim: shim |
| }); |
| |
| module.exports = bound; |
| |
| },{"./implementation":2,"./polyfill":16,"./shim":17,"call-bind":5,"define-properties":6}],4:[function(require,module,exports){ |
| 'use strict'; |
| |
| var GetIntrinsic = require('get-intrinsic'); |
| |
| var callBind = require('./'); |
| |
| var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf')); |
| |
| module.exports = function callBoundIntrinsic(name, allowMissing) { |
| var intrinsic = GetIntrinsic(name, !!allowMissing); |
| if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) { |
| return callBind(intrinsic); |
| } |
| return intrinsic; |
| }; |
| |
| },{"./":5,"get-intrinsic":9}],5:[function(require,module,exports){ |
| 'use strict'; |
| |
| var bind = require('function-bind'); |
| var GetIntrinsic = require('get-intrinsic'); |
| |
| var $apply = GetIntrinsic('%Function.prototype.apply%'); |
| var $call = GetIntrinsic('%Function.prototype.call%'); |
| var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply); |
| |
| var $defineProperty = GetIntrinsic('%Object.defineProperty%', true); |
| |
| if ($defineProperty) { |
| try { |
| $defineProperty({}, 'a', { value: 1 }); |
| } catch (e) { |
| // IE 8 has a broken defineProperty |
| $defineProperty = null; |
| } |
| } |
| |
| module.exports = function callBind() { |
| return $reflectApply(bind, $call, arguments); |
| }; |
| |
| var applyBind = function applyBind() { |
| return $reflectApply(bind, $apply, arguments); |
| }; |
| |
| if ($defineProperty) { |
| $defineProperty(module.exports, 'apply', { value: applyBind }); |
| } else { |
| module.exports.apply = applyBind; |
| } |
| |
| },{"function-bind":8,"get-intrinsic":9}],6:[function(require,module,exports){ |
| 'use strict'; |
| |
| var keys = require('object-keys'); |
| var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol'; |
| |
| var toStr = Object.prototype.toString; |
| var concat = Array.prototype.concat; |
| var origDefineProperty = Object.defineProperty; |
| |
| var isFunction = function (fn) { |
| return typeof fn === 'function' && toStr.call(fn) === '[object Function]'; |
| }; |
| |
| var arePropertyDescriptorsSupported = function () { |
| var obj = {}; |
| try { |
| origDefineProperty(obj, 'x', { enumerable: false, value: obj }); |
| // eslint-disable-next-line no-unused-vars, no-restricted-syntax |
| for (var _ in obj) { // jscs:ignore disallowUnusedVariables |
| return false; |
| } |
| return obj.x === obj; |
| } catch (e) { /* this is IE 8. */ |
| return false; |
| } |
| }; |
| var supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported(); |
| |
| var defineProperty = function (object, name, value, predicate) { |
| if (name in object && (!isFunction(predicate) || !predicate())) { |
| return; |
| } |
| if (supportsDescriptors) { |
| origDefineProperty(object, name, { |
| configurable: true, |
| enumerable: false, |
| value: value, |
| writable: true |
| }); |
| } else { |
| object[name] = value; |
| } |
| }; |
| |
| var defineProperties = function (object, map) { |
| var predicates = arguments.length > 2 ? arguments[2] : {}; |
| var props = keys(map); |
| if (hasSymbols) { |
| props = concat.call(props, Object.getOwnPropertySymbols(map)); |
| } |
| for (var i = 0; i < props.length; i += 1) { |
| defineProperty(object, props[i], map[props[i]], predicates[props[i]]); |
| } |
| }; |
| |
| defineProperties.supportsDescriptors = !!supportsDescriptors; |
| |
| module.exports = defineProperties; |
| |
| },{"object-keys":14}],7:[function(require,module,exports){ |
| 'use strict'; |
| |
| /* eslint no-invalid-this: 1 */ |
| |
| var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible '; |
| var slice = Array.prototype.slice; |
| var toStr = Object.prototype.toString; |
| var funcType = '[object Function]'; |
| |
| module.exports = function bind(that) { |
| var target = this; |
| if (typeof target !== 'function' || toStr.call(target) !== funcType) { |
| throw new TypeError(ERROR_MESSAGE + target); |
| } |
| var args = slice.call(arguments, 1); |
| |
| var bound; |
| var binder = function () { |
| if (this instanceof bound) { |
| var result = target.apply( |
| this, |
| args.concat(slice.call(arguments)) |
| ); |
| if (Object(result) === result) { |
| return result; |
| } |
| return this; |
| } else { |
| return target.apply( |
| that, |
| args.concat(slice.call(arguments)) |
| ); |
| } |
| }; |
| |
| var boundLength = Math.max(0, target.length - args.length); |
| var boundArgs = []; |
| for (var i = 0; i < boundLength; i++) { |
| boundArgs.push('$' + i); |
| } |
| |
| bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder); |
| |
| if (target.prototype) { |
| var Empty = function Empty() {}; |
| Empty.prototype = target.prototype; |
| bound.prototype = new Empty(); |
| Empty.prototype = null; |
| } |
| |
| return bound; |
| }; |
| |
| },{}],8:[function(require,module,exports){ |
| 'use strict'; |
| |
| var implementation = require('./implementation'); |
| |
| module.exports = Function.prototype.bind || implementation; |
| |
| },{"./implementation":7}],9:[function(require,module,exports){ |
| 'use strict'; |
| |
| /* globals |
| AggregateError, |
| Atomics, |
| FinalizationRegistry, |
| SharedArrayBuffer, |
| WeakRef, |
| */ |
| |
| var undefined; |
| |
| var $SyntaxError = SyntaxError; |
| var $Function = Function; |
| var $TypeError = TypeError; |
| |
| // eslint-disable-next-line consistent-return |
| var getEvalledConstructor = function (expressionSyntax) { |
| try { |
| // eslint-disable-next-line no-new-func |
| return Function('"use strict"; return (' + expressionSyntax + ').constructor;')(); |
| } catch (e) {} |
| }; |
| |
| var $gOPD = Object.getOwnPropertyDescriptor; |
| if ($gOPD) { |
| try { |
| $gOPD({}, ''); |
| } catch (e) { |
| $gOPD = null; // this is IE 8, which has a broken gOPD |
| } |
| } |
| |
| var throwTypeError = function () { |
| throw new $TypeError(); |
| }; |
| var ThrowTypeError = $gOPD |
| ? (function () { |
| try { |
| // eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties |
| arguments.callee; // IE 8 does not throw here |
| return throwTypeError; |
| } catch (calleeThrows) { |
| try { |
| // IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '') |
| return $gOPD(arguments, 'callee').get; |
| } catch (gOPDthrows) { |
| return throwTypeError; |
| } |
| } |
| }()) |
| : throwTypeError; |
| |
| var hasSymbols = require('has-symbols')(); |
| |
| var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto |
| |
| var asyncGenFunction = getEvalledConstructor('async function* () {}'); |
| var asyncGenFunctionPrototype = asyncGenFunction ? asyncGenFunction.prototype : undefined; |
| var asyncGenPrototype = asyncGenFunctionPrototype ? asyncGenFunctionPrototype.prototype : undefined; |
| |
| var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array); |
| |
| var INTRINSICS = { |
| '%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError, |
| '%Array%': Array, |
| '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer, |
| '%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined, |
| '%AsyncFromSyncIteratorPrototype%': undefined, |
| '%AsyncFunction%': getEvalledConstructor('async function () {}'), |
| '%AsyncGenerator%': asyncGenFunctionPrototype, |
| '%AsyncGeneratorFunction%': asyncGenFunction, |
| '%AsyncIteratorPrototype%': asyncGenPrototype ? getProto(asyncGenPrototype) : undefined, |
| '%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics, |
| '%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt, |
| '%Boolean%': Boolean, |
| '%DataView%': typeof DataView === 'undefined' ? undefined : DataView, |
| '%Date%': Date, |
| '%decodeURI%': decodeURI, |
| '%decodeURIComponent%': decodeURIComponent, |
| '%encodeURI%': encodeURI, |
| '%encodeURIComponent%': encodeURIComponent, |
| '%Error%': Error, |
| '%eval%': eval, // eslint-disable-line no-eval |
| '%EvalError%': EvalError, |
| '%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array, |
| '%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array, |
| '%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry, |
| '%Function%': $Function, |
| '%GeneratorFunction%': getEvalledConstructor('function* () {}'), |
| '%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array, |
| '%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array, |
| '%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array, |
| '%isFinite%': isFinite, |
| '%isNaN%': isNaN, |
| '%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined, |
| '%JSON%': typeof JSON === 'object' ? JSON : undefined, |
| '%Map%': typeof Map === 'undefined' ? undefined : Map, |
| '%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()), |
| '%Math%': Math, |
| '%Number%': Number, |
| '%Object%': Object, |
| '%parseFloat%': parseFloat, |
| '%parseInt%': parseInt, |
| '%Promise%': typeof Promise === 'undefined' ? undefined : Promise, |
| '%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy, |
| '%RangeError%': RangeError, |
| '%ReferenceError%': ReferenceError, |
| '%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect, |
| '%RegExp%': RegExp, |
| '%Set%': typeof Set === 'undefined' ? undefined : Set, |
| '%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()), |
| '%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer, |
| '%String%': String, |
| '%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined, |
| '%Symbol%': hasSymbols ? Symbol : undefined, |
| '%SyntaxError%': $SyntaxError, |
| '%ThrowTypeError%': ThrowTypeError, |
| '%TypedArray%': TypedArray, |
| '%TypeError%': $TypeError, |
| '%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array, |
| '%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray, |
| '%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array, |
| '%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array, |
| '%URIError%': URIError, |
| '%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap, |
| '%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef, |
| '%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet |
| }; |
| |
| var LEGACY_ALIASES = { |
| '%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'], |
| '%ArrayPrototype%': ['Array', 'prototype'], |
| '%ArrayProto_entries%': ['Array', 'prototype', 'entries'], |
| '%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'], |
| '%ArrayProto_keys%': ['Array', 'prototype', 'keys'], |
| '%ArrayProto_values%': ['Array', 'prototype', 'values'], |
| '%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'], |
| '%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'], |
| '%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'], |
| '%BooleanPrototype%': ['Boolean', 'prototype'], |
| '%DataViewPrototype%': ['DataView', 'prototype'], |
| '%DatePrototype%': ['Date', 'prototype'], |
| '%ErrorPrototype%': ['Error', 'prototype'], |
| '%EvalErrorPrototype%': ['EvalError', 'prototype'], |
| '%Float32ArrayPrototype%': ['Float32Array', 'prototype'], |
| '%Float64ArrayPrototype%': ['Float64Array', 'prototype'], |
| '%FunctionPrototype%': ['Function', 'prototype'], |
| '%Generator%': ['GeneratorFunction', 'prototype'], |
| '%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'], |
| '%Int8ArrayPrototype%': ['Int8Array', 'prototype'], |
| '%Int16ArrayPrototype%': ['Int16Array', 'prototype'], |
| '%Int32ArrayPrototype%': ['Int32Array', 'prototype'], |
| '%JSONParse%': ['JSON', 'parse'], |
| '%JSONStringify%': ['JSON', 'stringify'], |
| '%MapPrototype%': ['Map', 'prototype'], |
| '%NumberPrototype%': ['Number', 'prototype'], |
| '%ObjectPrototype%': ['Object', 'prototype'], |
| '%ObjProto_toString%': ['Object', 'prototype', 'toString'], |
| '%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'], |
| '%PromisePrototype%': ['Promise', 'prototype'], |
| '%PromiseProto_then%': ['Promise', 'prototype', 'then'], |
| '%Promise_all%': ['Promise', 'all'], |
| '%Promise_reject%': ['Promise', 'reject'], |
| '%Promise_resolve%': ['Promise', 'resolve'], |
| '%RangeErrorPrototype%': ['RangeError', 'prototype'], |
| '%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'], |
| '%RegExpPrototype%': ['RegExp', 'prototype'], |
| '%SetPrototype%': ['Set', 'prototype'], |
| '%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'], |
| '%StringPrototype%': ['String', 'prototype'], |
| '%SymbolPrototype%': ['Symbol', 'prototype'], |
| '%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'], |
| '%TypedArrayPrototype%': ['TypedArray', 'prototype'], |
| '%TypeErrorPrototype%': ['TypeError', 'prototype'], |
| '%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'], |
| '%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'], |
| '%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'], |
| '%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'], |
| '%URIErrorPrototype%': ['URIError', 'prototype'], |
| '%WeakMapPrototype%': ['WeakMap', 'prototype'], |
| '%WeakSetPrototype%': ['WeakSet', 'prototype'] |
| }; |
| |
| var bind = require('function-bind'); |
| var hasOwn = require('has'); |
| var $concat = bind.call(Function.call, Array.prototype.concat); |
| var $spliceApply = bind.call(Function.apply, Array.prototype.splice); |
| var $replace = bind.call(Function.call, String.prototype.replace); |
| |
| /* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */ |
| var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g; |
| var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */ |
| var stringToPath = function stringToPath(string) { |
| var result = []; |
| $replace(string, rePropName, function (match, number, quote, subString) { |
| result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match; |
| }); |
| return result; |
| }; |
| /* end adaptation */ |
| |
| var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) { |
| var intrinsicName = name; |
| var alias; |
| if (hasOwn(LEGACY_ALIASES, intrinsicName)) { |
| alias = LEGACY_ALIASES[intrinsicName]; |
| intrinsicName = '%' + alias[0] + '%'; |
| } |
| |
| if (hasOwn(INTRINSICS, intrinsicName)) { |
| var value = INTRINSICS[intrinsicName]; |
| if (typeof value === 'undefined' && !allowMissing) { |
| throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!'); |
| } |
| |
| return { |
| alias: alias, |
| name: intrinsicName, |
| value: value |
| }; |
| } |
| |
| throw new $SyntaxError('intrinsic ' + name + ' does not exist!'); |
| }; |
| |
| module.exports = function GetIntrinsic(name, allowMissing) { |
| if (typeof name !== 'string' || name.length === 0) { |
| throw new $TypeError('intrinsic name must be a non-empty string'); |
| } |
| if (arguments.length > 1 && typeof allowMissing !== 'boolean') { |
| throw new $TypeError('"allowMissing" argument must be a boolean'); |
| } |
| |
| var parts = stringToPath(name); |
| var intrinsicBaseName = parts.length > 0 ? parts[0] : ''; |
| |
| var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing); |
| var intrinsicRealName = intrinsic.name; |
| var value = intrinsic.value; |
| var skipFurtherCaching = false; |
| |
| var alias = intrinsic.alias; |
| if (alias) { |
| intrinsicBaseName = alias[0]; |
| $spliceApply(parts, $concat([0, 1], alias)); |
| } |
| |
| for (var i = 1, isOwn = true; i < parts.length; i += 1) { |
| var part = parts[i]; |
| if (part === 'constructor' || !isOwn) { |
| skipFurtherCaching = true; |
| } |
| |
| intrinsicBaseName += '.' + part; |
| intrinsicRealName = '%' + intrinsicBaseName + '%'; |
| |
| if (hasOwn(INTRINSICS, intrinsicRealName)) { |
| value = INTRINSICS[intrinsicRealName]; |
| } else if (value != null) { |
| if ($gOPD && (i + 1) >= parts.length) { |
| var desc = $gOPD(value, part); |
| isOwn = !!desc; |
| |
| if (!allowMissing && !(part in value)) { |
| throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.'); |
| } |
| // By convention, when a data property is converted to an accessor |
| // property to emulate a data property that does not suffer from |
| // the override mistake, that accessor's getter is marked with |
| // an `originalValue` property. Here, when we detect this, we |
| // uphold the illusion by pretending to see that original data |
| // property, i.e., returning the value rather than the getter |
| // itself. |
| if (isOwn && 'get' in desc && !('originalValue' in desc.get)) { |
| value = desc.get; |
| } else { |
| value = value[part]; |
| } |
| } else { |
| isOwn = hasOwn(value, part); |
| value = value[part]; |
| } |
| |
| if (isOwn && !skipFurtherCaching) { |
| INTRINSICS[intrinsicRealName] = value; |
| } |
| } |
| } |
| return value; |
| }; |
| |
| },{"function-bind":8,"has":12,"has-symbols":10}],10:[function(require,module,exports){ |
| (function (global){(function (){ |
| 'use strict'; |
| |
| var origSymbol = global.Symbol; |
| var hasSymbolSham = require('./shams'); |
| |
| module.exports = function hasNativeSymbols() { |
| if (typeof origSymbol !== 'function') { return false; } |
| if (typeof Symbol !== 'function') { return false; } |
| if (typeof origSymbol('foo') !== 'symbol') { return false; } |
| if (typeof Symbol('bar') !== 'symbol') { return false; } |
| |
| return hasSymbolSham(); |
| }; |
| |
| }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
| },{"./shams":11}],11:[function(require,module,exports){ |
| 'use strict'; |
| |
| /* eslint complexity: [2, 18], max-statements: [2, 33] */ |
| module.exports = function hasSymbols() { |
| if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; } |
| if (typeof Symbol.iterator === 'symbol') { return true; } |
| |
| var obj = {}; |
| var sym = Symbol('test'); |
| var symObj = Object(sym); |
| if (typeof sym === 'string') { return false; } |
| |
| if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; } |
| if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; } |
| |
| // temp disabled per https://github.com/ljharb/object.assign/issues/17 |
| // if (sym instanceof Symbol) { return false; } |
| // temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4 |
| // if (!(symObj instanceof Symbol)) { return false; } |
| |
| // if (typeof Symbol.prototype.toString !== 'function') { return false; } |
| // if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; } |
| |
| var symVal = 42; |
| obj[sym] = symVal; |
| for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax |
| if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; } |
| |
| if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; } |
| |
| var syms = Object.getOwnPropertySymbols(obj); |
| if (syms.length !== 1 || syms[0] !== sym) { return false; } |
| |
| if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; } |
| |
| if (typeof Object.getOwnPropertyDescriptor === 'function') { |
| var descriptor = Object.getOwnPropertyDescriptor(obj, sym); |
| if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; } |
| } |
| |
| return true; |
| }; |
| |
| },{}],12:[function(require,module,exports){ |
| 'use strict'; |
| |
| var bind = require('function-bind'); |
| |
| module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty); |
| |
| },{"function-bind":8}],13:[function(require,module,exports){ |
| 'use strict'; |
| |
| var keysShim; |
| if (!Object.keys) { |
| // modified from https://github.com/es-shims/es5-shim |
| var has = Object.prototype.hasOwnProperty; |
| var toStr = Object.prototype.toString; |
| var isArgs = require('./isArguments'); // eslint-disable-line global-require |
| var isEnumerable = Object.prototype.propertyIsEnumerable; |
| var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString'); |
| var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype'); |
| var dontEnums = [ |
| 'toString', |
| 'toLocaleString', |
| 'valueOf', |
| 'hasOwnProperty', |
| 'isPrototypeOf', |
| 'propertyIsEnumerable', |
| 'constructor' |
| ]; |
| 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 |
| }; |
| var hasAutomationEqualityBug = (function () { |
| /* global window */ |
| if (typeof window === 'undefined') { return false; } |
| for (var k in window) { |
| try { |
| if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') { |
| try { |
| equalsConstructorPrototype(window[k]); |
| } catch (e) { |
| return true; |
| } |
| } |
| } catch (e) { |
| return true; |
| } |
| } |
| return false; |
| }()); |
| var equalsConstructorPrototypeIfNotBuggy = function (o) { |
| /* global window */ |
| if (typeof window === 'undefined' || !hasAutomationEqualityBug) { |
| return equalsConstructorPrototype(o); |
| } |
| try { |
| return equalsConstructorPrototype(o); |
| } catch (e) { |
| return false; |
| } |
| }; |
| |
| keysShim = function keys(object) { |
| var isObject = object !== null && typeof object === 'object'; |
| var isFunction = toStr.call(object) === '[object Function]'; |
| var isArguments = isArgs(object); |
| var isString = isObject && toStr.call(object) === '[object String]'; |
| var theKeys = []; |
| |
| if (!isObject && !isFunction && !isArguments) { |
| throw new TypeError('Object.keys called on a non-object'); |
| } |
| |
| var skipProto = hasProtoEnumBug && isFunction; |
| if (isString && object.length > 0 && !has.call(object, 0)) { |
| for (var i = 0; i < object.length; ++i) { |
| theKeys.push(String(i)); |
| } |
| } |
| |
| if (isArguments && object.length > 0) { |
| for (var j = 0; j < object.length; ++j) { |
| theKeys.push(String(j)); |
| } |
| } else { |
| for (var name in object) { |
| if (!(skipProto && name === 'prototype') && has.call(object, name)) { |
| theKeys.push(String(name)); |
| } |
| } |
| } |
| |
| if (hasDontEnumBug) { |
| var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object); |
| |
| for (var k = 0; k < dontEnums.length; ++k) { |
| if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) { |
| theKeys.push(dontEnums[k]); |
| } |
| } |
| } |
| return theKeys; |
| }; |
| } |
| module.exports = keysShim; |
| |
| },{"./isArguments":15}],14:[function(require,module,exports){ |
| 'use strict'; |
| |
| var slice = Array.prototype.slice; |
| var isArgs = require('./isArguments'); |
| |
| var origKeys = Object.keys; |
| var keysShim = origKeys ? function keys(o) { return origKeys(o); } : require('./implementation'); |
| |
| var originalKeys = Object.keys; |
| |
| keysShim.shim = function shimObjectKeys() { |
| if (Object.keys) { |
| var keysWorksWithArguments = (function () { |
| // Safari 5.0 bug |
| var args = Object.keys(arguments); |
| return args && args.length === arguments.length; |
| }(1, 2)); |
| if (!keysWorksWithArguments) { |
| Object.keys = function keys(object) { // eslint-disable-line func-name-matching |
| if (isArgs(object)) { |
| return originalKeys(slice.call(object)); |
| } |
| return originalKeys(object); |
| }; |
| } |
| } else { |
| Object.keys = keysShim; |
| } |
| return Object.keys || keysShim; |
| }; |
| |
| module.exports = keysShim; |
| |
| },{"./implementation":13,"./isArguments":15}],15:[function(require,module,exports){ |
| 'use strict'; |
| |
| var toStr = Object.prototype.toString; |
| |
| module.exports = function isArguments(value) { |
| var str = toStr.call(value); |
| var isArgs = str === '[object Arguments]'; |
| if (!isArgs) { |
| isArgs = str !== '[object Array]' && |
| value !== null && |
| typeof value === 'object' && |
| typeof value.length === 'number' && |
| value.length >= 0 && |
| toStr.call(value.callee) === '[object Function]'; |
| } |
| return isArgs; |
| }; |
| |
| },{}],16:[function(require,module,exports){ |
| 'use strict'; |
| |
| var implementation = require('./implementation'); |
| |
| var lacksProperEnumerationOrder = function () { |
| if (!Object.assign) { |
| return false; |
| } |
| /* |
| * v8, specifically in node 4.x, has a bug with incorrect property enumeration order |
| * note: this does not detect the bug unless there's 20 characters |
| */ |
| var str = 'abcdefghijklmnopqrst'; |
| var letters = str.split(''); |
| var map = {}; |
| for (var i = 0; i < letters.length; ++i) { |
| map[letters[i]] = letters[i]; |
| } |
| var obj = Object.assign({}, map); |
| var actual = ''; |
| for (var k in obj) { |
| actual += k; |
| } |
| return str !== actual; |
| }; |
| |
| var assignHasPendingExceptions = function () { |
| if (!Object.assign || !Object.preventExtensions) { |
| return false; |
| } |
| /* |
| * 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'; |
| } |
| return false; |
| }; |
| |
| module.exports = function getPolyfill() { |
| if (!Object.assign) { |
| return implementation; |
| } |
| if (lacksProperEnumerationOrder()) { |
| return implementation; |
| } |
| if (assignHasPendingExceptions()) { |
| return implementation; |
| } |
| return Object.assign; |
| }; |
| |
| },{"./implementation":2}],17:[function(require,module,exports){ |
| 'use strict'; |
| |
| var define = require('define-properties'); |
| var getPolyfill = require('./polyfill'); |
| |
| module.exports = function shimAssign() { |
| var polyfill = getPolyfill(); |
| define( |
| Object, |
| { assign: polyfill }, |
| { assign: function () { return Object.assign !== polyfill; } } |
| ); |
| return polyfill; |
| }; |
| |
| },{"./polyfill":16,"define-properties":6}]},{},[1]); |