@nevware21/ts-utils
Version:
Common JavaScript/TypeScript helper functions for better minification
1,409 lines (1,343 loc) • 75 kB
JavaScript
/*! https://github.com/nevware21/ts-utils v0.11.8 */
/*
* Copyright (c) NevWare21 Solutions LLC and contributors. All rights reserved.
* Licensed under the MIT license.
*/
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.nevware21 = global.nevware21 || {}, global.nevware21["ts-utils"] = {})));
})(this, (function (exports) { 'use strict';
/*#__NO_SIDE_EFFECTS__*/
function _pureAssign(func1, func2) {
return func1 || func2;
}
/*#__NO_SIDE_EFFECTS__*/
function _pureRef(value, name) {
return value[name];
}
var UNDEF_VALUE = undefined;
var NULL_VALUE = null;
var EMPTY = "";
var FUNCTION = "function";
var OBJECT = "object";
var PROTOTYPE = "prototype";
var __PROTO__ = "__proto__";
var UNDEFINED = "undefined";
var CONSTRUCTOR = "constructor";
var SYMBOL = "Symbol";
var POLYFILL_TAG = "_polyfill";
var LENGTH = "length";
var NAME = "name";
var CALL = "call";
var TO_STRING = "toString";
var ObjClass = ( /*#__PURE__*/_pureAssign(Object));
var ObjProto = ( /*#__PURE__*/_pureRef(ObjClass, PROTOTYPE));
var StrCls = ( /*#__PURE__*/_pureAssign(String));
var StrProto = ( /*#__PURE__*/_pureRef(StrCls, PROTOTYPE));
var MathCls = ( /*#__PURE__*/_pureAssign(Math));
var ArrCls = ( /*#__PURE__*/_pureAssign(Array));
var ArrProto = ( /*#__PURE__*/_pureRef(ArrCls, PROTOTYPE));
var ArrSlice = ( /*#__PURE__*/_pureRef(ArrProto, "slice"));
function safe(func, argArray) {
try {
return {
v: func.apply(this, argArray)
};
}
catch (e) {
return { e: e };
}
}
/*#__NO_SIDE_EFFECTS__*/
function safeGet(cb, defValue) {
var result = safe(cb);
return result.e ? defValue : result.v;
}
var _primitiveTypes;
/*#__NO_SIDE_EFFECTS__*/
function _createIs(theType) {
return function (value) {
return typeof value === theType;
};
}
/*#__NO_SIDE_EFFECTS__*/
function _createObjIs(theName) {
var theType = "[object " + theName + "]";
return function (value) {
return !!(value && objToString(value) === theType);
};
}
/*#__NO_SIDE_EFFECTS__*/
function objToString(value) {
return ObjProto[TO_STRING].call(value);
}
/*#__NO_SIDE_EFFECTS__*/
function isTypeof(value, theType) {
return typeof value === theType;
}
/*#__NO_SIDE_EFFECTS__*/
function isUndefined(value) {
return typeof value === UNDEFINED || value === UNDEFINED;
}
/*#__NO_SIDE_EFFECTS__*/
function isStrictUndefined(arg) {
return !isDefined(arg);
}
/*#__NO_SIDE_EFFECTS__*/
function isNullOrUndefined(value) {
return value === NULL_VALUE || isUndefined(value);
}
/*#__NO_SIDE_EFFECTS__*/
function isStrictNullOrUndefined(value) {
return value === NULL_VALUE || !isDefined(value);
}
/*#__NO_SIDE_EFFECTS__*/
function isDefined(arg) {
return !!arg || arg !== UNDEF_VALUE;
}
/*#__NO_SIDE_EFFECTS__*/
function isPrimitive(value) {
return value === NULL_VALUE || isPrimitiveType(typeof value);
}
/*#__NO_SIDE_EFFECTS__*/
function isPrimitiveType(theType) {
!_primitiveTypes && (_primitiveTypes = ["string", "number", "boolean", UNDEFINED, "symbol", "bigint"]);
return !!(theType !== OBJECT && _primitiveTypes.indexOf(theType) !== -1);
}
var isString = ( /*#__PURE__*/_createIs("string"));
var isFunction = ( /*#__PURE__*/_createIs(FUNCTION));
/*#__NO_SIDE_EFFECTS__*/
function isObject(value) {
if (!value && isNullOrUndefined(value)) {
return false;
}
return !!value && typeof value === OBJECT;
}
var isArray = ( /* #__PURE__*/_pureRef(ArrCls, "isArray"));
var isDate = ( /*#__PURE__*/_createObjIs("Date"));
var isNumber = ( /*#__PURE__*/_createIs("number"));
var isBoolean = ( /*#__PURE__*/_createIs("boolean"));
var isRegExp = ( /*#__PURE__*/_createObjIs("RegExp"));
var isFile = ( /*#__PURE__*/_createObjIs("File"));
var isFormData = ( /*#__PURE__*/_createObjIs("FormData"));
var isBlob = ( /*#__PURE__*/_createObjIs("Blob"));
var isArrayBuffer = ( /*#__PURE__*/_createObjIs("ArrayBuffer"));
var isError = ( /*#__PURE__*/_createObjIs("Error"));
/*#__NO_SIDE_EFFECTS__*/
function isPromiseLike(value) {
return !!(value && value.then && isFunction(value.then));
}
var isThenable = isPromiseLike;
/*#__NO_SIDE_EFFECTS__*/
function isPromise(value) {
return !!(value && value.then && value.catch && isFunction(value.then) && isFunction(value.catch));
}
/*#__NO_SIDE_EFFECTS__*/
function isNotTruthy(value) {
return !value || !isTruthy(value);
}
/*#__NO_SIDE_EFFECTS__*/
function isTruthy(value) {
return !(!value || safeGet(function () { return !(value && (0 + value)); }, !value));
}
var objGetOwnPropertyDescriptor = ( /* #__PURE__ */_pureRef(ObjClass, "getOwnPropertyDescriptor"));
/*#__NO_SIDE_EFFECTS__*/
function objHasOwnProperty(obj, prop) {
return !!obj && ObjProto.hasOwnProperty[CALL](obj, prop);
}
var objHasOwn = ( /*#__PURE__*/_pureAssign(( /* #__PURE__ */_pureRef(ObjClass, "hasOwn")), polyObjHasOwn));
/*#__NO_SIDE_EFFECTS__*/
function polyObjHasOwn(obj, prop) {
return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
}
function objForEachKey(theObject, callbackfn, thisArg) {
if (theObject && isObject(theObject)) {
for (var prop in theObject) {
if (objHasOwn(theObject, prop)) {
if (callbackfn[CALL](thisArg || theObject, prop, theObject[prop]) === -1) {
break;
}
}
}
}
}
var propMap = {
e: "enumerable",
c: "configurable",
v: "value",
w: "writable",
g: "get",
s: "set"
};
/*#__NO_SIDE_EFFECTS__*/
function _createProp(value) {
var prop = {};
prop[propMap["c"]] = true;
prop[propMap["e"]] = true;
if (value.l) {
prop.get = function () { return value.l.v; };
var desc = objGetOwnPropertyDescriptor(value.l, "v");
if (desc && desc.set) {
prop.set = function (newValue) {
value.l.v = newValue;
};
}
}
objForEachKey(value, function (key, value) {
prop[propMap[key]] = isStrictUndefined(value) ? prop[propMap[key]] : value;
});
return prop;
}
var objDefineProp = ( /*#__PURE__*/_pureRef(ObjClass, "defineProperty"));
var objDefineProperties = ( /*#__PURE__*/_pureRef(ObjClass, "defineProperties"));
function objDefineGet(target, key, value, configurable, enumerable) {
var _a;
return objDefineProp(target, key, _createProp((_a = {
e: enumerable,
c: configurable
},
_a[isFunction(value) ? "g" : "v"] = value,
_a)));
}
function objDefineAccessors(target, prop, getProp, setProp, configurable, enumerable) {
var desc = {
e: enumerable,
c: configurable
};
if (getProp) {
desc.g = getProp;
}
if (setProp) {
desc.s = setProp;
}
return objDefineProp(target, prop, _createProp(desc));
}
function objDefine(target, key, propDesc) {
return objDefineProp(target, key, _createProp(propDesc));
}
function objDefineProps(target, propDescMap) {
var props = {};
objForEachKey(propDescMap, function (key, value) {
props[key] = _createProp(value);
});
return objDefineProperties(target, props);
}
/*#__NO_SIDE_EFFECTS__*/
function _createKeyValueMap(values, keyType, valueType, completeFn, writable) {
var theMap = {};
objForEachKey(values, function (key, value) {
_assignMapValue(theMap, key, keyType ? value : key);
_assignMapValue(theMap, value, valueType ? value : key);
});
return completeFn ? completeFn(theMap) : theMap;
}
function _assignMapValue(theMap, key, value, writable) {
objDefineProp(theMap, key, {
value: value,
enumerable: true,
writable: false
});
}
var asString = ( /* #__PURE__ */_pureAssign(StrCls));
var ERROR_TYPE = "[object Error]";
/*#__NO_SIDE_EFFECTS__*/
function dumpObj(object, format) {
var propertyValueDump = EMPTY;
var objType = ObjProto[TO_STRING][CALL](object);
if (objType === ERROR_TYPE) {
object = { stack: asString(object.stack), message: asString(object.message), name: asString(object.name) };
}
try {
propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? ((typeof format === "number") ? format : 4) : UNDEF_VALUE);
propertyValueDump = (propertyValueDump ? propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ") : NULL_VALUE) || asString(object);
}
catch (e) {
propertyValueDump = " - " + dumpObj(e, format);
}
return objType + ": " + propertyValueDump;
}
function throwError(message) {
throw new Error(message);
}
function throwTypeError(message) {
throw new TypeError(message);
}
function throwRangeError(message) {
throw new RangeError(message);
}
/*#__NO_SIDE_EFFECTS__*/
function polyObjKeys(obj) {
if (!isObject(obj) || obj === NULL_VALUE) {
throwTypeError("non-object " + dumpObj(obj));
}
var result = [];
for (var prop in obj) {
if (objHasOwn(obj, prop)) {
result.push(prop);
}
}
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function polyObjEntries(value) {
var result = [];
objForEachKey(value, function (key, value) {
result.push([key, value]);
});
return result;
}
var _objFreeze = ( /* #__PURE__ */_pureRef(ObjClass, "freeze"));
function _doNothing(value) {
return value;
}
/*#__NO_SIDE_EFFECTS__*/
function _getProto(value) {
return value[__PROTO__] || NULL_VALUE;
}
var objAssign = ( /*#__PURE__*/_pureRef(ObjClass, "assign"));
var objKeys = ( /*#__PURE__*/_pureRef(ObjClass, "keys"));
function objDeepFreeze(value) {
if (_objFreeze) {
objForEachKey(value, function (key, value) {
if (isArray(value) || isObject(value)) {
objDeepFreeze(value);
}
});
}
return objFreeze(value);
}
var objFreeze = ( /* #__PURE__*/_pureAssign(_objFreeze, _doNothing));
var objSeal = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ObjClass, "seal")), _doNothing));
var objGetPrototypeOf = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ObjClass, "getPrototypeOf")), _getProto));
var objEntries = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ObjClass, "entries")), polyObjEntries));
/*#__NO_SIDE_EFFECTS__*/
function createEnum(values) {
return _createKeyValueMap(values, 1 , 0 , objFreeze);
}
/*#__NO_SIDE_EFFECTS__*/
function createEnumKeyMap(values) {
return _createKeyValueMap(values, 0 , 0 , objFreeze);
}
/*#__NO_SIDE_EFFECTS__*/
function createEnumValueMap(values) {
return _createKeyValueMap(values, 1 , 1 , objFreeze);
}
/*#__NO_SIDE_EFFECTS__*/
function createSimpleMap(values) {
var mapClass = {};
objForEachKey(values, function (key, value) {
_assignMapValue(mapClass, key, value[1]);
_assignMapValue(mapClass, value[0], value[1]);
});
return objFreeze(mapClass);
}
/*#__NO_SIDE_EFFECTS__*/
function createTypeMap(values) {
return createSimpleMap(values);
}
var _wellKnownSymbolMap = /*#__PURE__*/ createEnumKeyMap({
asyncIterator: 0 ,
hasInstance: 1 ,
isConcatSpreadable: 2 ,
iterator: 3 ,
match: 4 ,
matchAll: 5 ,
replace: 6 ,
search: 7 ,
species: 8 ,
split: 9 ,
toPrimitive: 10 ,
toStringTag: 11 ,
unscopables: 12
});
var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
var _globalCfg;
/*#__NO_SIDE_EFFECTS__*/
function _getGlobalValue() {
var result;
if (typeof globalThis !== UNDEFINED) {
result = globalThis;
}
if (!result && typeof self !== UNDEFINED) {
result = self;
}
if (!result && typeof window !== UNDEFINED) {
result = window;
}
if (!result && typeof global !== UNDEFINED) {
result = global;
}
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function _getGlobalConfig() {
if (!_globalCfg) {
var gbl = safe(_getGlobalValue).v || {};
_globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
}
return _globalCfg;
}
var _unwrapFunction = ( _unwrapFunctionWithPoly);
/*#__NO_SIDE_EFFECTS__*/
function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
return function (thisArg) {
var theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || clsFn;
if (theFunc || polyFunc) {
var theArgs = arguments;
return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);
}
throwTypeError("\"" + asString(funcName) + "\" not defined for " + dumpObj(thisArg));
};
}
/*#__NO_SIDE_EFFECTS__*/
function _unwrapProp(propName) {
return function (thisArg) {
return thisArg[propName];
};
}
var mathMin = ( /*#__PURE__*/_pureRef(MathCls, "min"));
var mathMax = ( /*#__PURE__*/_pureRef(MathCls, "max"));
var strSlice = ( /*#__PURE__*/_unwrapFunction("slice", StrProto));
var strSubstring = ( /*#__PURE__*/_unwrapFunction("substring", StrProto));
var strSubstr = ( /*#__PURE__*/_unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr));
/*#__NO_SIDE_EFFECTS__*/
function polyStrSubstr(value, start, length) {
if (isNullOrUndefined(value)) {
throwTypeError("Invalid " + dumpObj(value));
}
if (length < 0) {
return EMPTY;
}
start = start || 0;
if (start < 0) {
start = mathMax(start + value[LENGTH], 0);
}
if (isUndefined(length)) {
return strSlice(value, start);
}
return strSlice(value, start, start + length);
}
/*#__NO_SIDE_EFFECTS__*/
function strLeft(value, count) {
return strSubstring(value, 0, count);
}
/*#__NO_SIDE_EFFECTS__*/
function strRight(value, count) {
return count <= 0 ? EMPTY : (value[LENGTH] > count ? strSlice(value, -count) : value);
}
var UNIQUE_REGISTRY_ID = "_urid";
var _polySymbols;
/*#__NO_SIDE_EFFECTS__*/
function _globalSymbolRegistry() {
if (!_polySymbols) {
var gblCfg = _getGlobalConfig();
_polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
}
return _polySymbols;
}
var _wellKnownSymbolCache;
/*#__NO_SIDE_EFFECTS__*/
function polyNewSymbol(description) {
var theSymbol = {
description: asString(description),
toString: function () { return SYMBOL + "(" + description + ")"; }
};
theSymbol[POLYFILL_TAG] = true;
return theSymbol;
}
/*#__NO_SIDE_EFFECTS__*/
function polySymbolFor(key) {
var registry = _globalSymbolRegistry();
if (!objHasOwn(registry.k, key)) {
var newSymbol_1 = polyNewSymbol(key);
var regId_1 = objKeys(registry.s).length;
newSymbol_1[UNIQUE_REGISTRY_ID] = function () { return regId_1 + "_" + newSymbol_1[TO_STRING](); };
registry.k[key] = newSymbol_1;
registry.s[newSymbol_1[UNIQUE_REGISTRY_ID]()] = asString(key);
}
return registry.k[key];
}
/*#__NO_SIDE_EFFECTS__*/
function polySymbolKeyFor(sym) {
if (!sym || !sym[TO_STRING] || strSubstring(sym[TO_STRING](), 0, 6) != SYMBOL) {
throwTypeError(sym + " is not a symbol");
}
var regId = sym[POLYFILL_TAG] && sym[UNIQUE_REGISTRY_ID] && sym[UNIQUE_REGISTRY_ID]();
return regId ? _globalSymbolRegistry().s[regId] : undefined;
}
/*#__NO_SIDE_EFFECTS__*/
function polyGetKnownSymbol(name) {
!_wellKnownSymbolCache && (_wellKnownSymbolCache = {});
var result;
var knownName = _wellKnownSymbolMap[name];
if (knownName) {
result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
}
return result;
}
var _globalLazyTestHooks;
function _initTestHooks() {
_globalLazyTestHooks = _getGlobalConfig();
}
/*#__NO_SIDE_EFFECTS__*/
function getLazy(cb) {
var lazyValue = {};
!_globalLazyTestHooks && _initTestHooks();
lazyValue.b = _globalLazyTestHooks.lzy;
objDefineProp(lazyValue, "v", {
configurable: true,
get: function () {
var result = cb();
if (!_globalLazyTestHooks.lzy) {
objDefineProp(lazyValue, "v", {
value: result
});
}
lazyValue.b = _globalLazyTestHooks.lzy;
return result;
}
});
return lazyValue;
}
function setBypassLazyCache(newValue) {
!_globalLazyTestHooks && _initTestHooks();
_globalLazyTestHooks.lzy = newValue;
}
function getWritableLazy(cb) {
var lazyValue = {};
!_globalLazyTestHooks && _initTestHooks();
lazyValue.b = _globalLazyTestHooks.lzy;
var _setValue = function (newValue) {
objDefineProp(lazyValue, "v", {
value: newValue,
writable: true
});
if (lazyValue.b) {
delete lazyValue.b;
}
};
objDefineProp(lazyValue, "v", {
configurable: true,
get: function () {
var result = cb();
if (!_globalLazyTestHooks.lzy) {
_setValue(result);
}
if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
lazyValue.b = _globalLazyTestHooks.lzy;
}
return result;
},
set: _setValue
});
return lazyValue;
}
/*#__NO_SIDE_EFFECTS__*/
function createCachedValue(value) {
return objDefineProp({
toJSON: function () { return value; }
}, "v", { value: value });
}
/*#__NO_SIDE_EFFECTS__*/
function createDeferredCachedValue(cb) {
var theValue = {
toJSON: function () { return theValue.v; }
};
return objDefineProp(theValue, "v", {
get: function () {
var result = cb();
cb = NULL_VALUE;
objDefineProp(theValue, "v", { value: result });
return result;
},
configurable: true
});
}
var WINDOW = "window";
var _cachedGlobal;
function _getGlobalInstFn(getFn, theArgs) {
var cachedValue;
return function () {
!_globalLazyTestHooks && _initTestHooks();
if (!cachedValue || _globalLazyTestHooks.lzy) {
cachedValue = createCachedValue(safe(getFn, theArgs).v);
}
return cachedValue.v;
};
}
/*#__NO_SIDE_EFFECTS__*/
function lazySafeGetInst(name) {
return getLazy(function () { return safe((getInst), [name]).v || UNDEF_VALUE; });
}
function getGlobal(useCached) {
!_globalLazyTestHooks && _initTestHooks();
if (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) {
_cachedGlobal = createCachedValue(safe(_getGlobalValue).v || NULL_VALUE);
}
return _cachedGlobal.v;
}
/*#__NO_SIDE_EFFECTS__*/
function getInst(name, useCached) {
var gbl;
if (!_cachedGlobal || useCached === false) {
gbl = getGlobal(useCached);
}
else {
gbl = _cachedGlobal.v;
}
if (gbl && gbl[name]) {
return gbl[name];
}
if (name === WINDOW) {
try {
return window;
}
catch (e) {
}
}
return NULL_VALUE;
}
/*#__NO_SIDE_EFFECTS__*/
function hasDocument() {
return !!( /*#__PURE__*/getDocument());
}
var getDocument = ( /*#__PURE__*/_getGlobalInstFn(getInst, ["document"]));
/*#__NO_SIDE_EFFECTS__*/
function hasWindow() {
return !!( /*#__PURE__*/getWindow());
}
var getWindow = ( /*#__PURE__*/_getGlobalInstFn(getInst, [WINDOW]));
/*#__NO_SIDE_EFFECTS__*/
function hasNavigator() {
return !!( /*#__PURE__*/getNavigator());
}
var getNavigator = ( /*#__PURE__*/_getGlobalInstFn(getInst, ["navigator"]));
/*#__NO_SIDE_EFFECTS__*/
function hasHistory() {
return !!( /*#__PURE__*/getHistory());
}
var getHistory = ( /*#__PURE__*/_getGlobalInstFn(getInst, ["history"]));
var isNode = ( /*#__PURE__*/_getGlobalInstFn(function () {
return !!( /*#__PURE__*/safe(function () { return (process && (process.versions || {}).node); }).v);
}));
var isWebWorker = ( /*#__PURE__*/_getGlobalInstFn(function () {
return !!( /*#__PURE__*/safe(function () { return self && self instanceof WorkerGlobalScope; }).v);
}));
var _symbol;
var _symbolFor;
var _symbolKeyFor;
/*#__NO_SIDE_EFFECTS__*/
function _initSymbol() {
_symbol = ( /*#__PURE__*/createCachedValue(safe((getInst), [SYMBOL]).v));
return _symbol;
}
function _getSymbolKey(key) {
var gblSym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
return (gblSym.v ? gblSym.v[key] : UNDEF_VALUE);
}
var isSymbol = ( /*#__PURE__*/_createIs("symbol"));
/*#__NO_SIDE_EFFECTS__*/
function hasSymbol() {
return !!( /*#__PURE__*/getSymbol());
}
/*#__NO_SIDE_EFFECTS__*/
function getSymbol() {
!_globalLazyTestHooks && _initTestHooks();
return ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol()).v;
}
/*#__NO_SIDE_EFFECTS__*/
function getKnownSymbol(name, noPoly) {
var knownName = _wellKnownSymbolMap[name];
!_globalLazyTestHooks && _initTestHooks();
var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
return sym.v ? sym.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
}
/*#__NO_SIDE_EFFECTS__*/
function newSymbol(description, noPoly) {
!_globalLazyTestHooks && _initTestHooks();
var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
return sym.v ? sym.v(description) : (!noPoly ? polyNewSymbol(description) : NULL_VALUE);
}
/*#__NO_SIDE_EFFECTS__*/
function symbolFor(key) {
!_globalLazyTestHooks && _initTestHooks();
_symbolFor = ((!_globalLazyTestHooks.lzy ? _symbolFor : 0) || ( /*#__PURE__*/createCachedValue(safe((_getSymbolKey), ["for"]).v)));
return (_symbolFor.v || polySymbolFor)(key);
}
/*#__NO_SIDE_EFFECTS__*/
function symbolKeyFor(sym) {
!_globalLazyTestHooks && _initTestHooks();
_symbolKeyFor = ((!_globalLazyTestHooks.lzy ? _symbolKeyFor : 0) || ( /*#__PURE__*/createCachedValue(safe((_getSymbolKey), ["keyFor"]).v)));
return (_symbolKeyFor.v || polySymbolKeyFor)(sym);
}
/*#__NO_SIDE_EFFECTS__*/
function isIterator(value) {
return !!value && isFunction(value.next);
}
/*#__NO_SIDE_EFFECTS__*/
function isIterable(value) {
return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);
}
var _iterSymbol$1;
function iterForOf(iter, callbackfn, thisArg) {
if (iter) {
if (!isIterator(iter)) {
!_iterSymbol$1 && (_iterSymbol$1 = createCachedValue(getKnownSymbol(3 )));
iter = iter[_iterSymbol$1.v] ? iter[_iterSymbol$1.v]() : NULL_VALUE;
}
if (isIterator(iter)) {
var err = UNDEF_VALUE;
var iterResult = UNDEF_VALUE;
try {
var count = 0;
while (!(iterResult = iter.next()).done) {
if (callbackfn[CALL](thisArg || iter, iterResult.value, count, iter) === -1) {
break;
}
count++;
}
}
catch (failed) {
err = { e: failed };
if (iter.throw) {
iterResult = NULL_VALUE;
iter.throw(err);
}
}
finally {
try {
if (iterResult && !iterResult.done) {
iter.return && iter.return(iterResult);
}
}
finally {
if (err) {
// eslint-disable-next-line no-unsafe-finally
throw err.e;
}
}
}
}
}
}
function fnApply(fn, thisArg, argArray) {
return fn.apply(thisArg, argArray);
}
function fnCall(fn, thisArg) {
return fn.apply(thisArg, ArrSlice[CALL](arguments, 2));
}
function fnBind(fn, thisArg) {
return fn.bind.apply(fn, ArrSlice[CALL](arguments, 1));
}
function arrAppend(target, elms) {
if (!isUndefined(elms) && target) {
if (isArray(elms)) {
fnApply(target.push, target, elms);
}
else if (isIterator(elms) || isIterable(elms)) {
iterForOf(elms, function (elm) {
target.push(elm);
});
}
else {
target.push(elms);
}
}
return target;
}
var arrEvery = /*#__PURE__*/ _unwrapFunction("every", ArrProto);
var arrFilter = /*#__PURE__*/ _unwrapFunction("filter", ArrProto);
function arrForEach(theArray, callbackfn, thisArg) {
if (theArray) {
var len = theArray[LENGTH] >>> 0;
for (var idx = 0; idx < len; idx++) {
if (idx in theArray) {
if (callbackfn[CALL](thisArg || theArray, theArray[idx], idx, theArray) === -1) {
break;
}
}
}
}
}
var arrIndexOf = ( /*#__PURE__*/_unwrapFunction("indexOf", ArrProto));
var arrLastIndexOf = ( /*#__PURE__*/_unwrapFunction("lastIndexOf", ArrProto));
var arrMap = ( /*#__PURE__*/_unwrapFunction("map", ArrProto));
function arrSlice(theArray, start, end) {
return ((theArray ? theArray["slice"] : NULL_VALUE) || ArrSlice).apply(theArray, ArrSlice[CALL](arguments, 1));
}
/*#__NO_SIDE_EFFECTS__*/
function polyIsArray(value) {
if (isNullOrUndefined(value)) {
return false;
}
return objToString(value) === "[object Array]";
}
/*#__NO_SIDE_EFFECTS__*/
function polyArrIncludes(theArray, searchElement, fromIndex) {
return arrIndexOf(theArray, searchElement, fromIndex) !== -1;
}
function polyArrFind(theArray, callbackFn, thisArg) {
var result;
var idx = polyArrFindIndex(theArray, callbackFn, thisArg);
return idx !== -1 ? theArray[idx] : result;
}
function polyArrFindIndex(theArray, callbackFn, thisArg) {
var result = -1;
arrForEach(theArray, function (value, index) {
if (callbackFn[CALL](thisArg | theArray, value, index, theArray)) {
result = index;
return -1;
}
});
return result;
}
function polyArrFindLast(theArray, callbackFn, thisArg) {
var result;
var idx = polyArrFindLastIndex(theArray, callbackFn, thisArg);
return idx !== -1 ? theArray[idx] : result;
}
function polyArrFindLastIndex(theArray, callbackFn, thisArg) {
var result = -1;
var len = theArray[LENGTH] >>> 0;
for (var idx = len - 1; idx >= 0; idx--) {
if (idx in theArray && callbackFn[CALL](thisArg | theArray, theArray[idx], idx, theArray)) {
result = idx;
break;
}
}
return result;
}
function polyArrFrom(theValue, mapFn, thisArg) {
if (isArray(theValue)) {
var result_1 = arrSlice(theValue);
return mapFn ? arrMap(result_1, mapFn, thisArg) : result_1;
}
var result = [];
iterForOf(theValue, function (value, cnt) {
return result.push(mapFn ? mapFn[CALL](thisArg, value, cnt) : value);
});
return result;
}
var arrFind = /*#__PURE__*/ _unwrapFunctionWithPoly("find", ArrProto, polyArrFind);
var arrFindIndex = /*#__PURE__*/ _unwrapFunctionWithPoly("findIndex", ArrProto, polyArrFindIndex);
var arrFindLast = /*#__PURE__*/ _unwrapFunctionWithPoly("findLast", ArrProto, polyArrFindLast);
var arrFindLastIndex = /*#__PURE__*/ _unwrapFunctionWithPoly("findLastIndex", ArrProto, polyArrFindLastIndex);
var arrFrom = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ArrCls, "from")), polyArrFrom));
var arrIncludes = ( /*#__PURE__*/_unwrapFunctionWithPoly("includes", ArrProto, polyArrIncludes));
var arrContains = arrIncludes;
var arrReduce = ( /*#__PURE__*/_unwrapFunction("reduce", ArrProto));
var arrSome = ( /*#__PURE__*/_unwrapFunction("some", ArrProto));
/*#__NO_SIDE_EFFECTS__*/
function createFnDeferredProxy(hostFn, funcName) {
return function () {
var theArgs = ArrSlice[CALL](arguments);
var theHost = hostFn();
return fnApply(theHost[funcName], theHost, theArgs);
};
}
function createProxyFuncs(target, host, funcDefs) {
if (target && host && isArray(funcDefs)) {
var isDeferred_1 = isFunction(host);
arrForEach(funcDefs, function (funcDef) {
var targetName = (funcDef.as || funcDef.n);
if (funcDef.rp === false && target[targetName]) {
return;
}
target[targetName] = isDeferred_1 ?
createFnDeferredProxy(host, funcDef.n) :
fnBind(host[funcDef.n], host);
});
}
return target;
}
var _iterSymbol;
/*#__NO_SIDE_EFFECTS__*/
function readArgs(theArgs, start, end) {
if (!objHasOwn(theArgs, LENGTH)) {
!_iterSymbol && (_iterSymbol = createCachedValue(hasSymbol() && getKnownSymbol(3 )));
var iterFn = void 0;
if (_iterSymbol.v) {
iterFn = theArgs[_iterSymbol.v];
}
if (iterFn) {
var values_1 = [];
var from_1 = (start === UNDEF_VALUE || start < 0) ? 0 : start;
var to_1 = end < 0 || start < 0 ? UNDEF_VALUE : end;
iterForOf(iterFn[CALL](theArgs), function (value, cnt) {
if (to_1 !== UNDEF_VALUE && cnt >= to_1) {
return -1;
}
if (cnt >= from_1) {
values_1.push(value);
}
});
if ((start === UNDEF_VALUE || start >= 0) && (end === UNDEF_VALUE || end >= 0)) {
return values_1;
}
theArgs = values_1;
}
}
return arrSlice(theArgs, start, end);
}
var objCreate = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ObjClass, "create")), polyObjCreate));
/*#__NO_SIDE_EFFECTS__*/
function polyObjCreate(obj) {
if (!obj) {
return {};
}
var type = typeof obj;
if (type !== OBJECT && type !== FUNCTION) {
throwTypeError("Prototype must be an Object or function: " + dumpObj(obj));
}
function tempFunc() { }
tempFunc[PROTOTYPE] = obj;
return new tempFunc();
}
var _isProtoArray;
function objSetPrototypeOf(obj, proto) {
var fn = ObjClass["setPrototypeOf"] ||
function (d, b) {
var _a;
!_isProtoArray && (_isProtoArray = createCachedValue((_a = {}, _a[__PROTO__] = [], _a) instanceof Array));
_isProtoArray.v ? d[__PROTO__] = b : objForEachKey(b, function (key, value) { return d[key] = value; });
};
return fn(obj, proto);
}
/*#__NO_SIDE_EFFECTS__*/
function _createCustomError(name, d, b) {
safe(objDefine, [d, NAME, { v: name, c: true, e: false }]);
d = objSetPrototypeOf(d, b);
function __() {
this[CONSTRUCTOR] = d;
safe(objDefine, [this, NAME, { v: name, c: true, e: false }]);
}
d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());
return d;
}
function _setName(baseClass, name) {
name && (baseClass[NAME] = name);
}
/*#__NO_SIDE_EFFECTS__*/
function createCustomError(name, constructCb, errorBase) {
var theBaseClass = errorBase || Error;
var orgName = theBaseClass[PROTOTYPE][NAME];
var captureFn = Error.captureStackTrace;
return _createCustomError(name, function () {
var _this = this;
var theArgs = arguments;
try {
safe(_setName, [theBaseClass, name]);
var _self = fnApply(theBaseClass, _this, ArrSlice[CALL](theArgs)) || _this;
if (_self !== _this) {
var orgProto = objGetPrototypeOf(_this);
if (orgProto !== objGetPrototypeOf(_self)) {
objSetPrototypeOf(_self, orgProto);
}
}
captureFn && captureFn(_self, _this[CONSTRUCTOR]);
constructCb && constructCb(_self, theArgs);
return _self;
}
finally {
safe(_setName, [theBaseClass, orgName]);
}
}, theBaseClass);
}
var _unsupportedError;
function throwUnsupported(message) {
if (!_unsupportedError) {
_unsupportedError = createCustomError("UnsupportedError");
}
throw new _unsupportedError(message);
}
/*#__NO_SIDE_EFFECTS__*/
function utcNow() {
return (Date.now || polyUtcNow)();
}
/*#__NO_SIDE_EFFECTS__*/
function polyUtcNow() {
return new Date().getTime();
}
/*#__NO_SIDE_EFFECTS__*/
function _createTrimFn(exp) {
return function _doTrim(value) {
if (isNullOrUndefined(value)) {
throwTypeError("strTrim called [" + dumpObj(value) + "]");
}
if (value && value.replace) {
value = value.replace(exp, EMPTY);
}
return value;
};
}
var polyStrTrim = ( /*#__PURE__*/_createTrimFn(/^\s+|(?=\s)\s+$/g));
var polyStrTrimStart = ( /*#__PURE__*/_createTrimFn(/^\s+/g));
var polyStrTrimEnd = ( /*#__PURE__*/_createTrimFn(/(?=\s)\s+$/g));
var strTrim = ( /*#__PURE__*/_unwrapFunctionWithPoly("trim", StrProto, polyStrTrim));
var strTrimStart = ( /*#__PURE__*/_unwrapFunctionWithPoly("trimStart", StrProto, polyStrTrimStart));
var strTrimLeft = ( /*#__PURE__*/_pureAssign(strTrimStart));
var strTrimEnd = ( /*#__PURE__*/_unwrapFunctionWithPoly("trimEnd", StrProto, polyStrTrimEnd));
var strTrimRight = ( /*#__PURE__*/_pureAssign(strTrimEnd));
var strUpper = ( /*#__PURE__*/_unwrapFunction("toUpperCase", StrProto));
var strLower = ( /*#__PURE__*/_unwrapFunction("toLowerCase", StrProto));
/*#__NO_SIDE_EFFECTS__*/
function _convertCase(value, newPrefix, upperWord) {
return strTrim(asString(value)).replace(/((_|\W)+(\w){0,1}|([a-z])([A-Z]))/g, function (_match, _g1, _g2, wordStart, upperPrefix, upperLetter) {
var convertMatch = wordStart || upperLetter || EMPTY;
if (upperWord) {
convertMatch = strUpper(convertMatch);
}
return (upperPrefix || EMPTY) + newPrefix + convertMatch;
});
}
/*#__NO_SIDE_EFFECTS__*/
function strLetterCase(value) {
return asString(value).replace(/(_|\b)\w/g, strUpper);
}
/*#__NO_SIDE_EFFECTS__*/
function strCamelCase(value, upperFirst) {
var result = _convertCase(value, "", true);
return result.replace(/^\w/, upperFirst ? strUpper : strLower);
}
/*#__NO_SIDE_EFFECTS__*/
function strKebabCase(value, scream) {
var result = _convertCase(value, "-");
return (scream ? strUpper : strLower)(result);
}
/*#__NO_SIDE_EFFECTS__*/
function strSnakeCase(value, scream) {
var result = _convertCase(value, "_");
return (scream ? strUpper : strLower)(result);
}
var mathFloor = ( /*#__PURE__*/_pureRef(MathCls, "floor"));
var mathCeil = ( /*#__PURE__*/_pureRef(MathCls, "ceil"));
var mathTrunc = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(MathCls, "trunc")), polyMathTrunc));
/*#__NO_SIDE_EFFECTS__*/
function polyMathTrunc(value) {
var theValue = +value;
return (theValue > 0 ? mathFloor : mathCeil)(theValue);
}
/*#__NO_SIDE_EFFECTS__*/
function mathToInt(value, throwInfinity) {
var result = +value;
if (result == Infinity && throwInfinity) {
throwRangeError("invalid value [" + dumpObj(value) + "]");
}
return result !== result || result === 0 ? 0 : mathTrunc(result);
}
var strRepeat = ( /*#__PURE__*/_unwrapFunctionWithPoly("repeat", StrProto, polyStrRepeat));
/*#__NO_SIDE_EFFECTS__*/
function polyStrRepeat(value, count) {
if (isNullOrUndefined(value)) {
throwTypeError("can't convert [" + dumpObj(value) + "]");
}
count = mathToInt(count, true);
if (count < 0) {
throwRangeError("invalid count must be >= 0 && < Infinity");
}
var pad = isString(value) ? value : asString(value);
var result = EMPTY;
for (; count > 0; (count >>>= 1) && (pad += pad)) {
if (count & 1) {
result += pad;
}
}
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function _padValue(value, targetLength, padString) {
var result = EMPTY;
targetLength = mathToInt(targetLength, true);
targetLength >>= 0;
var len = value[LENGTH];
if (len < targetLength) {
result = isNullOrUndefined(padString) ? " " : asString(padString);
targetLength = targetLength - len;
if (targetLength > result[LENGTH]) {
result = strRepeat(result, mathCeil(targetLength / result[LENGTH]));
}
if (result[LENGTH] > targetLength) {
result = strSubstring(result, 0, targetLength);
}
}
return result;
}
var strPadStart = ( /*#__PURE__*/_unwrapFunctionWithPoly("padStart", StrProto, polyStrPadStart));
var strPadEnd = ( /*#__PURE__*/_unwrapFunctionWithPoly("padEnd", StrProto, polyStrPadEnd));
/*#__NO_SIDE_EFFECTS__*/
function polyStrPadStart(value, targetLength, padString) {
return _padValue(value, targetLength, padString) + value;
}
/*#__NO_SIDE_EFFECTS__*/
function polyStrPadEnd(value, targetLength, padString) {
return value + _padValue(value, targetLength, padString);
}
var DBL_QUOTE = "\"";
var INVALID_JS_NAME = /([^\w\d_$])/g;
var _htmlEntityCache;
/*#__NO_SIDE_EFFECTS__*/
function normalizeJsName(jsName, camelCase) {
var result = asString(jsName).replace(INVALID_JS_NAME, "_");
return !isUndefined(camelCase) ? strCamelCase(result, !camelCase) : result;
}
/*#__NO_SIDE_EFFECTS__*/
function encodeAsJson(value, format) {
var result;
if (isString(value)) {
result = DBL_QUOTE + value.replace(/[^\w .,\-!@#$%\^&*\(\)_+={}\[\]:;|<>?]/g, function (match) {
if (match === DBL_QUOTE || match === "\\") {
return "\\" + match;
}
var hex = match.charCodeAt(0)[TO_STRING](16);
return "\\u" + strPadStart(strUpper(hex), 4, "0");
}) + DBL_QUOTE;
}
else {
try {
result = JSON.stringify(value, NULL_VALUE, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
}
catch (e) {
result = DBL_QUOTE + dumpObj(e) + DBL_QUOTE;
}
}
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function encodeAsHtml(value) {
!_htmlEntityCache && (_htmlEntityCache = {
"&": "amp",
"<": "lt",
">": "gt",
"\"": "quot",
"'": "#39"
});
return asString(value).replace(/[&<>"']/g, function (match) { return "&" + _htmlEntityCache[match] + ";"; });
}
var _fnToString;
var _objCtrFnString;
var _gblWindow;
/*#__NO_SIDE_EFFECTS__*/
function isPlainObject(value) {
if (!value || typeof value !== OBJECT) {
return false;
}
if (!_gblWindow) {
_gblWindow = hasWindow() ? getWindow() : true;
}
var result = false;
if (value !== _gblWindow) {
if (!_objCtrFnString) {
_fnToString = Function[PROTOTYPE][TO_STRING];
_objCtrFnString = _fnToString[CALL](ObjClass);
}
try {
var proto = objGetPrototypeOf(value);
result = !proto;
if (!result) {
if (objHasOwnProperty(proto, CONSTRUCTOR)) {
proto = proto[CONSTRUCTOR];
}
result = !!(proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString);
}
}
catch (ex) {
}
}
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function _defaultDeepCopyHandler(details) {
details.value && plainObjDeepCopyHandler(details);
return true;
}
var defaultDeepCopyHandlers = [
arrayDeepCopyHandler,
plainObjDeepCopyHandler,
functionDeepCopyHandler,
dateDeepCopyHandler
];
/*#__NO_SIDE_EFFECTS__*/
function _getSetVisited(visitMap, source, newPath, cb) {
var theEntry;
arrForEach(visitMap, function (entry) {
if (entry.k === source) {
theEntry = entry;
return -1;
}
});
if (!theEntry) {
theEntry = { k: source, v: source };
visitMap.push(theEntry);
cb(theEntry);
}
return theEntry.v;
}
function _deepCopy(visitMap, value, ctx, key) {
var userHandler = ctx.handler;
var newPath = ctx.path ? (key ? ctx.path.concat(key) : ctx.path) : [];
var newCtx = {
handler: ctx.handler,
src: ctx.src,
path: newPath
};
var theType = typeof value;
var isPlain = false;
var isPrim = value === NULL_VALUE;
if (!isPrim) {
if (value && theType === OBJECT) {
isPlain = isPlainObject(value);
}
else {
isPrim = isPrimitiveType(theType);
}
}
var details = {
type: theType,
isPrim: isPrim,
isPlain: isPlain,
value: value,
result: value,
path: newPath,
origin: ctx.src,
copy: function (source, newKey) {
return _deepCopy(visitMap, source, newKey ? newCtx : ctx, newKey);
},
copyTo: function (target, source) {
return _copyProps(visitMap, target, source, newCtx);
}
};
if (!details.isPrim) {
return _getSetVisited(visitMap, value, newPath, function (newEntry) {
objDefine(details, "result", {
g: function () {
return newEntry.v;
},
s: function (newValue) {
newEntry.v = newValue;
}
});
var idx = 0;
var handler = userHandler;
while (!(handler || (idx < defaultDeepCopyHandlers.length ? defaultDeepCopyHandlers[idx++] : _defaultDeepCopyHandler))[CALL](ctx, details)) {
handler = NULL_VALUE;
}
});
}
if (userHandler && userHandler[CALL](ctx, details)) {
return details.result;
}
return value;
}
function _copyProps(visitMap, target, source, ctx) {
if (!isNullOrUndefined(source)) {
for (var key in source) {
target[key] = _deepCopy(visitMap, source[key], ctx, key);
}
}
return target;
}
function objCopyProps(target, source, handler) {
var ctx = {
handler: handler,
src: source,
path: []
};
return _copyProps([], target, source, ctx);
}
/*#__NO_SIDE_EFFECTS__*/
function objDeepCopy(source, handler) {
var ctx = {
handler: handler,
src: source
};
return _deepCopy([], source, ctx);
}
function arrayDeepCopyHandler(details) {
var value = details.value;
if (isArray(value)) {
var target = details.result = [];
target.length = value.length;
details.copyTo(target, value);
return true;
}
return false;
}
function dateDeepCopyHandler(details) {
var value = details.value;
if (isDate(value)) {
details.result = new Date(value.getTime());
return true;
}
return false;
}
function functionDeepCopyHandler(details) {
if (details.type === FUNCTION) {
return true;
}
return false;
}
function plainObjDeepCopyHandler(details) {
var value = details.value;
if (value && details.isPlain) {
var target = details.result = {};
details.copyTo(target, value);
return true;
}
return false;
}
function _doExtend(target, theArgs) {
arrForEach(theArgs, function (theArg) {
objCopyProps(target, theArg);
});
return target;
}
function deepExtend(target, obj1, obj2, obj3, obj4, obj5, obj6) {
return _doExtend(objDeepCopy(target) || {}, ArrSlice[CALL](arguments));
}
function objExtend(target, obj1, obj2, obj3, obj4, obj5, obj6) {
return _doExtend(target || {}, ArrSlice[CALL](arguments));
}
var getLength = ( /*#__PURE__*/_unwrapProp(LENGTH));
/*#__NO_SIDE_EFFECTS__*/
function getIntValue(value, defValue) {
if (!isNullOrUndefined(value)) {
if (isNumber(value)) {
return value;
}
var theValue = parseInt(value, 10);
return isNaN(theValue) ? defValue : theValue;
}
return defValue;
}
var _perf;
/*#__NO_SIDE_EFFECTS__*/
function hasPerformance() {
return !!getPerformance();
}
/*#__NO_SIDE_EFFECTS__*/
function getPerformance() {
!_globalLazyTestHooks && _initTestHooks();
if (!_perf || _globalLazyTestHooks.lzy) {
_perf = createCachedValue(safe((getInst), ["performance"]).v);
}
return _perf.v;
}
/*#__NO_SIDE_EFFECTS__*/
function perfNow() {
var perf = getPerformance();
if (perf && perf.now) {
return perf.now();
}
return utcNow();
}
/*#__NO_SIDE_EFFECTS__*/
function elapsedTime(startTime) {
return perfNow() - startTime;
}
var MATCH_ANY = "(.*)";
var MATCH_SINGLE = "(.)";
function _createRegExp(value, escapeRgx, replaceFn, ignoreCase, fullMatch) {
// eslint-disable-next-line security/detect-non-literal-regexp
return new RegExp((fullMatch ? "^" : EMPTY) + replaceFn(value.replace(escapeRgx, "\\