mirror of
https://github.com/DanielnetoDotCom/YouPHPTube
synced 2025-10-03 01:39:24 +02:00
2652 lines
No EOL
117 KiB
JavaScript
2652 lines
No EOL
117 KiB
JavaScript
/*! @silvermine/videojs-airplay 2023-11-15 v1.3.0 */
|
|
|
|
(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) {
|
|
var isCallable = require("../internals/is-callable");
|
|
var tryToString = require("../internals/try-to-string");
|
|
var $TypeError = TypeError;
|
|
module.exports = function(argument) {
|
|
if (isCallable(argument)) return argument;
|
|
throw $TypeError(tryToString(argument) + " is not a function");
|
|
};
|
|
}, {
|
|
"../internals/is-callable": 49,
|
|
"../internals/try-to-string": 93
|
|
} ],
|
|
2: [ function(require, module, exports) {
|
|
var isConstructor = require("../internals/is-constructor");
|
|
var tryToString = require("../internals/try-to-string");
|
|
var $TypeError = TypeError;
|
|
module.exports = function(argument) {
|
|
if (isConstructor(argument)) return argument;
|
|
throw $TypeError(tryToString(argument) + " is not a constructor");
|
|
};
|
|
}, {
|
|
"../internals/is-constructor": 50,
|
|
"../internals/try-to-string": 93
|
|
} ],
|
|
3: [ function(require, module, exports) {
|
|
var isObject = require("../internals/is-object");
|
|
var $String = String;
|
|
var $TypeError = TypeError;
|
|
module.exports = function(argument) {
|
|
if (isObject(argument)) return argument;
|
|
throw $TypeError($String(argument) + " is not an object");
|
|
};
|
|
}, {
|
|
"../internals/is-object": 54
|
|
} ],
|
|
4: [ function(require, module, exports) {
|
|
var toIndexedObject = require("../internals/to-indexed-object");
|
|
var toAbsoluteIndex = require("../internals/to-absolute-index");
|
|
var lengthOfArrayLike = require("../internals/length-of-array-like");
|
|
var createMethod = function(IS_INCLUDES) {
|
|
return function($this, el, fromIndex) {
|
|
var O = toIndexedObject($this);
|
|
var length = lengthOfArrayLike(O);
|
|
var index = toAbsoluteIndex(fromIndex, length);
|
|
var value;
|
|
if (IS_INCLUDES && el != el) while (length > index) {
|
|
value = O[index++];
|
|
if (value != value) return true;
|
|
} else for (;length > index; index++) {
|
|
if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
|
|
}
|
|
return !IS_INCLUDES && -1;
|
|
};
|
|
};
|
|
module.exports = {
|
|
includes: createMethod(true),
|
|
indexOf: createMethod(false)
|
|
};
|
|
}, {
|
|
"../internals/length-of-array-like": 57,
|
|
"../internals/to-absolute-index": 84,
|
|
"../internals/to-indexed-object": 85
|
|
} ],
|
|
5: [ function(require, module, exports) {
|
|
var bind = require("../internals/function-bind-context");
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var IndexedObject = require("../internals/indexed-object");
|
|
var toObject = require("../internals/to-object");
|
|
var lengthOfArrayLike = require("../internals/length-of-array-like");
|
|
var arraySpeciesCreate = require("../internals/array-species-create");
|
|
var push = uncurryThis([].push);
|
|
var createMethod = function(TYPE) {
|
|
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 IS_FILTER_REJECT = TYPE == 7;
|
|
var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
|
|
return function($this, callbackfn, that, specificCreate) {
|
|
var O = toObject($this);
|
|
var self = IndexedObject(O);
|
|
var boundFunction = bind(callbackfn, that);
|
|
var length = lengthOfArrayLike(self);
|
|
var index = 0;
|
|
var create = specificCreate || arraySpeciesCreate;
|
|
var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? 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; else if (result) switch (TYPE) {
|
|
case 3:
|
|
return true;
|
|
|
|
case 5:
|
|
return value;
|
|
|
|
case 6:
|
|
return index;
|
|
|
|
case 2:
|
|
push(target, value);
|
|
} else switch (TYPE) {
|
|
case 4:
|
|
return false;
|
|
|
|
case 7:
|
|
push(target, value);
|
|
}
|
|
}
|
|
}
|
|
return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
|
|
};
|
|
};
|
|
module.exports = {
|
|
forEach: createMethod(0),
|
|
map: createMethod(1),
|
|
filter: createMethod(2),
|
|
some: createMethod(3),
|
|
every: createMethod(4),
|
|
find: createMethod(5),
|
|
findIndex: createMethod(6),
|
|
filterReject: createMethod(7)
|
|
};
|
|
}, {
|
|
"../internals/array-species-create": 9,
|
|
"../internals/function-bind-context": 30,
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/indexed-object": 45,
|
|
"../internals/length-of-array-like": 57,
|
|
"../internals/to-object": 88
|
|
} ],
|
|
6: [ function(require, module, exports) {
|
|
var toAbsoluteIndex = require("../internals/to-absolute-index");
|
|
var lengthOfArrayLike = require("../internals/length-of-array-like");
|
|
var createProperty = require("../internals/create-property");
|
|
var $Array = Array;
|
|
var max = Math.max;
|
|
module.exports = function(O, start, end) {
|
|
var length = lengthOfArrayLike(O);
|
|
var k = toAbsoluteIndex(start, length);
|
|
var fin = toAbsoluteIndex(end === undefined ? length : end, length);
|
|
var result = $Array(max(fin - k, 0));
|
|
for (var n = 0; k < fin; k++, n++) createProperty(result, n, O[k]);
|
|
result.length = n;
|
|
return result;
|
|
};
|
|
}, {
|
|
"../internals/create-property": 16,
|
|
"../internals/length-of-array-like": 57,
|
|
"../internals/to-absolute-index": 84
|
|
} ],
|
|
7: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
module.exports = uncurryThis([].slice);
|
|
}, {
|
|
"../internals/function-uncurry-this": 36
|
|
} ],
|
|
8: [ function(require, module, exports) {
|
|
var isArray = require("../internals/is-array");
|
|
var isConstructor = require("../internals/is-constructor");
|
|
var isObject = require("../internals/is-object");
|
|
var wellKnownSymbol = require("../internals/well-known-symbol");
|
|
var SPECIES = wellKnownSymbol("species");
|
|
var $Array = Array;
|
|
module.exports = function(originalArray) {
|
|
var C;
|
|
if (isArray(originalArray)) {
|
|
C = originalArray.constructor;
|
|
if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined; else if (isObject(C)) {
|
|
C = C[SPECIES];
|
|
if (C === null) C = undefined;
|
|
}
|
|
}
|
|
return C === undefined ? $Array : C;
|
|
};
|
|
}, {
|
|
"../internals/is-array": 48,
|
|
"../internals/is-constructor": 50,
|
|
"../internals/is-object": 54,
|
|
"../internals/well-known-symbol": 100
|
|
} ],
|
|
9: [ function(require, module, exports) {
|
|
var arraySpeciesConstructor = require("../internals/array-species-constructor");
|
|
module.exports = function(originalArray, length) {
|
|
return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
|
|
};
|
|
}, {
|
|
"../internals/array-species-constructor": 8
|
|
} ],
|
|
10: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var toString = uncurryThis({}.toString);
|
|
var stringSlice = uncurryThis("".slice);
|
|
module.exports = function(it) {
|
|
return stringSlice(toString(it), 8, -1);
|
|
};
|
|
}, {
|
|
"../internals/function-uncurry-this": 36
|
|
} ],
|
|
11: [ function(require, module, exports) {
|
|
var TO_STRING_TAG_SUPPORT = require("../internals/to-string-tag-support");
|
|
var isCallable = require("../internals/is-callable");
|
|
var classofRaw = require("../internals/classof-raw");
|
|
var wellKnownSymbol = require("../internals/well-known-symbol");
|
|
var TO_STRING_TAG = wellKnownSymbol("toStringTag");
|
|
var $Object = Object;
|
|
var CORRECT_ARGUMENTS = classofRaw(function() {
|
|
return arguments;
|
|
}()) == "Arguments";
|
|
var tryGet = function(it, key) {
|
|
try {
|
|
return it[key];
|
|
} catch (error) {}
|
|
};
|
|
module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function(it) {
|
|
var O, tag, result;
|
|
return it === undefined ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == "string" ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) == "Object" && isCallable(O.callee) ? "Arguments" : result;
|
|
};
|
|
}, {
|
|
"../internals/classof-raw": 10,
|
|
"../internals/is-callable": 49,
|
|
"../internals/to-string-tag-support": 91,
|
|
"../internals/well-known-symbol": 100
|
|
} ],
|
|
12: [ function(require, module, exports) {
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var ownKeys = require("../internals/own-keys");
|
|
var getOwnPropertyDescriptorModule = require("../internals/object-get-own-property-descriptor");
|
|
var definePropertyModule = require("../internals/object-define-property");
|
|
module.exports = function(target, source, exceptions) {
|
|
var keys = ownKeys(source);
|
|
var defineProperty = definePropertyModule.f;
|
|
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var key = keys[i];
|
|
if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
|
|
defineProperty(target, key, getOwnPropertyDescriptor(source, key));
|
|
}
|
|
}
|
|
};
|
|
}, {
|
|
"../internals/has-own-property": 41,
|
|
"../internals/object-define-property": 62,
|
|
"../internals/object-get-own-property-descriptor": 63,
|
|
"../internals/own-keys": 74
|
|
} ],
|
|
13: [ function(require, module, exports) {
|
|
var fails = require("../internals/fails");
|
|
module.exports = !fails(function() {
|
|
function F() {}
|
|
F.prototype.constructor = null;
|
|
return Object.getPrototypeOf(new F()) !== F.prototype;
|
|
});
|
|
}, {
|
|
"../internals/fails": 28
|
|
} ],
|
|
14: [ function(require, module, exports) {
|
|
var DESCRIPTORS = require("../internals/descriptors");
|
|
var definePropertyModule = require("../internals/object-define-property");
|
|
var createPropertyDescriptor = require("../internals/create-property-descriptor");
|
|
module.exports = DESCRIPTORS ? function(object, key, value) {
|
|
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
|
|
} : function(object, key, value) {
|
|
object[key] = value;
|
|
return object;
|
|
};
|
|
}, {
|
|
"../internals/create-property-descriptor": 15,
|
|
"../internals/descriptors": 21,
|
|
"../internals/object-define-property": 62
|
|
} ],
|
|
15: [ function(require, module, exports) {
|
|
module.exports = function(bitmap, value) {
|
|
return {
|
|
enumerable: !(bitmap & 1),
|
|
configurable: !(bitmap & 2),
|
|
writable: !(bitmap & 4),
|
|
value: value
|
|
};
|
|
};
|
|
}, {} ],
|
|
16: [ function(require, module, exports) {
|
|
"use strict";
|
|
var toPropertyKey = require("../internals/to-property-key");
|
|
var definePropertyModule = require("../internals/object-define-property");
|
|
var createPropertyDescriptor = require("../internals/create-property-descriptor");
|
|
module.exports = function(object, key, value) {
|
|
var propertyKey = toPropertyKey(key);
|
|
if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); else object[propertyKey] = value;
|
|
};
|
|
}, {
|
|
"../internals/create-property-descriptor": 15,
|
|
"../internals/object-define-property": 62,
|
|
"../internals/to-property-key": 90
|
|
} ],
|
|
17: [ function(require, module, exports) {
|
|
"use strict";
|
|
var anObject = require("../internals/an-object");
|
|
var ordinaryToPrimitive = require("../internals/ordinary-to-primitive");
|
|
var $TypeError = TypeError;
|
|
module.exports = function(hint) {
|
|
anObject(this);
|
|
if (hint === "string" || hint === "default") hint = "string"; else if (hint !== "number") throw $TypeError("Incorrect hint");
|
|
return ordinaryToPrimitive(this, hint);
|
|
};
|
|
}, {
|
|
"../internals/an-object": 3,
|
|
"../internals/ordinary-to-primitive": 73
|
|
} ],
|
|
18: [ function(require, module, exports) {
|
|
var makeBuiltIn = require("../internals/make-built-in");
|
|
var defineProperty = require("../internals/object-define-property");
|
|
module.exports = function(target, name, descriptor) {
|
|
if (descriptor.get) makeBuiltIn(descriptor.get, name, {
|
|
getter: true
|
|
});
|
|
if (descriptor.set) makeBuiltIn(descriptor.set, name, {
|
|
setter: true
|
|
});
|
|
return defineProperty.f(target, name, descriptor);
|
|
};
|
|
}, {
|
|
"../internals/make-built-in": 58,
|
|
"../internals/object-define-property": 62
|
|
} ],
|
|
19: [ function(require, module, exports) {
|
|
var isCallable = require("../internals/is-callable");
|
|
var definePropertyModule = require("../internals/object-define-property");
|
|
var makeBuiltIn = require("../internals/make-built-in");
|
|
var defineGlobalProperty = require("../internals/define-global-property");
|
|
module.exports = function(O, key, value, options) {
|
|
if (!options) options = {};
|
|
var simple = options.enumerable;
|
|
var name = options.name !== undefined ? options.name : key;
|
|
if (isCallable(value)) makeBuiltIn(value, name, options);
|
|
if (options.global) {
|
|
if (simple) O[key] = value; else defineGlobalProperty(key, value);
|
|
} else {
|
|
try {
|
|
if (!options.unsafe) delete O[key]; else if (O[key]) simple = true;
|
|
} catch (error) {}
|
|
if (simple) O[key] = value; else definePropertyModule.f(O, key, {
|
|
value: value,
|
|
enumerable: false,
|
|
configurable: !options.nonConfigurable,
|
|
writable: !options.nonWritable
|
|
});
|
|
}
|
|
return O;
|
|
};
|
|
}, {
|
|
"../internals/define-global-property": 20,
|
|
"../internals/is-callable": 49,
|
|
"../internals/make-built-in": 58,
|
|
"../internals/object-define-property": 62
|
|
} ],
|
|
20: [ function(require, module, exports) {
|
|
var global = require("../internals/global");
|
|
var defineProperty = Object.defineProperty;
|
|
module.exports = function(key, value) {
|
|
try {
|
|
defineProperty(global, key, {
|
|
value: value,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} catch (error) {
|
|
global[key] = value;
|
|
}
|
|
return value;
|
|
};
|
|
}, {
|
|
"../internals/global": 40
|
|
} ],
|
|
21: [ function(require, module, exports) {
|
|
var fails = require("../internals/fails");
|
|
module.exports = !fails(function() {
|
|
return Object.defineProperty({}, 1, {
|
|
get: function() {
|
|
return 7;
|
|
}
|
|
})[1] != 7;
|
|
});
|
|
}, {
|
|
"../internals/fails": 28
|
|
} ],
|
|
22: [ function(require, module, exports) {
|
|
var documentAll = typeof document == "object" && document.all;
|
|
var IS_HTMLDDA = typeof documentAll == "undefined" && documentAll !== undefined;
|
|
module.exports = {
|
|
all: documentAll,
|
|
IS_HTMLDDA: IS_HTMLDDA
|
|
};
|
|
}, {} ],
|
|
23: [ function(require, module, exports) {
|
|
var global = require("../internals/global");
|
|
var isObject = require("../internals/is-object");
|
|
var document = global.document;
|
|
var EXISTS = isObject(document) && isObject(document.createElement);
|
|
module.exports = function(it) {
|
|
return EXISTS ? document.createElement(it) : {};
|
|
};
|
|
}, {
|
|
"../internals/global": 40,
|
|
"../internals/is-object": 54
|
|
} ],
|
|
24: [ function(require, module, exports) {
|
|
module.exports = typeof navigator != "undefined" && String(navigator.userAgent) || "";
|
|
}, {} ],
|
|
25: [ function(require, module, exports) {
|
|
var global = require("../internals/global");
|
|
var userAgent = require("../internals/engine-user-agent");
|
|
var process = global.process;
|
|
var Deno = global.Deno;
|
|
var versions = process && process.versions || Deno && Deno.version;
|
|
var v8 = versions && versions.v8;
|
|
var match, version;
|
|
if (v8) {
|
|
match = v8.split(".");
|
|
version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
|
|
}
|
|
if (!version && userAgent) {
|
|
match = userAgent.match(/Edge\/(\d+)/);
|
|
if (!match || match[1] >= 74) {
|
|
match = userAgent.match(/Chrome\/(\d+)/);
|
|
if (match) version = +match[1];
|
|
}
|
|
}
|
|
module.exports = version;
|
|
}, {
|
|
"../internals/engine-user-agent": 24,
|
|
"../internals/global": 40
|
|
} ],
|
|
26: [ function(require, module, exports) {
|
|
module.exports = [ "constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf" ];
|
|
}, {} ],
|
|
27: [ function(require, module, exports) {
|
|
var global = require("../internals/global");
|
|
var getOwnPropertyDescriptor = require("../internals/object-get-own-property-descriptor").f;
|
|
var createNonEnumerableProperty = require("../internals/create-non-enumerable-property");
|
|
var defineBuiltIn = require("../internals/define-built-in");
|
|
var defineGlobalProperty = require("../internals/define-global-property");
|
|
var copyConstructorProperties = require("../internals/copy-constructor-properties");
|
|
var isForced = require("../internals/is-forced");
|
|
module.exports = 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;
|
|
} else if (STATIC) {
|
|
target = global[TARGET] || defineGlobalProperty(TARGET, {});
|
|
} else {
|
|
target = (global[TARGET] || {}).prototype;
|
|
}
|
|
if (target) for (key in source) {
|
|
sourceProperty = source[key];
|
|
if (options.dontCallGetSet) {
|
|
descriptor = getOwnPropertyDescriptor(target, key);
|
|
targetProperty = descriptor && descriptor.value;
|
|
} else targetProperty = target[key];
|
|
FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced);
|
|
if (!FORCED && targetProperty !== undefined) {
|
|
if (typeof sourceProperty == typeof targetProperty) continue;
|
|
copyConstructorProperties(sourceProperty, targetProperty);
|
|
}
|
|
if (options.sham || targetProperty && targetProperty.sham) {
|
|
createNonEnumerableProperty(sourceProperty, "sham", true);
|
|
}
|
|
defineBuiltIn(target, key, sourceProperty, options);
|
|
}
|
|
};
|
|
}, {
|
|
"../internals/copy-constructor-properties": 12,
|
|
"../internals/create-non-enumerable-property": 14,
|
|
"../internals/define-built-in": 19,
|
|
"../internals/define-global-property": 20,
|
|
"../internals/global": 40,
|
|
"../internals/is-forced": 52,
|
|
"../internals/object-get-own-property-descriptor": 63
|
|
} ],
|
|
28: [ function(require, module, exports) {
|
|
module.exports = function(exec) {
|
|
try {
|
|
return !!exec();
|
|
} catch (error) {
|
|
return true;
|
|
}
|
|
};
|
|
}, {} ],
|
|
29: [ function(require, module, exports) {
|
|
var NATIVE_BIND = require("../internals/function-bind-native");
|
|
var FunctionPrototype = Function.prototype;
|
|
var apply = FunctionPrototype.apply;
|
|
var call = FunctionPrototype.call;
|
|
module.exports = typeof Reflect == "object" && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function() {
|
|
return call.apply(apply, arguments);
|
|
});
|
|
}, {
|
|
"../internals/function-bind-native": 31
|
|
} ],
|
|
30: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this-clause");
|
|
var aCallable = require("../internals/a-callable");
|
|
var NATIVE_BIND = require("../internals/function-bind-native");
|
|
var bind = uncurryThis(uncurryThis.bind);
|
|
module.exports = function(fn, that) {
|
|
aCallable(fn);
|
|
return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function() {
|
|
return fn.apply(that, arguments);
|
|
};
|
|
};
|
|
}, {
|
|
"../internals/a-callable": 1,
|
|
"../internals/function-bind-native": 31,
|
|
"../internals/function-uncurry-this-clause": 35
|
|
} ],
|
|
31: [ function(require, module, exports) {
|
|
var fails = require("../internals/fails");
|
|
module.exports = !fails(function() {
|
|
var test = function() {}.bind();
|
|
return typeof test != "function" || test.hasOwnProperty("prototype");
|
|
});
|
|
}, {
|
|
"../internals/fails": 28
|
|
} ],
|
|
32: [ function(require, module, exports) {
|
|
"use strict";
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var aCallable = require("../internals/a-callable");
|
|
var isObject = require("../internals/is-object");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var arraySlice = require("../internals/array-slice");
|
|
var NATIVE_BIND = require("../internals/function-bind-native");
|
|
var $Function = Function;
|
|
var concat = uncurryThis([].concat);
|
|
var join = uncurryThis([].join);
|
|
var factories = {};
|
|
var construct = function(C, argsLength, args) {
|
|
if (!hasOwn(factories, argsLength)) {
|
|
for (var list = [], i = 0; i < argsLength; i++) list[i] = "a[" + i + "]";
|
|
factories[argsLength] = $Function("C,a", "return new C(" + join(list, ",") + ")");
|
|
}
|
|
return factories[argsLength](C, args);
|
|
};
|
|
module.exports = NATIVE_BIND ? $Function.bind : function bind(that) {
|
|
var F = aCallable(this);
|
|
var Prototype = F.prototype;
|
|
var partArgs = arraySlice(arguments, 1);
|
|
var boundFunction = function bound() {
|
|
var args = concat(partArgs, arraySlice(arguments));
|
|
return this instanceof boundFunction ? construct(F, args.length, args) : F.apply(that, args);
|
|
};
|
|
if (isObject(Prototype)) boundFunction.prototype = Prototype;
|
|
return boundFunction;
|
|
};
|
|
}, {
|
|
"../internals/a-callable": 1,
|
|
"../internals/array-slice": 7,
|
|
"../internals/function-bind-native": 31,
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/is-object": 54
|
|
} ],
|
|
33: [ function(require, module, exports) {
|
|
var NATIVE_BIND = require("../internals/function-bind-native");
|
|
var call = Function.prototype.call;
|
|
module.exports = NATIVE_BIND ? call.bind(call) : function() {
|
|
return call.apply(call, arguments);
|
|
};
|
|
}, {
|
|
"../internals/function-bind-native": 31
|
|
} ],
|
|
34: [ function(require, module, exports) {
|
|
var DESCRIPTORS = require("../internals/descriptors");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var FunctionPrototype = Function.prototype;
|
|
var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
|
|
var EXISTS = hasOwn(FunctionPrototype, "name");
|
|
var PROPER = EXISTS && function something() {}.name === "something";
|
|
var CONFIGURABLE = EXISTS && (!DESCRIPTORS || DESCRIPTORS && getDescriptor(FunctionPrototype, "name").configurable);
|
|
module.exports = {
|
|
EXISTS: EXISTS,
|
|
PROPER: PROPER,
|
|
CONFIGURABLE: CONFIGURABLE
|
|
};
|
|
}, {
|
|
"../internals/descriptors": 21,
|
|
"../internals/has-own-property": 41
|
|
} ],
|
|
35: [ function(require, module, exports) {
|
|
var classofRaw = require("../internals/classof-raw");
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
module.exports = function(fn) {
|
|
if (classofRaw(fn) === "Function") return uncurryThis(fn);
|
|
};
|
|
}, {
|
|
"../internals/classof-raw": 10,
|
|
"../internals/function-uncurry-this": 36
|
|
} ],
|
|
36: [ function(require, module, exports) {
|
|
var NATIVE_BIND = require("../internals/function-bind-native");
|
|
var FunctionPrototype = Function.prototype;
|
|
var call = FunctionPrototype.call;
|
|
var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
|
|
module.exports = NATIVE_BIND ? uncurryThisWithBind : function(fn) {
|
|
return function() {
|
|
return call.apply(fn, arguments);
|
|
};
|
|
};
|
|
}, {
|
|
"../internals/function-bind-native": 31
|
|
} ],
|
|
37: [ function(require, module, exports) {
|
|
var global = require("../internals/global");
|
|
var isCallable = require("../internals/is-callable");
|
|
var aFunction = function(argument) {
|
|
return isCallable(argument) ? argument : undefined;
|
|
};
|
|
module.exports = function(namespace, method) {
|
|
return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];
|
|
};
|
|
}, {
|
|
"../internals/global": 40,
|
|
"../internals/is-callable": 49
|
|
} ],
|
|
38: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var isArray = require("../internals/is-array");
|
|
var isCallable = require("../internals/is-callable");
|
|
var classof = require("../internals/classof-raw");
|
|
var toString = require("../internals/to-string");
|
|
var push = uncurryThis([].push);
|
|
module.exports = function(replacer) {
|
|
if (isCallable(replacer)) return replacer;
|
|
if (!isArray(replacer)) return;
|
|
var rawLength = replacer.length;
|
|
var keys = [];
|
|
for (var i = 0; i < rawLength; i++) {
|
|
var element = replacer[i];
|
|
if (typeof element == "string") push(keys, element); else if (typeof element == "number" || classof(element) == "Number" || classof(element) == "String") push(keys, toString(element));
|
|
}
|
|
var keysLength = keys.length;
|
|
var root = true;
|
|
return function(key, value) {
|
|
if (root) {
|
|
root = false;
|
|
return value;
|
|
}
|
|
if (isArray(this)) return value;
|
|
for (var j = 0; j < keysLength; j++) if (keys[j] === key) return value;
|
|
};
|
|
};
|
|
}, {
|
|
"../internals/classof-raw": 10,
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/is-array": 48,
|
|
"../internals/is-callable": 49,
|
|
"../internals/to-string": 92
|
|
} ],
|
|
39: [ function(require, module, exports) {
|
|
var aCallable = require("../internals/a-callable");
|
|
var isNullOrUndefined = require("../internals/is-null-or-undefined");
|
|
module.exports = function(V, P) {
|
|
var func = V[P];
|
|
return isNullOrUndefined(func) ? undefined : aCallable(func);
|
|
};
|
|
}, {
|
|
"../internals/a-callable": 1,
|
|
"../internals/is-null-or-undefined": 53
|
|
} ],
|
|
40: [ function(require, module, exports) {
|
|
(function(global) {
|
|
(function() {
|
|
var check = function(it) {
|
|
return it && it.Math == Math && it;
|
|
};
|
|
module.exports = check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || check(typeof self == "object" && self) || check(typeof global == "object" && global) || function() {
|
|
return this;
|
|
}() || Function("return this")();
|
|
}).call(this);
|
|
}).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
|
|
}, {} ],
|
|
41: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var toObject = require("../internals/to-object");
|
|
var hasOwnProperty = uncurryThis({}.hasOwnProperty);
|
|
module.exports = Object.hasOwn || function hasOwn(it, key) {
|
|
return hasOwnProperty(toObject(it), key);
|
|
};
|
|
}, {
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/to-object": 88
|
|
} ],
|
|
42: [ function(require, module, exports) {
|
|
module.exports = {};
|
|
}, {} ],
|
|
43: [ function(require, module, exports) {
|
|
var getBuiltIn = require("../internals/get-built-in");
|
|
module.exports = getBuiltIn("document", "documentElement");
|
|
}, {
|
|
"../internals/get-built-in": 37
|
|
} ],
|
|
44: [ function(require, module, exports) {
|
|
var DESCRIPTORS = require("../internals/descriptors");
|
|
var fails = require("../internals/fails");
|
|
var createElement = require("../internals/document-create-element");
|
|
module.exports = !DESCRIPTORS && !fails(function() {
|
|
return Object.defineProperty(createElement("div"), "a", {
|
|
get: function() {
|
|
return 7;
|
|
}
|
|
}).a != 7;
|
|
});
|
|
}, {
|
|
"../internals/descriptors": 21,
|
|
"../internals/document-create-element": 23,
|
|
"../internals/fails": 28
|
|
} ],
|
|
45: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var fails = require("../internals/fails");
|
|
var classof = require("../internals/classof-raw");
|
|
var $Object = Object;
|
|
var split = uncurryThis("".split);
|
|
module.exports = fails(function() {
|
|
return !$Object("z").propertyIsEnumerable(0);
|
|
}) ? function(it) {
|
|
return classof(it) == "String" ? split(it, "") : $Object(it);
|
|
} : $Object;
|
|
}, {
|
|
"../internals/classof-raw": 10,
|
|
"../internals/fails": 28,
|
|
"../internals/function-uncurry-this": 36
|
|
} ],
|
|
46: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var isCallable = require("../internals/is-callable");
|
|
var store = require("../internals/shared-store");
|
|
var functionToString = uncurryThis(Function.toString);
|
|
if (!isCallable(store.inspectSource)) {
|
|
store.inspectSource = function(it) {
|
|
return functionToString(it);
|
|
};
|
|
}
|
|
module.exports = store.inspectSource;
|
|
}, {
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/is-callable": 49,
|
|
"../internals/shared-store": 79
|
|
} ],
|
|
47: [ function(require, module, exports) {
|
|
var NATIVE_WEAK_MAP = require("../internals/weak-map-basic-detection");
|
|
var global = require("../internals/global");
|
|
var isObject = require("../internals/is-object");
|
|
var createNonEnumerableProperty = require("../internals/create-non-enumerable-property");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var shared = require("../internals/shared-store");
|
|
var sharedKey = require("../internals/shared-key");
|
|
var hiddenKeys = require("../internals/hidden-keys");
|
|
var OBJECT_ALREADY_INITIALIZED = "Object already initialized";
|
|
var TypeError = global.TypeError;
|
|
var WeakMap = global.WeakMap;
|
|
var set, get, has;
|
|
var enforce = function(it) {
|
|
return has(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 (NATIVE_WEAK_MAP || shared.state) {
|
|
var store = shared.state || (shared.state = new WeakMap());
|
|
store.get = store.get;
|
|
store.has = store.has;
|
|
store.set = store.set;
|
|
set = function(it, metadata) {
|
|
if (store.has(it)) throw TypeError(OBJECT_ALREADY_INITIALIZED);
|
|
metadata.facade = it;
|
|
store.set(it, metadata);
|
|
return metadata;
|
|
};
|
|
get = function(it) {
|
|
return store.get(it) || {};
|
|
};
|
|
has = function(it) {
|
|
return store.has(it);
|
|
};
|
|
} else {
|
|
var STATE = sharedKey("state");
|
|
hiddenKeys[STATE] = true;
|
|
set = function(it, metadata) {
|
|
if (hasOwn(it, STATE)) throw TypeError(OBJECT_ALREADY_INITIALIZED);
|
|
metadata.facade = it;
|
|
createNonEnumerableProperty(it, STATE, metadata);
|
|
return metadata;
|
|
};
|
|
get = function(it) {
|
|
return hasOwn(it, STATE) ? it[STATE] : {};
|
|
};
|
|
has = function(it) {
|
|
return hasOwn(it, STATE);
|
|
};
|
|
}
|
|
module.exports = {
|
|
set: set,
|
|
get: get,
|
|
has: has,
|
|
enforce: enforce,
|
|
getterFor: getterFor
|
|
};
|
|
}, {
|
|
"../internals/create-non-enumerable-property": 14,
|
|
"../internals/global": 40,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/hidden-keys": 42,
|
|
"../internals/is-object": 54,
|
|
"../internals/shared-key": 78,
|
|
"../internals/shared-store": 79,
|
|
"../internals/weak-map-basic-detection": 97
|
|
} ],
|
|
48: [ function(require, module, exports) {
|
|
var classof = require("../internals/classof-raw");
|
|
module.exports = Array.isArray || function isArray(argument) {
|
|
return classof(argument) == "Array";
|
|
};
|
|
}, {
|
|
"../internals/classof-raw": 10
|
|
} ],
|
|
49: [ function(require, module, exports) {
|
|
var $documentAll = require("../internals/document-all");
|
|
var documentAll = $documentAll.all;
|
|
module.exports = $documentAll.IS_HTMLDDA ? function(argument) {
|
|
return typeof argument == "function" || argument === documentAll;
|
|
} : function(argument) {
|
|
return typeof argument == "function";
|
|
};
|
|
}, {
|
|
"../internals/document-all": 22
|
|
} ],
|
|
50: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var fails = require("../internals/fails");
|
|
var isCallable = require("../internals/is-callable");
|
|
var classof = require("../internals/classof");
|
|
var getBuiltIn = require("../internals/get-built-in");
|
|
var inspectSource = require("../internals/inspect-source");
|
|
var noop = function() {};
|
|
var empty = [];
|
|
var construct = getBuiltIn("Reflect", "construct");
|
|
var constructorRegExp = /^\s*(?:class|function)\b/;
|
|
var exec = uncurryThis(constructorRegExp.exec);
|
|
var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
|
|
var isConstructorModern = function isConstructor(argument) {
|
|
if (!isCallable(argument)) return false;
|
|
try {
|
|
construct(noop, empty, argument);
|
|
return true;
|
|
} catch (error) {
|
|
return false;
|
|
}
|
|
};
|
|
var isConstructorLegacy = function isConstructor(argument) {
|
|
if (!isCallable(argument)) return false;
|
|
switch (classof(argument)) {
|
|
case "AsyncFunction":
|
|
case "GeneratorFunction":
|
|
case "AsyncGeneratorFunction":
|
|
return false;
|
|
}
|
|
try {
|
|
return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
|
|
} catch (error) {
|
|
return true;
|
|
}
|
|
};
|
|
isConstructorLegacy.sham = true;
|
|
module.exports = !construct || fails(function() {
|
|
var called;
|
|
return isConstructorModern(isConstructorModern.call) || !isConstructorModern(Object) || !isConstructorModern(function() {
|
|
called = true;
|
|
}) || called;
|
|
}) ? isConstructorLegacy : isConstructorModern;
|
|
}, {
|
|
"../internals/classof": 11,
|
|
"../internals/fails": 28,
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/get-built-in": 37,
|
|
"../internals/inspect-source": 46,
|
|
"../internals/is-callable": 49
|
|
} ],
|
|
51: [ function(require, module, exports) {
|
|
var hasOwn = require("../internals/has-own-property");
|
|
module.exports = function(descriptor) {
|
|
return descriptor !== undefined && (hasOwn(descriptor, "value") || hasOwn(descriptor, "writable"));
|
|
};
|
|
}, {
|
|
"../internals/has-own-property": 41
|
|
} ],
|
|
52: [ function(require, module, exports) {
|
|
var fails = require("../internals/fails");
|
|
var isCallable = require("../internals/is-callable");
|
|
var replacement = /#|\.prototype\./;
|
|
var isForced = function(feature, detection) {
|
|
var value = data[normalize(feature)];
|
|
return value == POLYFILL ? true : value == NATIVE ? false : isCallable(detection) ? 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";
|
|
module.exports = isForced;
|
|
}, {
|
|
"../internals/fails": 28,
|
|
"../internals/is-callable": 49
|
|
} ],
|
|
53: [ function(require, module, exports) {
|
|
module.exports = function(it) {
|
|
return it === null || it === undefined;
|
|
};
|
|
}, {} ],
|
|
54: [ function(require, module, exports) {
|
|
var isCallable = require("../internals/is-callable");
|
|
var $documentAll = require("../internals/document-all");
|
|
var documentAll = $documentAll.all;
|
|
module.exports = $documentAll.IS_HTMLDDA ? function(it) {
|
|
return typeof it == "object" ? it !== null : isCallable(it) || it === documentAll;
|
|
} : function(it) {
|
|
return typeof it == "object" ? it !== null : isCallable(it);
|
|
};
|
|
}, {
|
|
"../internals/document-all": 22,
|
|
"../internals/is-callable": 49
|
|
} ],
|
|
55: [ function(require, module, exports) {
|
|
module.exports = false;
|
|
}, {} ],
|
|
56: [ function(require, module, exports) {
|
|
var getBuiltIn = require("../internals/get-built-in");
|
|
var isCallable = require("../internals/is-callable");
|
|
var isPrototypeOf = require("../internals/object-is-prototype-of");
|
|
var USE_SYMBOL_AS_UID = require("../internals/use-symbol-as-uid");
|
|
var $Object = Object;
|
|
module.exports = USE_SYMBOL_AS_UID ? function(it) {
|
|
return typeof it == "symbol";
|
|
} : function(it) {
|
|
var $Symbol = getBuiltIn("Symbol");
|
|
return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
|
|
};
|
|
}, {
|
|
"../internals/get-built-in": 37,
|
|
"../internals/is-callable": 49,
|
|
"../internals/object-is-prototype-of": 68,
|
|
"../internals/use-symbol-as-uid": 95
|
|
} ],
|
|
57: [ function(require, module, exports) {
|
|
var toLength = require("../internals/to-length");
|
|
module.exports = function(obj) {
|
|
return toLength(obj.length);
|
|
};
|
|
}, {
|
|
"../internals/to-length": 87
|
|
} ],
|
|
58: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var fails = require("../internals/fails");
|
|
var isCallable = require("../internals/is-callable");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var DESCRIPTORS = require("../internals/descriptors");
|
|
var CONFIGURABLE_FUNCTION_NAME = require("../internals/function-name").CONFIGURABLE;
|
|
var inspectSource = require("../internals/inspect-source");
|
|
var InternalStateModule = require("../internals/internal-state");
|
|
var enforceInternalState = InternalStateModule.enforce;
|
|
var getInternalState = InternalStateModule.get;
|
|
var $String = String;
|
|
var defineProperty = Object.defineProperty;
|
|
var stringSlice = uncurryThis("".slice);
|
|
var replace = uncurryThis("".replace);
|
|
var join = uncurryThis([].join);
|
|
var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function() {
|
|
return defineProperty(function() {}, "length", {
|
|
value: 8
|
|
}).length !== 8;
|
|
});
|
|
var TEMPLATE = String(String).split("String");
|
|
var makeBuiltIn = module.exports = function(value, name, options) {
|
|
if (stringSlice($String(name), 0, 7) === "Symbol(") {
|
|
name = "[" + replace($String(name), /^Symbol\(([^)]*)\)/, "$1") + "]";
|
|
}
|
|
if (options && options.getter) name = "get " + name;
|
|
if (options && options.setter) name = "set " + name;
|
|
if (!hasOwn(value, "name") || CONFIGURABLE_FUNCTION_NAME && value.name !== name) {
|
|
if (DESCRIPTORS) defineProperty(value, "name", {
|
|
value: name,
|
|
configurable: true
|
|
}); else value.name = name;
|
|
}
|
|
if (CONFIGURABLE_LENGTH && options && hasOwn(options, "arity") && value.length !== options.arity) {
|
|
defineProperty(value, "length", {
|
|
value: options.arity
|
|
});
|
|
}
|
|
try {
|
|
if (options && hasOwn(options, "constructor") && options.constructor) {
|
|
if (DESCRIPTORS) defineProperty(value, "prototype", {
|
|
writable: false
|
|
});
|
|
} else if (value.prototype) value.prototype = undefined;
|
|
} catch (error) {}
|
|
var state = enforceInternalState(value);
|
|
if (!hasOwn(state, "source")) {
|
|
state.source = join(TEMPLATE, typeof name == "string" ? name : "");
|
|
}
|
|
return value;
|
|
};
|
|
Function.prototype.toString = makeBuiltIn(function toString() {
|
|
return isCallable(this) && getInternalState(this).source || inspectSource(this);
|
|
}, "toString");
|
|
}, {
|
|
"../internals/descriptors": 21,
|
|
"../internals/fails": 28,
|
|
"../internals/function-name": 34,
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/inspect-source": 46,
|
|
"../internals/internal-state": 47,
|
|
"../internals/is-callable": 49
|
|
} ],
|
|
59: [ function(require, module, exports) {
|
|
var ceil = Math.ceil;
|
|
var floor = Math.floor;
|
|
module.exports = Math.trunc || function trunc(x) {
|
|
var n = +x;
|
|
return (n > 0 ? floor : ceil)(n);
|
|
};
|
|
}, {} ],
|
|
60: [ function(require, module, exports) {
|
|
var anObject = require("../internals/an-object");
|
|
var definePropertiesModule = require("../internals/object-define-properties");
|
|
var enumBugKeys = require("../internals/enum-bug-keys");
|
|
var hiddenKeys = require("../internals/hidden-keys");
|
|
var html = require("../internals/html");
|
|
var documentCreateElement = require("../internals/document-create-element");
|
|
var sharedKey = require("../internals/shared-key");
|
|
var GT = ">";
|
|
var LT = "<";
|
|
var PROTOTYPE = "prototype";
|
|
var SCRIPT = "script";
|
|
var IE_PROTO = sharedKey("IE_PROTO");
|
|
var EmptyConstructor = function() {};
|
|
var scriptTag = function(content) {
|
|
return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT;
|
|
};
|
|
var NullProtoObjectViaActiveX = function(activeXDocument) {
|
|
activeXDocument.write(scriptTag(""));
|
|
activeXDocument.close();
|
|
var temp = activeXDocument.parentWindow.Object;
|
|
activeXDocument = null;
|
|
return temp;
|
|
};
|
|
var NullProtoObjectViaIFrame = function() {
|
|
var iframe = documentCreateElement("iframe");
|
|
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(scriptTag("document.F=Object"));
|
|
iframeDocument.close();
|
|
return iframeDocument.F;
|
|
};
|
|
var activeXDocument;
|
|
var NullProtoObject = function() {
|
|
try {
|
|
activeXDocument = new ActiveXObject("htmlfile");
|
|
} catch (error) {}
|
|
NullProtoObject = typeof document != "undefined" ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument);
|
|
var length = enumBugKeys.length;
|
|
while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
|
|
return NullProtoObject();
|
|
};
|
|
hiddenKeys[IE_PROTO] = true;
|
|
module.exports = Object.create || function create(O, Properties) {
|
|
var result;
|
|
if (O !== null) {
|
|
EmptyConstructor[PROTOTYPE] = anObject(O);
|
|
result = new EmptyConstructor();
|
|
EmptyConstructor[PROTOTYPE] = null;
|
|
result[IE_PROTO] = O;
|
|
} else result = NullProtoObject();
|
|
return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
|
|
};
|
|
}, {
|
|
"../internals/an-object": 3,
|
|
"../internals/document-create-element": 23,
|
|
"../internals/enum-bug-keys": 26,
|
|
"../internals/hidden-keys": 42,
|
|
"../internals/html": 43,
|
|
"../internals/object-define-properties": 61,
|
|
"../internals/shared-key": 78
|
|
} ],
|
|
61: [ function(require, module, exports) {
|
|
var DESCRIPTORS = require("../internals/descriptors");
|
|
var V8_PROTOTYPE_DEFINE_BUG = require("../internals/v8-prototype-define-bug");
|
|
var definePropertyModule = require("../internals/object-define-property");
|
|
var anObject = require("../internals/an-object");
|
|
var toIndexedObject = require("../internals/to-indexed-object");
|
|
var objectKeys = require("../internals/object-keys");
|
|
exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
|
|
anObject(O);
|
|
var props = toIndexedObject(Properties);
|
|
var keys = objectKeys(Properties);
|
|
var length = keys.length;
|
|
var index = 0;
|
|
var key;
|
|
while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
|
|
return O;
|
|
};
|
|
}, {
|
|
"../internals/an-object": 3,
|
|
"../internals/descriptors": 21,
|
|
"../internals/object-define-property": 62,
|
|
"../internals/object-keys": 70,
|
|
"../internals/to-indexed-object": 85,
|
|
"../internals/v8-prototype-define-bug": 96
|
|
} ],
|
|
62: [ function(require, module, exports) {
|
|
var DESCRIPTORS = require("../internals/descriptors");
|
|
var IE8_DOM_DEFINE = require("../internals/ie8-dom-define");
|
|
var V8_PROTOTYPE_DEFINE_BUG = require("../internals/v8-prototype-define-bug");
|
|
var anObject = require("../internals/an-object");
|
|
var toPropertyKey = require("../internals/to-property-key");
|
|
var $TypeError = TypeError;
|
|
var $defineProperty = Object.defineProperty;
|
|
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
var ENUMERABLE = "enumerable";
|
|
var CONFIGURABLE = "configurable";
|
|
var WRITABLE = "writable";
|
|
exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
|
|
anObject(O);
|
|
P = toPropertyKey(P);
|
|
anObject(Attributes);
|
|
if (typeof O === "function" && P === "prototype" && "value" in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
|
|
var current = $getOwnPropertyDescriptor(O, P);
|
|
if (current && current[WRITABLE]) {
|
|
O[P] = Attributes.value;
|
|
Attributes = {
|
|
configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
|
|
enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
|
|
writable: false
|
|
};
|
|
}
|
|
}
|
|
return $defineProperty(O, P, Attributes);
|
|
} : $defineProperty : function defineProperty(O, P, Attributes) {
|
|
anObject(O);
|
|
P = toPropertyKey(P);
|
|
anObject(Attributes);
|
|
if (IE8_DOM_DEFINE) try {
|
|
return $defineProperty(O, P, Attributes);
|
|
} catch (error) {}
|
|
if ("get" in Attributes || "set" in Attributes) throw $TypeError("Accessors not supported");
|
|
if ("value" in Attributes) O[P] = Attributes.value;
|
|
return O;
|
|
};
|
|
}, {
|
|
"../internals/an-object": 3,
|
|
"../internals/descriptors": 21,
|
|
"../internals/ie8-dom-define": 44,
|
|
"../internals/to-property-key": 90,
|
|
"../internals/v8-prototype-define-bug": 96
|
|
} ],
|
|
63: [ function(require, module, exports) {
|
|
var DESCRIPTORS = require("../internals/descriptors");
|
|
var call = require("../internals/function-call");
|
|
var propertyIsEnumerableModule = require("../internals/object-property-is-enumerable");
|
|
var createPropertyDescriptor = require("../internals/create-property-descriptor");
|
|
var toIndexedObject = require("../internals/to-indexed-object");
|
|
var toPropertyKey = require("../internals/to-property-key");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var IE8_DOM_DEFINE = require("../internals/ie8-dom-define");
|
|
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
|
|
O = toIndexedObject(O);
|
|
P = toPropertyKey(P);
|
|
if (IE8_DOM_DEFINE) try {
|
|
return $getOwnPropertyDescriptor(O, P);
|
|
} catch (error) {}
|
|
if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
|
|
};
|
|
}, {
|
|
"../internals/create-property-descriptor": 15,
|
|
"../internals/descriptors": 21,
|
|
"../internals/function-call": 33,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/ie8-dom-define": 44,
|
|
"../internals/object-property-is-enumerable": 71,
|
|
"../internals/to-indexed-object": 85,
|
|
"../internals/to-property-key": 90
|
|
} ],
|
|
64: [ function(require, module, exports) {
|
|
var classof = require("../internals/classof-raw");
|
|
var toIndexedObject = require("../internals/to-indexed-object");
|
|
var $getOwnPropertyNames = require("../internals/object-get-own-property-names").f;
|
|
var arraySlice = require("../internals/array-slice-simple");
|
|
var windowNames = typeof window == "object" && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : [];
|
|
var getWindowNames = function(it) {
|
|
try {
|
|
return $getOwnPropertyNames(it);
|
|
} catch (error) {
|
|
return arraySlice(windowNames);
|
|
}
|
|
};
|
|
module.exports.f = function getOwnPropertyNames(it) {
|
|
return windowNames && classof(it) == "Window" ? getWindowNames(it) : $getOwnPropertyNames(toIndexedObject(it));
|
|
};
|
|
}, {
|
|
"../internals/array-slice-simple": 6,
|
|
"../internals/classof-raw": 10,
|
|
"../internals/object-get-own-property-names": 65,
|
|
"../internals/to-indexed-object": 85
|
|
} ],
|
|
65: [ function(require, module, exports) {
|
|
var internalObjectKeys = require("../internals/object-keys-internal");
|
|
var enumBugKeys = require("../internals/enum-bug-keys");
|
|
var hiddenKeys = enumBugKeys.concat("length", "prototype");
|
|
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
|
|
return internalObjectKeys(O, hiddenKeys);
|
|
};
|
|
}, {
|
|
"../internals/enum-bug-keys": 26,
|
|
"../internals/object-keys-internal": 69
|
|
} ],
|
|
66: [ function(require, module, exports) {
|
|
exports.f = Object.getOwnPropertySymbols;
|
|
}, {} ],
|
|
67: [ function(require, module, exports) {
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var isCallable = require("../internals/is-callable");
|
|
var toObject = require("../internals/to-object");
|
|
var sharedKey = require("../internals/shared-key");
|
|
var CORRECT_PROTOTYPE_GETTER = require("../internals/correct-prototype-getter");
|
|
var IE_PROTO = sharedKey("IE_PROTO");
|
|
var $Object = Object;
|
|
var ObjectPrototype = $Object.prototype;
|
|
module.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function(O) {
|
|
var object = toObject(O);
|
|
if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
|
|
var constructor = object.constructor;
|
|
if (isCallable(constructor) && object instanceof constructor) {
|
|
return constructor.prototype;
|
|
}
|
|
return object instanceof $Object ? ObjectPrototype : null;
|
|
};
|
|
}, {
|
|
"../internals/correct-prototype-getter": 13,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/is-callable": 49,
|
|
"../internals/shared-key": 78,
|
|
"../internals/to-object": 88
|
|
} ],
|
|
68: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
module.exports = uncurryThis({}.isPrototypeOf);
|
|
}, {
|
|
"../internals/function-uncurry-this": 36
|
|
} ],
|
|
69: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var toIndexedObject = require("../internals/to-indexed-object");
|
|
var indexOf = require("../internals/array-includes").indexOf;
|
|
var hiddenKeys = require("../internals/hidden-keys");
|
|
var push = uncurryThis([].push);
|
|
module.exports = function(object, names) {
|
|
var O = toIndexedObject(object);
|
|
var i = 0;
|
|
var result = [];
|
|
var key;
|
|
for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
|
|
while (names.length > i) if (hasOwn(O, key = names[i++])) {
|
|
~indexOf(result, key) || push(result, key);
|
|
}
|
|
return result;
|
|
};
|
|
}, {
|
|
"../internals/array-includes": 4,
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/hidden-keys": 42,
|
|
"../internals/to-indexed-object": 85
|
|
} ],
|
|
70: [ function(require, module, exports) {
|
|
var internalObjectKeys = require("../internals/object-keys-internal");
|
|
var enumBugKeys = require("../internals/enum-bug-keys");
|
|
module.exports = Object.keys || function keys(O) {
|
|
return internalObjectKeys(O, enumBugKeys);
|
|
};
|
|
}, {
|
|
"../internals/enum-bug-keys": 26,
|
|
"../internals/object-keys-internal": 69
|
|
} ],
|
|
71: [ function(require, module, exports) {
|
|
"use strict";
|
|
var $propertyIsEnumerable = {}.propertyIsEnumerable;
|
|
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({
|
|
1: 2
|
|
}, 1);
|
|
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
|
|
var descriptor = getOwnPropertyDescriptor(this, V);
|
|
return !!descriptor && descriptor.enumerable;
|
|
} : $propertyIsEnumerable;
|
|
}, {} ],
|
|
72: [ function(require, module, exports) {
|
|
"use strict";
|
|
var TO_STRING_TAG_SUPPORT = require("../internals/to-string-tag-support");
|
|
var classof = require("../internals/classof");
|
|
module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {
|
|
return "[object " + classof(this) + "]";
|
|
};
|
|
}, {
|
|
"../internals/classof": 11,
|
|
"../internals/to-string-tag-support": 91
|
|
} ],
|
|
73: [ function(require, module, exports) {
|
|
var call = require("../internals/function-call");
|
|
var isCallable = require("../internals/is-callable");
|
|
var isObject = require("../internals/is-object");
|
|
var $TypeError = TypeError;
|
|
module.exports = function(input, pref) {
|
|
var fn, val;
|
|
if (pref === "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
|
|
if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
|
|
if (pref !== "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
|
|
throw $TypeError("Can't convert object to primitive value");
|
|
};
|
|
}, {
|
|
"../internals/function-call": 33,
|
|
"../internals/is-callable": 49,
|
|
"../internals/is-object": 54
|
|
} ],
|
|
74: [ function(require, module, exports) {
|
|
var getBuiltIn = require("../internals/get-built-in");
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var getOwnPropertyNamesModule = require("../internals/object-get-own-property-names");
|
|
var getOwnPropertySymbolsModule = require("../internals/object-get-own-property-symbols");
|
|
var anObject = require("../internals/an-object");
|
|
var concat = uncurryThis([].concat);
|
|
module.exports = getBuiltIn("Reflect", "ownKeys") || function ownKeys(it) {
|
|
var keys = getOwnPropertyNamesModule.f(anObject(it));
|
|
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
|
|
return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
|
|
};
|
|
}, {
|
|
"../internals/an-object": 3,
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/get-built-in": 37,
|
|
"../internals/object-get-own-property-names": 65,
|
|
"../internals/object-get-own-property-symbols": 66
|
|
} ],
|
|
75: [ function(require, module, exports) {
|
|
var global = require("../internals/global");
|
|
module.exports = global;
|
|
}, {
|
|
"../internals/global": 40
|
|
} ],
|
|
76: [ function(require, module, exports) {
|
|
var isNullOrUndefined = require("../internals/is-null-or-undefined");
|
|
var $TypeError = TypeError;
|
|
module.exports = function(it) {
|
|
if (isNullOrUndefined(it)) throw $TypeError("Can't call method on " + it);
|
|
return it;
|
|
};
|
|
}, {
|
|
"../internals/is-null-or-undefined": 53
|
|
} ],
|
|
77: [ function(require, module, exports) {
|
|
var defineProperty = require("../internals/object-define-property").f;
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var wellKnownSymbol = require("../internals/well-known-symbol");
|
|
var TO_STRING_TAG = wellKnownSymbol("toStringTag");
|
|
module.exports = function(target, TAG, STATIC) {
|
|
if (target && !STATIC) target = target.prototype;
|
|
if (target && !hasOwn(target, TO_STRING_TAG)) {
|
|
defineProperty(target, TO_STRING_TAG, {
|
|
configurable: true,
|
|
value: TAG
|
|
});
|
|
}
|
|
};
|
|
}, {
|
|
"../internals/has-own-property": 41,
|
|
"../internals/object-define-property": 62,
|
|
"../internals/well-known-symbol": 100
|
|
} ],
|
|
78: [ function(require, module, exports) {
|
|
var shared = require("../internals/shared");
|
|
var uid = require("../internals/uid");
|
|
var keys = shared("keys");
|
|
module.exports = function(key) {
|
|
return keys[key] || (keys[key] = uid(key));
|
|
};
|
|
}, {
|
|
"../internals/shared": 80,
|
|
"../internals/uid": 94
|
|
} ],
|
|
79: [ function(require, module, exports) {
|
|
var global = require("../internals/global");
|
|
var defineGlobalProperty = require("../internals/define-global-property");
|
|
var SHARED = "__core-js_shared__";
|
|
var store = global[SHARED] || defineGlobalProperty(SHARED, {});
|
|
module.exports = store;
|
|
}, {
|
|
"../internals/define-global-property": 20,
|
|
"../internals/global": 40
|
|
} ],
|
|
80: [ function(require, module, exports) {
|
|
var IS_PURE = require("../internals/is-pure");
|
|
var store = require("../internals/shared-store");
|
|
(module.exports = function(key, value) {
|
|
return store[key] || (store[key] = value !== undefined ? value : {});
|
|
})("versions", []).push({
|
|
version: "3.28.0",
|
|
mode: IS_PURE ? "pure" : "global",
|
|
copyright: "© 2014-2023 Denis Pushkarev (zloirock.ru)",
|
|
license: "https://github.com/zloirock/core-js/blob/v3.28.0/LICENSE",
|
|
source: "https://github.com/zloirock/core-js"
|
|
});
|
|
}, {
|
|
"../internals/is-pure": 55,
|
|
"../internals/shared-store": 79
|
|
} ],
|
|
81: [ function(require, module, exports) {
|
|
var V8_VERSION = require("../internals/engine-v8-version");
|
|
var fails = require("../internals/fails");
|
|
module.exports = !!Object.getOwnPropertySymbols && !fails(function() {
|
|
var symbol = Symbol();
|
|
return !String(symbol) || !(Object(symbol) instanceof Symbol) || !Symbol.sham && V8_VERSION && V8_VERSION < 41;
|
|
});
|
|
}, {
|
|
"../internals/engine-v8-version": 25,
|
|
"../internals/fails": 28
|
|
} ],
|
|
82: [ function(require, module, exports) {
|
|
var call = require("../internals/function-call");
|
|
var getBuiltIn = require("../internals/get-built-in");
|
|
var wellKnownSymbol = require("../internals/well-known-symbol");
|
|
var defineBuiltIn = require("../internals/define-built-in");
|
|
module.exports = function() {
|
|
var Symbol = getBuiltIn("Symbol");
|
|
var SymbolPrototype = Symbol && Symbol.prototype;
|
|
var valueOf = SymbolPrototype && SymbolPrototype.valueOf;
|
|
var TO_PRIMITIVE = wellKnownSymbol("toPrimitive");
|
|
if (SymbolPrototype && !SymbolPrototype[TO_PRIMITIVE]) {
|
|
defineBuiltIn(SymbolPrototype, TO_PRIMITIVE, function(hint) {
|
|
return call(valueOf, this);
|
|
}, {
|
|
arity: 1
|
|
});
|
|
}
|
|
};
|
|
}, {
|
|
"../internals/define-built-in": 19,
|
|
"../internals/function-call": 33,
|
|
"../internals/get-built-in": 37,
|
|
"../internals/well-known-symbol": 100
|
|
} ],
|
|
83: [ function(require, module, exports) {
|
|
var NATIVE_SYMBOL = require("../internals/symbol-constructor-detection");
|
|
module.exports = NATIVE_SYMBOL && !!Symbol["for"] && !!Symbol.keyFor;
|
|
}, {
|
|
"../internals/symbol-constructor-detection": 81
|
|
} ],
|
|
84: [ function(require, module, exports) {
|
|
var toIntegerOrInfinity = require("../internals/to-integer-or-infinity");
|
|
var max = Math.max;
|
|
var min = Math.min;
|
|
module.exports = function(index, length) {
|
|
var integer = toIntegerOrInfinity(index);
|
|
return integer < 0 ? max(integer + length, 0) : min(integer, length);
|
|
};
|
|
}, {
|
|
"../internals/to-integer-or-infinity": 86
|
|
} ],
|
|
85: [ function(require, module, exports) {
|
|
var IndexedObject = require("../internals/indexed-object");
|
|
var requireObjectCoercible = require("../internals/require-object-coercible");
|
|
module.exports = function(it) {
|
|
return IndexedObject(requireObjectCoercible(it));
|
|
};
|
|
}, {
|
|
"../internals/indexed-object": 45,
|
|
"../internals/require-object-coercible": 76
|
|
} ],
|
|
86: [ function(require, module, exports) {
|
|
var trunc = require("../internals/math-trunc");
|
|
module.exports = function(argument) {
|
|
var number = +argument;
|
|
return number !== number || number === 0 ? 0 : trunc(number);
|
|
};
|
|
}, {
|
|
"../internals/math-trunc": 59
|
|
} ],
|
|
87: [ function(require, module, exports) {
|
|
var toIntegerOrInfinity = require("../internals/to-integer-or-infinity");
|
|
var min = Math.min;
|
|
module.exports = function(argument) {
|
|
return argument > 0 ? min(toIntegerOrInfinity(argument), 9007199254740991) : 0;
|
|
};
|
|
}, {
|
|
"../internals/to-integer-or-infinity": 86
|
|
} ],
|
|
88: [ function(require, module, exports) {
|
|
var requireObjectCoercible = require("../internals/require-object-coercible");
|
|
var $Object = Object;
|
|
module.exports = function(argument) {
|
|
return $Object(requireObjectCoercible(argument));
|
|
};
|
|
}, {
|
|
"../internals/require-object-coercible": 76
|
|
} ],
|
|
89: [ function(require, module, exports) {
|
|
var call = require("../internals/function-call");
|
|
var isObject = require("../internals/is-object");
|
|
var isSymbol = require("../internals/is-symbol");
|
|
var getMethod = require("../internals/get-method");
|
|
var ordinaryToPrimitive = require("../internals/ordinary-to-primitive");
|
|
var wellKnownSymbol = require("../internals/well-known-symbol");
|
|
var $TypeError = TypeError;
|
|
var TO_PRIMITIVE = wellKnownSymbol("toPrimitive");
|
|
module.exports = function(input, pref) {
|
|
if (!isObject(input) || isSymbol(input)) return input;
|
|
var exoticToPrim = getMethod(input, TO_PRIMITIVE);
|
|
var result;
|
|
if (exoticToPrim) {
|
|
if (pref === undefined) pref = "default";
|
|
result = call(exoticToPrim, input, pref);
|
|
if (!isObject(result) || isSymbol(result)) return result;
|
|
throw $TypeError("Can't convert object to primitive value");
|
|
}
|
|
if (pref === undefined) pref = "number";
|
|
return ordinaryToPrimitive(input, pref);
|
|
};
|
|
}, {
|
|
"../internals/function-call": 33,
|
|
"../internals/get-method": 39,
|
|
"../internals/is-object": 54,
|
|
"../internals/is-symbol": 56,
|
|
"../internals/ordinary-to-primitive": 73,
|
|
"../internals/well-known-symbol": 100
|
|
} ],
|
|
90: [ function(require, module, exports) {
|
|
var toPrimitive = require("../internals/to-primitive");
|
|
var isSymbol = require("../internals/is-symbol");
|
|
module.exports = function(argument) {
|
|
var key = toPrimitive(argument, "string");
|
|
return isSymbol(key) ? key : key + "";
|
|
};
|
|
}, {
|
|
"../internals/is-symbol": 56,
|
|
"../internals/to-primitive": 89
|
|
} ],
|
|
91: [ function(require, module, exports) {
|
|
var wellKnownSymbol = require("../internals/well-known-symbol");
|
|
var TO_STRING_TAG = wellKnownSymbol("toStringTag");
|
|
var test = {};
|
|
test[TO_STRING_TAG] = "z";
|
|
module.exports = String(test) === "[object z]";
|
|
}, {
|
|
"../internals/well-known-symbol": 100
|
|
} ],
|
|
92: [ function(require, module, exports) {
|
|
var classof = require("../internals/classof");
|
|
var $String = String;
|
|
module.exports = function(argument) {
|
|
if (classof(argument) === "Symbol") throw TypeError("Cannot convert a Symbol value to a string");
|
|
return $String(argument);
|
|
};
|
|
}, {
|
|
"../internals/classof": 11
|
|
} ],
|
|
93: [ function(require, module, exports) {
|
|
var $String = String;
|
|
module.exports = function(argument) {
|
|
try {
|
|
return $String(argument);
|
|
} catch (error) {
|
|
return "Object";
|
|
}
|
|
};
|
|
}, {} ],
|
|
94: [ function(require, module, exports) {
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var id = 0;
|
|
var postfix = Math.random();
|
|
var toString = uncurryThis(1..toString);
|
|
module.exports = function(key) {
|
|
return "Symbol(" + (key === undefined ? "" : key) + ")_" + toString(++id + postfix, 36);
|
|
};
|
|
}, {
|
|
"../internals/function-uncurry-this": 36
|
|
} ],
|
|
95: [ function(require, module, exports) {
|
|
var NATIVE_SYMBOL = require("../internals/symbol-constructor-detection");
|
|
module.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == "symbol";
|
|
}, {
|
|
"../internals/symbol-constructor-detection": 81
|
|
} ],
|
|
96: [ function(require, module, exports) {
|
|
var DESCRIPTORS = require("../internals/descriptors");
|
|
var fails = require("../internals/fails");
|
|
module.exports = DESCRIPTORS && fails(function() {
|
|
return Object.defineProperty(function() {}, "prototype", {
|
|
value: 42,
|
|
writable: false
|
|
}).prototype != 42;
|
|
});
|
|
}, {
|
|
"../internals/descriptors": 21,
|
|
"../internals/fails": 28
|
|
} ],
|
|
97: [ function(require, module, exports) {
|
|
var global = require("../internals/global");
|
|
var isCallable = require("../internals/is-callable");
|
|
var WeakMap = global.WeakMap;
|
|
module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));
|
|
}, {
|
|
"../internals/global": 40,
|
|
"../internals/is-callable": 49
|
|
} ],
|
|
98: [ function(require, module, exports) {
|
|
var path = require("../internals/path");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var wrappedWellKnownSymbolModule = require("../internals/well-known-symbol-wrapped");
|
|
var defineProperty = require("../internals/object-define-property").f;
|
|
module.exports = function(NAME) {
|
|
var Symbol = path.Symbol || (path.Symbol = {});
|
|
if (!hasOwn(Symbol, NAME)) defineProperty(Symbol, NAME, {
|
|
value: wrappedWellKnownSymbolModule.f(NAME)
|
|
});
|
|
};
|
|
}, {
|
|
"../internals/has-own-property": 41,
|
|
"../internals/object-define-property": 62,
|
|
"../internals/path": 75,
|
|
"../internals/well-known-symbol-wrapped": 99
|
|
} ],
|
|
99: [ function(require, module, exports) {
|
|
var wellKnownSymbol = require("../internals/well-known-symbol");
|
|
exports.f = wellKnownSymbol;
|
|
}, {
|
|
"../internals/well-known-symbol": 100
|
|
} ],
|
|
100: [ function(require, module, exports) {
|
|
var global = require("../internals/global");
|
|
var shared = require("../internals/shared");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var uid = require("../internals/uid");
|
|
var NATIVE_SYMBOL = require("../internals/symbol-constructor-detection");
|
|
var USE_SYMBOL_AS_UID = require("../internals/use-symbol-as-uid");
|
|
var Symbol = global.Symbol;
|
|
var WellKnownSymbolsStore = shared("wks");
|
|
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol["for"] || Symbol : Symbol && Symbol.withoutSetter || uid;
|
|
module.exports = function(name) {
|
|
if (!hasOwn(WellKnownSymbolsStore, name)) {
|
|
WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name) ? Symbol[name] : createWellKnownSymbol("Symbol." + name);
|
|
}
|
|
return WellKnownSymbolsStore[name];
|
|
};
|
|
}, {
|
|
"../internals/global": 40,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/shared": 80,
|
|
"../internals/symbol-constructor-detection": 81,
|
|
"../internals/uid": 94,
|
|
"../internals/use-symbol-as-uid": 95
|
|
} ],
|
|
101: [ function(require, module, exports) {
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var defineBuiltIn = require("../internals/define-built-in");
|
|
var dateToPrimitive = require("../internals/date-to-primitive");
|
|
var wellKnownSymbol = require("../internals/well-known-symbol");
|
|
var TO_PRIMITIVE = wellKnownSymbol("toPrimitive");
|
|
var DatePrototype = Date.prototype;
|
|
if (!hasOwn(DatePrototype, TO_PRIMITIVE)) {
|
|
defineBuiltIn(DatePrototype, TO_PRIMITIVE, dateToPrimitive);
|
|
}
|
|
}, {
|
|
"../internals/date-to-primitive": 17,
|
|
"../internals/define-built-in": 19,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/well-known-symbol": 100
|
|
} ],
|
|
102: [ function(require, module, exports) {
|
|
var $ = require("../internals/export");
|
|
var getBuiltIn = require("../internals/get-built-in");
|
|
var apply = require("../internals/function-apply");
|
|
var call = require("../internals/function-call");
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var fails = require("../internals/fails");
|
|
var isCallable = require("../internals/is-callable");
|
|
var isSymbol = require("../internals/is-symbol");
|
|
var arraySlice = require("../internals/array-slice");
|
|
var getReplacerFunction = require("../internals/get-json-replacer-function");
|
|
var NATIVE_SYMBOL = require("../internals/symbol-constructor-detection");
|
|
var $String = String;
|
|
var $stringify = getBuiltIn("JSON", "stringify");
|
|
var exec = uncurryThis(/./.exec);
|
|
var charAt = uncurryThis("".charAt);
|
|
var charCodeAt = uncurryThis("".charCodeAt);
|
|
var replace = uncurryThis("".replace);
|
|
var numberToString = uncurryThis(1..toString);
|
|
var tester = /[\uD800-\uDFFF]/g;
|
|
var low = /^[\uD800-\uDBFF]$/;
|
|
var hi = /^[\uDC00-\uDFFF]$/;
|
|
var WRONG_SYMBOLS_CONVERSION = !NATIVE_SYMBOL || fails(function() {
|
|
var symbol = getBuiltIn("Symbol")();
|
|
return $stringify([ symbol ]) != "[null]" || $stringify({
|
|
a: symbol
|
|
}) != "{}" || $stringify(Object(symbol)) != "{}";
|
|
});
|
|
var ILL_FORMED_UNICODE = fails(function() {
|
|
return $stringify("\udf06\ud834") !== '"\\udf06\\ud834"' || $stringify("\udead") !== '"\\udead"';
|
|
});
|
|
var stringifyWithSymbolsFix = function(it, replacer) {
|
|
var args = arraySlice(arguments);
|
|
var $replacer = getReplacerFunction(replacer);
|
|
if (!isCallable($replacer) && (it === undefined || isSymbol(it))) return;
|
|
args[1] = function(key, value) {
|
|
if (isCallable($replacer)) value = call($replacer, this, $String(key), value);
|
|
if (!isSymbol(value)) return value;
|
|
};
|
|
return apply($stringify, null, args);
|
|
};
|
|
var fixIllFormed = function(match, offset, string) {
|
|
var prev = charAt(string, offset - 1);
|
|
var next = charAt(string, offset + 1);
|
|
if (exec(low, match) && !exec(hi, next) || exec(hi, match) && !exec(low, prev)) {
|
|
return "\\u" + numberToString(charCodeAt(match, 0), 16);
|
|
}
|
|
return match;
|
|
};
|
|
if ($stringify) {
|
|
$({
|
|
target: "JSON",
|
|
stat: true,
|
|
arity: 3,
|
|
forced: WRONG_SYMBOLS_CONVERSION || ILL_FORMED_UNICODE
|
|
}, {
|
|
stringify: function stringify(it, replacer, space) {
|
|
var args = arraySlice(arguments);
|
|
var result = apply(WRONG_SYMBOLS_CONVERSION ? stringifyWithSymbolsFix : $stringify, null, args);
|
|
return ILL_FORMED_UNICODE && typeof result == "string" ? replace(result, tester, fixIllFormed) : result;
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
"../internals/array-slice": 7,
|
|
"../internals/export": 27,
|
|
"../internals/fails": 28,
|
|
"../internals/function-apply": 29,
|
|
"../internals/function-call": 33,
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/get-built-in": 37,
|
|
"../internals/get-json-replacer-function": 38,
|
|
"../internals/is-callable": 49,
|
|
"../internals/is-symbol": 56,
|
|
"../internals/symbol-constructor-detection": 81
|
|
} ],
|
|
103: [ function(require, module, exports) {
|
|
var $ = require("../internals/export");
|
|
var NATIVE_SYMBOL = require("../internals/symbol-constructor-detection");
|
|
var fails = require("../internals/fails");
|
|
var getOwnPropertySymbolsModule = require("../internals/object-get-own-property-symbols");
|
|
var toObject = require("../internals/to-object");
|
|
var FORCED = !NATIVE_SYMBOL || fails(function() {
|
|
getOwnPropertySymbolsModule.f(1);
|
|
});
|
|
$({
|
|
target: "Object",
|
|
stat: true,
|
|
forced: FORCED
|
|
}, {
|
|
getOwnPropertySymbols: function getOwnPropertySymbols(it) {
|
|
var $getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
|
|
return $getOwnPropertySymbols ? $getOwnPropertySymbols(toObject(it)) : [];
|
|
}
|
|
});
|
|
}, {
|
|
"../internals/export": 27,
|
|
"../internals/fails": 28,
|
|
"../internals/object-get-own-property-symbols": 66,
|
|
"../internals/symbol-constructor-detection": 81,
|
|
"../internals/to-object": 88
|
|
} ],
|
|
104: [ function(require, module, exports) {
|
|
var TO_STRING_TAG_SUPPORT = require("../internals/to-string-tag-support");
|
|
var defineBuiltIn = require("../internals/define-built-in");
|
|
var toString = require("../internals/object-to-string");
|
|
if (!TO_STRING_TAG_SUPPORT) {
|
|
defineBuiltIn(Object.prototype, "toString", toString, {
|
|
unsafe: true
|
|
});
|
|
}
|
|
}, {
|
|
"../internals/define-built-in": 19,
|
|
"../internals/object-to-string": 72,
|
|
"../internals/to-string-tag-support": 91
|
|
} ],
|
|
105: [ function(require, module, exports) {
|
|
var $ = require("../internals/export");
|
|
var getBuiltIn = require("../internals/get-built-in");
|
|
var apply = require("../internals/function-apply");
|
|
var bind = require("../internals/function-bind");
|
|
var aConstructor = require("../internals/a-constructor");
|
|
var anObject = require("../internals/an-object");
|
|
var isObject = require("../internals/is-object");
|
|
var create = require("../internals/object-create");
|
|
var fails = require("../internals/fails");
|
|
var nativeConstruct = getBuiltIn("Reflect", "construct");
|
|
var ObjectPrototype = Object.prototype;
|
|
var push = [].push;
|
|
var NEW_TARGET_BUG = fails(function() {
|
|
function F() {}
|
|
return !(nativeConstruct(function() {}, [], F) instanceof F);
|
|
});
|
|
var ARGS_BUG = !fails(function() {
|
|
nativeConstruct(function() {});
|
|
});
|
|
var FORCED = NEW_TARGET_BUG || ARGS_BUG;
|
|
$({
|
|
target: "Reflect",
|
|
stat: true,
|
|
forced: FORCED,
|
|
sham: FORCED
|
|
}, {
|
|
construct: function construct(Target, args) {
|
|
aConstructor(Target);
|
|
anObject(args);
|
|
var newTarget = arguments.length < 3 ? Target : aConstructor(arguments[2]);
|
|
if (ARGS_BUG && !NEW_TARGET_BUG) return nativeConstruct(Target, args, newTarget);
|
|
if (Target == newTarget) {
|
|
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]);
|
|
}
|
|
var $args = [ null ];
|
|
apply(push, $args, args);
|
|
return new (apply(bind, Target, $args))();
|
|
}
|
|
var proto = newTarget.prototype;
|
|
var instance = create(isObject(proto) ? proto : ObjectPrototype);
|
|
var result = apply(Target, instance, args);
|
|
return isObject(result) ? result : instance;
|
|
}
|
|
});
|
|
}, {
|
|
"../internals/a-constructor": 2,
|
|
"../internals/an-object": 3,
|
|
"../internals/export": 27,
|
|
"../internals/fails": 28,
|
|
"../internals/function-apply": 29,
|
|
"../internals/function-bind": 32,
|
|
"../internals/get-built-in": 37,
|
|
"../internals/is-object": 54,
|
|
"../internals/object-create": 60
|
|
} ],
|
|
106: [ function(require, module, exports) {
|
|
var $ = require("../internals/export");
|
|
var call = require("../internals/function-call");
|
|
var isObject = require("../internals/is-object");
|
|
var anObject = require("../internals/an-object");
|
|
var isDataDescriptor = require("../internals/is-data-descriptor");
|
|
var getOwnPropertyDescriptorModule = require("../internals/object-get-own-property-descriptor");
|
|
var getPrototypeOf = require("../internals/object-get-prototype-of");
|
|
function get(target, propertyKey) {
|
|
var receiver = arguments.length < 3 ? target : arguments[2];
|
|
var descriptor, prototype;
|
|
if (anObject(target) === receiver) return target[propertyKey];
|
|
descriptor = getOwnPropertyDescriptorModule.f(target, propertyKey);
|
|
if (descriptor) return isDataDescriptor(descriptor) ? descriptor.value : descriptor.get === undefined ? undefined : call(descriptor.get, receiver);
|
|
if (isObject(prototype = getPrototypeOf(target))) return get(prototype, propertyKey, receiver);
|
|
}
|
|
$({
|
|
target: "Reflect",
|
|
stat: true
|
|
}, {
|
|
get: get
|
|
});
|
|
}, {
|
|
"../internals/an-object": 3,
|
|
"../internals/export": 27,
|
|
"../internals/function-call": 33,
|
|
"../internals/is-data-descriptor": 51,
|
|
"../internals/is-object": 54,
|
|
"../internals/object-get-own-property-descriptor": 63,
|
|
"../internals/object-get-prototype-of": 67
|
|
} ],
|
|
107: [ function(require, module, exports) {
|
|
"use strict";
|
|
var $ = require("../internals/export");
|
|
var global = require("../internals/global");
|
|
var call = require("../internals/function-call");
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var IS_PURE = require("../internals/is-pure");
|
|
var DESCRIPTORS = require("../internals/descriptors");
|
|
var NATIVE_SYMBOL = require("../internals/symbol-constructor-detection");
|
|
var fails = require("../internals/fails");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var isPrototypeOf = require("../internals/object-is-prototype-of");
|
|
var anObject = require("../internals/an-object");
|
|
var toIndexedObject = require("../internals/to-indexed-object");
|
|
var toPropertyKey = require("../internals/to-property-key");
|
|
var $toString = require("../internals/to-string");
|
|
var createPropertyDescriptor = require("../internals/create-property-descriptor");
|
|
var nativeObjectCreate = require("../internals/object-create");
|
|
var objectKeys = require("../internals/object-keys");
|
|
var getOwnPropertyNamesModule = require("../internals/object-get-own-property-names");
|
|
var getOwnPropertyNamesExternal = require("../internals/object-get-own-property-names-external");
|
|
var getOwnPropertySymbolsModule = require("../internals/object-get-own-property-symbols");
|
|
var getOwnPropertyDescriptorModule = require("../internals/object-get-own-property-descriptor");
|
|
var definePropertyModule = require("../internals/object-define-property");
|
|
var definePropertiesModule = require("../internals/object-define-properties");
|
|
var propertyIsEnumerableModule = require("../internals/object-property-is-enumerable");
|
|
var defineBuiltIn = require("../internals/define-built-in");
|
|
var defineBuiltInAccessor = require("../internals/define-built-in-accessor");
|
|
var shared = require("../internals/shared");
|
|
var sharedKey = require("../internals/shared-key");
|
|
var hiddenKeys = require("../internals/hidden-keys");
|
|
var uid = require("../internals/uid");
|
|
var wellKnownSymbol = require("../internals/well-known-symbol");
|
|
var wrappedWellKnownSymbolModule = require("../internals/well-known-symbol-wrapped");
|
|
var defineWellKnownSymbol = require("../internals/well-known-symbol-define");
|
|
var defineSymbolToPrimitive = require("../internals/symbol-define-to-primitive");
|
|
var setToStringTag = require("../internals/set-to-string-tag");
|
|
var InternalStateModule = require("../internals/internal-state");
|
|
var $forEach = require("../internals/array-iteration").forEach;
|
|
var HIDDEN = sharedKey("hidden");
|
|
var SYMBOL = "Symbol";
|
|
var PROTOTYPE = "prototype";
|
|
var setInternalState = InternalStateModule.set;
|
|
var getInternalState = InternalStateModule.getterFor(SYMBOL);
|
|
var ObjectPrototype = Object[PROTOTYPE];
|
|
var $Symbol = global.Symbol;
|
|
var SymbolPrototype = $Symbol && $Symbol[PROTOTYPE];
|
|
var TypeError = global.TypeError;
|
|
var QObject = global.QObject;
|
|
var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
|
|
var nativeDefineProperty = definePropertyModule.f;
|
|
var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f;
|
|
var nativePropertyIsEnumerable = propertyIsEnumerableModule.f;
|
|
var push = uncurryThis([].push);
|
|
var AllSymbols = shared("symbols");
|
|
var ObjectPrototypeSymbols = shared("op-symbols");
|
|
var WellKnownSymbolsStore = shared("wks");
|
|
var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
|
|
var setSymbolDescriptor = DESCRIPTORS && fails(function() {
|
|
return nativeObjectCreate(nativeDefineProperty({}, "a", {
|
|
get: function() {
|
|
return nativeDefineProperty(this, "a", {
|
|
value: 7
|
|
}).a;
|
|
}
|
|
})).a != 7;
|
|
}) ? function(O, P, Attributes) {
|
|
var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P);
|
|
if (ObjectPrototypeDescriptor) delete ObjectPrototype[P];
|
|
nativeDefineProperty(O, P, Attributes);
|
|
if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {
|
|
nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);
|
|
}
|
|
} : nativeDefineProperty;
|
|
var wrap = function(tag, description) {
|
|
var symbol = AllSymbols[tag] = nativeObjectCreate(SymbolPrototype);
|
|
setInternalState(symbol, {
|
|
type: SYMBOL,
|
|
tag: tag,
|
|
description: description
|
|
});
|
|
if (!DESCRIPTORS) symbol.description = description;
|
|
return symbol;
|
|
};
|
|
var $defineProperty = function defineProperty(O, P, Attributes) {
|
|
if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes);
|
|
anObject(O);
|
|
var key = toPropertyKey(P);
|
|
anObject(Attributes);
|
|
if (hasOwn(AllSymbols, key)) {
|
|
if (!Attributes.enumerable) {
|
|
if (!hasOwn(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, {}));
|
|
O[HIDDEN][key] = true;
|
|
} else {
|
|
if (hasOwn(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false;
|
|
Attributes = nativeObjectCreate(Attributes, {
|
|
enumerable: createPropertyDescriptor(0, false)
|
|
});
|
|
}
|
|
return setSymbolDescriptor(O, key, Attributes);
|
|
}
|
|
return nativeDefineProperty(O, key, Attributes);
|
|
};
|
|
var $defineProperties = function defineProperties(O, Properties) {
|
|
anObject(O);
|
|
var properties = toIndexedObject(Properties);
|
|
var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties));
|
|
$forEach(keys, function(key) {
|
|
if (!DESCRIPTORS || call($propertyIsEnumerable, properties, key)) $defineProperty(O, key, properties[key]);
|
|
});
|
|
return O;
|
|
};
|
|
var $create = function create(O, Properties) {
|
|
return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties);
|
|
};
|
|
var $propertyIsEnumerable = function propertyIsEnumerable(V) {
|
|
var P = toPropertyKey(V);
|
|
var enumerable = call(nativePropertyIsEnumerable, this, P);
|
|
if (this === ObjectPrototype && hasOwn(AllSymbols, P) && !hasOwn(ObjectPrototypeSymbols, P)) return false;
|
|
return enumerable || !hasOwn(this, P) || !hasOwn(AllSymbols, P) || hasOwn(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true;
|
|
};
|
|
var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) {
|
|
var it = toIndexedObject(O);
|
|
var key = toPropertyKey(P);
|
|
if (it === ObjectPrototype && hasOwn(AllSymbols, key) && !hasOwn(ObjectPrototypeSymbols, key)) return;
|
|
var descriptor = nativeGetOwnPropertyDescriptor(it, key);
|
|
if (descriptor && hasOwn(AllSymbols, key) && !(hasOwn(it, HIDDEN) && it[HIDDEN][key])) {
|
|
descriptor.enumerable = true;
|
|
}
|
|
return descriptor;
|
|
};
|
|
var $getOwnPropertyNames = function getOwnPropertyNames(O) {
|
|
var names = nativeGetOwnPropertyNames(toIndexedObject(O));
|
|
var result = [];
|
|
$forEach(names, function(key) {
|
|
if (!hasOwn(AllSymbols, key) && !hasOwn(hiddenKeys, key)) push(result, key);
|
|
});
|
|
return result;
|
|
};
|
|
var $getOwnPropertySymbols = function(O) {
|
|
var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;
|
|
var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O));
|
|
var result = [];
|
|
$forEach(names, function(key) {
|
|
if (hasOwn(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || hasOwn(ObjectPrototype, key))) {
|
|
push(result, AllSymbols[key]);
|
|
}
|
|
});
|
|
return result;
|
|
};
|
|
if (!NATIVE_SYMBOL) {
|
|
$Symbol = function Symbol() {
|
|
if (isPrototypeOf(SymbolPrototype, this)) throw TypeError("Symbol is not a constructor");
|
|
var description = !arguments.length || arguments[0] === undefined ? undefined : $toString(arguments[0]);
|
|
var tag = uid(description);
|
|
var setter = function(value) {
|
|
if (this === ObjectPrototype) call(setter, ObjectPrototypeSymbols, value);
|
|
if (hasOwn(this, HIDDEN) && hasOwn(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);
|
|
};
|
|
SymbolPrototype = $Symbol[PROTOTYPE];
|
|
defineBuiltIn(SymbolPrototype, "toString", function toString() {
|
|
return getInternalState(this).tag;
|
|
});
|
|
defineBuiltIn($Symbol, "withoutSetter", function(description) {
|
|
return wrap(uid(description), description);
|
|
});
|
|
propertyIsEnumerableModule.f = $propertyIsEnumerable;
|
|
definePropertyModule.f = $defineProperty;
|
|
definePropertiesModule.f = $defineProperties;
|
|
getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor;
|
|
getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames;
|
|
getOwnPropertySymbolsModule.f = $getOwnPropertySymbols;
|
|
wrappedWellKnownSymbolModule.f = function(name) {
|
|
return wrap(wellKnownSymbol(name), name);
|
|
};
|
|
if (DESCRIPTORS) {
|
|
defineBuiltInAccessor(SymbolPrototype, "description", {
|
|
configurable: true,
|
|
get: function description() {
|
|
return getInternalState(this).description;
|
|
}
|
|
});
|
|
if (!IS_PURE) {
|
|
defineBuiltIn(ObjectPrototype, "propertyIsEnumerable", $propertyIsEnumerable, {
|
|
unsafe: true
|
|
});
|
|
}
|
|
}
|
|
}
|
|
$({
|
|
global: true,
|
|
constructor: true,
|
|
wrap: true,
|
|
forced: !NATIVE_SYMBOL,
|
|
sham: !NATIVE_SYMBOL
|
|
}, {
|
|
Symbol: $Symbol
|
|
});
|
|
$forEach(objectKeys(WellKnownSymbolsStore), function(name) {
|
|
defineWellKnownSymbol(name);
|
|
});
|
|
$({
|
|
target: SYMBOL,
|
|
stat: true,
|
|
forced: !NATIVE_SYMBOL
|
|
}, {
|
|
useSetter: function() {
|
|
USE_SETTER = true;
|
|
},
|
|
useSimple: function() {
|
|
USE_SETTER = false;
|
|
}
|
|
});
|
|
$({
|
|
target: "Object",
|
|
stat: true,
|
|
forced: !NATIVE_SYMBOL,
|
|
sham: !DESCRIPTORS
|
|
}, {
|
|
create: $create,
|
|
defineProperty: $defineProperty,
|
|
defineProperties: $defineProperties,
|
|
getOwnPropertyDescriptor: $getOwnPropertyDescriptor
|
|
});
|
|
$({
|
|
target: "Object",
|
|
stat: true,
|
|
forced: !NATIVE_SYMBOL
|
|
}, {
|
|
getOwnPropertyNames: $getOwnPropertyNames
|
|
});
|
|
defineSymbolToPrimitive();
|
|
setToStringTag($Symbol, SYMBOL);
|
|
hiddenKeys[HIDDEN] = true;
|
|
}, {
|
|
"../internals/an-object": 3,
|
|
"../internals/array-iteration": 5,
|
|
"../internals/create-property-descriptor": 15,
|
|
"../internals/define-built-in": 19,
|
|
"../internals/define-built-in-accessor": 18,
|
|
"../internals/descriptors": 21,
|
|
"../internals/export": 27,
|
|
"../internals/fails": 28,
|
|
"../internals/function-call": 33,
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/global": 40,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/hidden-keys": 42,
|
|
"../internals/internal-state": 47,
|
|
"../internals/is-pure": 55,
|
|
"../internals/object-create": 60,
|
|
"../internals/object-define-properties": 61,
|
|
"../internals/object-define-property": 62,
|
|
"../internals/object-get-own-property-descriptor": 63,
|
|
"../internals/object-get-own-property-names": 65,
|
|
"../internals/object-get-own-property-names-external": 64,
|
|
"../internals/object-get-own-property-symbols": 66,
|
|
"../internals/object-is-prototype-of": 68,
|
|
"../internals/object-keys": 70,
|
|
"../internals/object-property-is-enumerable": 71,
|
|
"../internals/set-to-string-tag": 77,
|
|
"../internals/shared": 80,
|
|
"../internals/shared-key": 78,
|
|
"../internals/symbol-constructor-detection": 81,
|
|
"../internals/symbol-define-to-primitive": 82,
|
|
"../internals/to-indexed-object": 85,
|
|
"../internals/to-property-key": 90,
|
|
"../internals/to-string": 92,
|
|
"../internals/uid": 94,
|
|
"../internals/well-known-symbol": 100,
|
|
"../internals/well-known-symbol-define": 98,
|
|
"../internals/well-known-symbol-wrapped": 99
|
|
} ],
|
|
108: [ function(require, module, exports) {
|
|
"use strict";
|
|
var $ = require("../internals/export");
|
|
var DESCRIPTORS = require("../internals/descriptors");
|
|
var global = require("../internals/global");
|
|
var uncurryThis = require("../internals/function-uncurry-this");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var isCallable = require("../internals/is-callable");
|
|
var isPrototypeOf = require("../internals/object-is-prototype-of");
|
|
var toString = require("../internals/to-string");
|
|
var defineBuiltInAccessor = require("../internals/define-built-in-accessor");
|
|
var copyConstructorProperties = require("../internals/copy-constructor-properties");
|
|
var NativeSymbol = global.Symbol;
|
|
var SymbolPrototype = NativeSymbol && NativeSymbol.prototype;
|
|
if (DESCRIPTORS && isCallable(NativeSymbol) && (!("description" in SymbolPrototype) || NativeSymbol().description !== undefined)) {
|
|
var EmptyStringDescriptionStore = {};
|
|
var SymbolWrapper = function Symbol() {
|
|
var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString(arguments[0]);
|
|
var result = isPrototypeOf(SymbolPrototype, this) ? new NativeSymbol(description) : description === undefined ? NativeSymbol() : NativeSymbol(description);
|
|
if (description === "") EmptyStringDescriptionStore[result] = true;
|
|
return result;
|
|
};
|
|
copyConstructorProperties(SymbolWrapper, NativeSymbol);
|
|
SymbolWrapper.prototype = SymbolPrototype;
|
|
SymbolPrototype.constructor = SymbolWrapper;
|
|
var NATIVE_SYMBOL = String(NativeSymbol("test")) == "Symbol(test)";
|
|
var thisSymbolValue = uncurryThis(SymbolPrototype.valueOf);
|
|
var symbolDescriptiveString = uncurryThis(SymbolPrototype.toString);
|
|
var regexp = /^Symbol\((.*)\)[^)]+$/;
|
|
var replace = uncurryThis("".replace);
|
|
var stringSlice = uncurryThis("".slice);
|
|
defineBuiltInAccessor(SymbolPrototype, "description", {
|
|
configurable: true,
|
|
get: function description() {
|
|
var symbol = thisSymbolValue(this);
|
|
if (hasOwn(EmptyStringDescriptionStore, symbol)) return "";
|
|
var string = symbolDescriptiveString(symbol);
|
|
var desc = NATIVE_SYMBOL ? stringSlice(string, 7, -1) : replace(string, regexp, "$1");
|
|
return desc === "" ? undefined : desc;
|
|
}
|
|
});
|
|
$({
|
|
global: true,
|
|
constructor: true,
|
|
forced: true
|
|
}, {
|
|
Symbol: SymbolWrapper
|
|
});
|
|
}
|
|
}, {
|
|
"../internals/copy-constructor-properties": 12,
|
|
"../internals/define-built-in-accessor": 18,
|
|
"../internals/descriptors": 21,
|
|
"../internals/export": 27,
|
|
"../internals/function-uncurry-this": 36,
|
|
"../internals/global": 40,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/is-callable": 49,
|
|
"../internals/object-is-prototype-of": 68,
|
|
"../internals/to-string": 92
|
|
} ],
|
|
109: [ function(require, module, exports) {
|
|
var $ = require("../internals/export");
|
|
var getBuiltIn = require("../internals/get-built-in");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var toString = require("../internals/to-string");
|
|
var shared = require("../internals/shared");
|
|
var NATIVE_SYMBOL_REGISTRY = require("../internals/symbol-registry-detection");
|
|
var StringToSymbolRegistry = shared("string-to-symbol-registry");
|
|
var SymbolToStringRegistry = shared("symbol-to-string-registry");
|
|
$({
|
|
target: "Symbol",
|
|
stat: true,
|
|
forced: !NATIVE_SYMBOL_REGISTRY
|
|
}, {
|
|
for: function(key) {
|
|
var string = toString(key);
|
|
if (hasOwn(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string];
|
|
var symbol = getBuiltIn("Symbol")(string);
|
|
StringToSymbolRegistry[string] = symbol;
|
|
SymbolToStringRegistry[symbol] = string;
|
|
return symbol;
|
|
}
|
|
});
|
|
}, {
|
|
"../internals/export": 27,
|
|
"../internals/get-built-in": 37,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/shared": 80,
|
|
"../internals/symbol-registry-detection": 83,
|
|
"../internals/to-string": 92
|
|
} ],
|
|
110: [ function(require, module, exports) {
|
|
require("../modules/es.symbol.constructor");
|
|
require("../modules/es.symbol.for");
|
|
require("../modules/es.symbol.key-for");
|
|
require("../modules/es.json.stringify");
|
|
require("../modules/es.object.get-own-property-symbols");
|
|
}, {
|
|
"../modules/es.json.stringify": 102,
|
|
"../modules/es.object.get-own-property-symbols": 103,
|
|
"../modules/es.symbol.constructor": 107,
|
|
"../modules/es.symbol.for": 109,
|
|
"../modules/es.symbol.key-for": 111
|
|
} ],
|
|
111: [ function(require, module, exports) {
|
|
var $ = require("../internals/export");
|
|
var hasOwn = require("../internals/has-own-property");
|
|
var isSymbol = require("../internals/is-symbol");
|
|
var tryToString = require("../internals/try-to-string");
|
|
var shared = require("../internals/shared");
|
|
var NATIVE_SYMBOL_REGISTRY = require("../internals/symbol-registry-detection");
|
|
var SymbolToStringRegistry = shared("symbol-to-string-registry");
|
|
$({
|
|
target: "Symbol",
|
|
stat: true,
|
|
forced: !NATIVE_SYMBOL_REGISTRY
|
|
}, {
|
|
keyFor: function keyFor(sym) {
|
|
if (!isSymbol(sym)) throw TypeError(tryToString(sym) + " is not a symbol");
|
|
if (hasOwn(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym];
|
|
}
|
|
});
|
|
}, {
|
|
"../internals/export": 27,
|
|
"../internals/has-own-property": 41,
|
|
"../internals/is-symbol": 56,
|
|
"../internals/shared": 80,
|
|
"../internals/symbol-registry-detection": 83,
|
|
"../internals/try-to-string": 93
|
|
} ],
|
|
112: [ function(require, module, exports) {
|
|
var defineWellKnownSymbol = require("../internals/well-known-symbol-define");
|
|
var defineSymbolToPrimitive = require("../internals/symbol-define-to-primitive");
|
|
defineWellKnownSymbol("toPrimitive");
|
|
defineSymbolToPrimitive();
|
|
}, {
|
|
"../internals/symbol-define-to-primitive": 82,
|
|
"../internals/well-known-symbol-define": 98
|
|
} ],
|
|
113: [ function(require, module, exports) {
|
|
"use strict";
|
|
require("core-js/modules/es.object.to-string.js");
|
|
require("core-js/modules/es.reflect.construct.js");
|
|
require("core-js/modules/es.reflect.get.js");
|
|
require("core-js/modules/es.symbol.to-primitive.js");
|
|
require("core-js/modules/es.date.to-primitive.js");
|
|
require("core-js/modules/es.symbol.js");
|
|
require("core-js/modules/es.symbol.description.js");
|
|
function _classCallCheck(instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
}
|
|
function _defineProperties(target, props) {
|
|
for (var i = 0; i < props.length; i++) {
|
|
var descriptor = props[i];
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
|
descriptor.configurable = true;
|
|
if ("value" in descriptor) descriptor.writable = true;
|
|
Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
|
|
}
|
|
}
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
|
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
|
|
if (staticProps) _defineProperties(Constructor, staticProps);
|
|
Object.defineProperty(Constructor, "prototype", {
|
|
writable: false
|
|
});
|
|
return Constructor;
|
|
}
|
|
function _toPropertyKey(arg) {
|
|
var key = _toPrimitive(arg, "string");
|
|
return typeof key === "symbol" ? key : String(key);
|
|
}
|
|
function _toPrimitive(input, hint) {
|
|
if (typeof input !== "object" || input === null) return input;
|
|
var prim = input[Symbol.toPrimitive];
|
|
if (prim !== undefined) {
|
|
var res = prim.call(input, hint || "default");
|
|
if (typeof res !== "object") return res;
|
|
throw new TypeError("@@toPrimitive must return a primitive value.");
|
|
}
|
|
return (hint === "string" ? String : Number)(input);
|
|
}
|
|
function _get() {
|
|
if (typeof Reflect !== "undefined" && Reflect.get) {
|
|
_get = Reflect.get.bind();
|
|
} else {
|
|
_get = function _get(target, property, receiver) {
|
|
var base = _superPropBase(target, property);
|
|
if (!base) return;
|
|
var desc = Object.getOwnPropertyDescriptor(base, property);
|
|
if (desc.get) {
|
|
return desc.get.call(arguments.length < 3 ? target : receiver);
|
|
}
|
|
return desc.value;
|
|
};
|
|
}
|
|
return _get.apply(this, arguments);
|
|
}
|
|
function _superPropBase(object, property) {
|
|
while (!Object.prototype.hasOwnProperty.call(object, property)) {
|
|
object = _getPrototypeOf(object);
|
|
if (object === null) break;
|
|
}
|
|
return object;
|
|
}
|
|
function _inherits(subClass, superClass) {
|
|
if (typeof superClass !== "function" && superClass !== null) {
|
|
throw new TypeError("Super expression must either be null or a function");
|
|
}
|
|
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
|
constructor: {
|
|
value: subClass,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
Object.defineProperty(subClass, "prototype", {
|
|
writable: false
|
|
});
|
|
if (superClass) _setPrototypeOf(subClass, superClass);
|
|
}
|
|
function _setPrototypeOf(o, p) {
|
|
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
|
|
o.__proto__ = p;
|
|
return o;
|
|
};
|
|
return _setPrototypeOf(o, p);
|
|
}
|
|
function _createSuper(Derived) {
|
|
var hasNativeReflectConstruct = _isNativeReflectConstruct();
|
|
return function _createSuperInternal() {
|
|
var Super = _getPrototypeOf(Derived), result;
|
|
if (hasNativeReflectConstruct) {
|
|
var NewTarget = _getPrototypeOf(this).constructor;
|
|
result = Reflect.construct(Super, arguments, NewTarget);
|
|
} else {
|
|
result = Super.apply(this, arguments);
|
|
}
|
|
return _possibleConstructorReturn(this, result);
|
|
};
|
|
}
|
|
function _possibleConstructorReturn(self, call) {
|
|
if (call && (typeof call === "object" || typeof call === "function")) {
|
|
return call;
|
|
} else if (call !== void 0) {
|
|
throw new TypeError("Derived constructors may only return object or undefined");
|
|
}
|
|
return _assertThisInitialized(self);
|
|
}
|
|
function _assertThisInitialized(self) {
|
|
if (self === void 0) {
|
|
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
|
}
|
|
return self;
|
|
}
|
|
function _isNativeReflectConstruct() {
|
|
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
|
|
if (Reflect.construct.sham) return false;
|
|
if (typeof Proxy === "function") return true;
|
|
try {
|
|
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
function _getPrototypeOf(o) {
|
|
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
|
|
return o.__proto__ || Object.getPrototypeOf(o);
|
|
};
|
|
return _getPrototypeOf(o);
|
|
}
|
|
var hasAirPlayAPISupport = require("../lib/hasAirPlayAPISupport");
|
|
module.exports = function(videojs) {
|
|
var ButtonComponent = videojs.getComponent("Button");
|
|
var AirPlayButton = function(_ButtonComponent) {
|
|
_inherits(AirPlayButton, _ButtonComponent);
|
|
var _super = _createSuper(AirPlayButton);
|
|
function AirPlayButton(player, options) {
|
|
var _this;
|
|
_classCallCheck(this, AirPlayButton);
|
|
_this = _super.call(this, player, options);
|
|
if (!hasAirPlayAPISupport()) {
|
|
_this.hide();
|
|
}
|
|
_this._reactToAirPlayAvailableEvents();
|
|
if (options.addAirPlayLabelToButton) {
|
|
_this.el().classList.add("vjs-airplay-button-lg");
|
|
_this._labelEl = document.createElement("span");
|
|
_this._labelEl.classList.add("vjs-airplay-button-label");
|
|
_this._labelEl.textContent = _this.localize("AirPlay");
|
|
_this.el().appendChild(_this._labelEl);
|
|
} else {
|
|
_this.controlText("Start AirPlay");
|
|
}
|
|
return _this;
|
|
}
|
|
_createClass(AirPlayButton, [ {
|
|
key: "buildCSSClass",
|
|
value: function buildCSSClass() {
|
|
return "vjs-airplay-button " + _get(_getPrototypeOf(AirPlayButton.prototype), "buildCSSClass", this).call(this);
|
|
}
|
|
}, {
|
|
key: "handleClick",
|
|
value: function handleClick() {
|
|
this.player().trigger("airPlayRequested");
|
|
}
|
|
}, {
|
|
key: "_getMediaEl",
|
|
value: function _getMediaEl() {
|
|
var playerEl = this.player().el();
|
|
return playerEl.querySelector("video, audio");
|
|
}
|
|
}, {
|
|
key: "_reactToAirPlayAvailableEvents",
|
|
value: function _reactToAirPlayAvailableEvents() {
|
|
var mediaEl = this._getMediaEl(), self = this;
|
|
if (!mediaEl || !hasAirPlayAPISupport()) {
|
|
return;
|
|
}
|
|
function onTargetAvailabilityChanged(event) {
|
|
if (event.availability === "available") {
|
|
self.show();
|
|
} else {
|
|
self.hide();
|
|
}
|
|
}
|
|
mediaEl.addEventListener("webkitplaybacktargetavailabilitychanged", onTargetAvailabilityChanged);
|
|
this.on("dispose", function() {
|
|
mediaEl.removeEventListener("webkitplaybacktargetavailabilitychanged", onTargetAvailabilityChanged);
|
|
});
|
|
}
|
|
} ]);
|
|
return AirPlayButton;
|
|
}(ButtonComponent);
|
|
videojs.registerComponent("airPlayButton", AirPlayButton);
|
|
};
|
|
}, {
|
|
"../lib/hasAirPlayAPISupport": 116,
|
|
"core-js/modules/es.date.to-primitive.js": 101,
|
|
"core-js/modules/es.object.to-string.js": 104,
|
|
"core-js/modules/es.reflect.construct.js": 105,
|
|
"core-js/modules/es.reflect.get.js": 106,
|
|
"core-js/modules/es.symbol.description.js": 108,
|
|
"core-js/modules/es.symbol.js": 110,
|
|
"core-js/modules/es.symbol.to-primitive.js": 112
|
|
} ],
|
|
114: [ function(require, module, exports) {
|
|
"use strict";
|
|
var hasAirPlayAPISupport = require("./lib/hasAirPlayAPISupport");
|
|
function getExistingAirPlayButton(player) {
|
|
return player.controlBar.getChild("airPlayButton");
|
|
}
|
|
function ensureAirPlayButtonExists(player, options) {
|
|
var existingAirPlayButton = getExistingAirPlayButton(player), indexOpt;
|
|
if (options.addButtonToControlBar && !existingAirPlayButton) {
|
|
indexOpt = player.controlBar.children().length;
|
|
if (typeof options.buttonPositionIndex !== "undefined") {
|
|
indexOpt = options.buttonPositionIndex >= 0 ? options.buttonPositionIndex : player.controlBar.children().length + options.buttonPositionIndex;
|
|
}
|
|
player.controlBar.addChild("airPlayButton", options, indexOpt);
|
|
}
|
|
}
|
|
function onAirPlayRequested(player) {
|
|
var mediaEl = player.el().querySelector("video, audio");
|
|
if (mediaEl && mediaEl.webkitShowPlaybackTargetPicker) {
|
|
mediaEl.webkitShowPlaybackTargetPicker();
|
|
}
|
|
}
|
|
function listenForAirPlayEvents(player) {
|
|
player.on("airPlayRequested", onAirPlayRequested.bind(null, player));
|
|
}
|
|
function enableAirPlay(player, options) {
|
|
if (!player.controlBar) {
|
|
return;
|
|
}
|
|
if (hasAirPlayAPISupport()) {
|
|
listenForAirPlayEvents(player);
|
|
ensureAirPlayButtonExists(player, options);
|
|
}
|
|
}
|
|
module.exports = function(videojs) {
|
|
videojs.registerPlugin("airPlay", function(options) {
|
|
var pluginOptions = Object.assign({
|
|
addButtonToControlBar: true
|
|
}, options || {});
|
|
this.ready(enableAirPlay.bind(this, this, pluginOptions));
|
|
});
|
|
};
|
|
}, {
|
|
"./lib/hasAirPlayAPISupport": 116
|
|
} ],
|
|
115: [ function(require, module, exports) {
|
|
"use strict";
|
|
var createAirPlayButton = require("./components/AirPlayButton"), createAirPlayPlugin = require("./enableAirPlay");
|
|
module.exports = function(videojs) {
|
|
videojs = videojs || window.videojs;
|
|
createAirPlayButton(videojs);
|
|
createAirPlayPlugin(videojs);
|
|
};
|
|
}, {
|
|
"./components/AirPlayButton": 113,
|
|
"./enableAirPlay": 114
|
|
} ],
|
|
116: [ function(require, module, exports) {
|
|
"use strict";
|
|
module.exports = function() {
|
|
return !!window.WebKitPlaybackTargetAvailabilityEvent;
|
|
};
|
|
}, {} ],
|
|
117: [ function(require, module, exports) {
|
|
"use strict";
|
|
require("./index")();
|
|
}, {
|
|
"./index": 115
|
|
} ]
|
|
}, {}, [ 117 ]); |