@nevware21/ts-utils
Version:
Comprehensive TypeScript/JavaScript utility library with cross-environment support (Node.js, browser, web worker) providing helper functions, polyfills (ES5-ES2023), type checking utilities, and optimized implementations for better minification and code r
1,405 lines (1,335 loc) • 133 kB
JavaScript
/*! https://github.com/nevware21/ts-utils v0.14.0 */
/*
* 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 !== null && value !== undefined ? value[name] : undefined;
}
const UNDEF_VALUE = undefined;
const NULL_VALUE = null;
const EMPTY = "";
const FUNCTION = "function";
const OBJECT = "object";
const PROTOTYPE = "prototype";
const __PROTO__ = "__proto__";
const UNDEFINED = "undefined";
const CONSTRUCTOR = "constructor";
const SYMBOL = "Symbol";
const LENGTH = "length";
const NAME = "name";
const CALL = "call";
const TO_STRING = "toString";
const GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
const GET_OWN_PROPERTY_NAMES = "getOwnPropertyNames";
const GET_OWN_PROPERTY_SYMBOLS = "getOwnPropertySymbols";
const ObjClass = ( /*#__PURE__*/_pureAssign(Object));
const ObjProto = ( /*#__PURE__*/_pureRef(ObjClass, PROTOTYPE));
const StrCls = ( /*#__PURE__*/_pureAssign(String));
const StrProto = ( /*#__PURE__*/_pureRef(StrCls, PROTOTYPE));
const MathCls = ( /*#__PURE__*/_pureAssign(Math));
const ArrCls = ( /*#__PURE__*/_pureAssign(Array));
const ArrProto = ( /*#__PURE__*/_pureRef(ArrCls, PROTOTYPE));
const ArrSlice = ( /*#__PURE__*/_pureRef(ArrProto, "slice"));
const NumberCls = ( /*#__PURE__*/_pureAssign(Number));
const NumberProto = ( /*#__PURE__*/_pureRef(NumberCls, PROTOTYPE));
const FuncCls = ( /*#__PURE__*/_pureAssign(Function));
const FuncProto = ( /*#__PURE__*/_pureRef(FuncCls, PROTOTYPE));
const DateCls = ( /*#__PURE__*/_pureAssign(Date));
const DateProto = ( /*#__PURE__*/_pureRef(DateCls, PROTOTYPE));
const RegExpCls = ( /*#__PURE__*/_pureAssign(RegExp));
const RegExpProto = ( /*#__PURE__*/_pureRef(RegExpCls, PROTOTYPE));
const BooleanCls = ( /*#__PURE__*/_pureAssign(Boolean));
const BooleanProto = ( /*#__PURE__*/_pureRef(BooleanCls, PROTOTYPE));
const ErrorCls = ( /*#__PURE__*/_pureAssign(Error));
const ErrorProto = ( /*#__PURE__*/_pureRef(ErrorCls, PROTOTYPE));
const POLYFILL_TAG = "_polyfill";
const POLYFILL_TYPE_NAME = "__nw21$polytype__";
function _isPolyfill(obj) {
return !!(obj && obj[POLYFILL_TAG]);
}
function _isPolyfillType(obj, polyfillTypeName) {
return !!(obj && obj[POLYFILL_TYPE_NAME] === polyfillTypeName);
}
function safe(func, argArray) {
try {
return {
v: func.apply(this, argArray)
};
}
catch (e) {
return { e };
}
}
/*#__NO_SIDE_EFFECTS__*/
function safeGet(cb, defValue, argArray) {
let result = safe(cb, argArray);
return result.e ? defValue : result.v;
}
let _primitiveTypes;
/*#__NO_SIDE_EFFECTS__*/
function _createIs(theType) {
return function (value) {
return typeof value === theType;
};
}
/*#__NO_SIDE_EFFECTS__*/
function _createIsWithPoly(theType) {
return function (value) {
return typeof value === theType || _isPolyfillType(value, theType);
};
}
/*#__NO_SIDE_EFFECTS__*/
function _createObjIs(theName) {
const 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 arg === UNDEF_VALUE;
}
/*#__NO_SIDE_EFFECTS__*/
function isNullOrUndefined(value) {
return value === NULL_VALUE || isUndefined(value);
}
/*#__NO_SIDE_EFFECTS__*/
function isStrictNullOrUndefined(value) {
return value === NULL_VALUE || value === UNDEF_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);
}
const isString = ( /*#__PURE__*/_createIs("string"));
const isFunction = ( /*#__PURE__*/_createIs(FUNCTION));
const isAsyncFunction = ( /*#__PURE__*/_createObjIs("AsyncFunction"));
const isGenerator = ( /*#__PURE__*/_createObjIs("GeneratorFunction"));
const isAsyncGenerator = ( /*#__PURE__*/_createObjIs("AsyncGeneratorFunction"));
/*#__NO_SIDE_EFFECTS__*/
function isObject(value) {
if (!value && isNullOrUndefined(value)) {
return false;
}
return !!value && typeof value === OBJECT;
}
const isArray = ( /* #__PURE__*/_pureRef(ArrCls, "isArray"));
/*#__NO_SIDE_EFFECTS__*/
function isArrayLike(arg) {
return !isStrictNullOrUndefined(arg) && !isFunction(arg) && isNumber(arg[LENGTH]) && arg[LENGTH] >= 0;
}
const isDate = ( /*#__PURE__*/_createObjIs("Date"));
const isNumber = ( /*#__PURE__*/_createIs("number"));
const isBoolean = ( /*#__PURE__*/_createIs("boolean"));
const isRegExp = ( /*#__PURE__*/_createObjIs("RegExp"));
const isFile = ( /*#__PURE__*/_createObjIs("File"));
const isFormData = ( /*#__PURE__*/_createObjIs("FormData"));
const isBlob = ( /*#__PURE__*/_createObjIs("Blob"));
const isArrayBuffer = ( /*#__PURE__*/_createObjIs("ArrayBuffer"));
const isError = ( /*#__PURE__*/_createObjIs("Error"));
/*#__NO_SIDE_EFFECTS__*/
function isPromiseLike(value) {
return !!(value && value.then && isFunction(value.then));
}
const isThenable = isPromiseLike;
/*#__NO_SIDE_EFFECTS__*/
function isPromise(value) {
return !!(value && value.then && value.catch && isFunction(value.then) && isFunction(value.catch));
}
const isMap = ( /*#__PURE__*/_createObjIs("Map"));
const isWeakMap = ( /*#__PURE__*/_createObjIs("WeakMap"));
const isSet = ( /*#__PURE__*/_createObjIs("Set"));
const isWeakSet = ( /*#__PURE__*/_createObjIs("WeakSet"));
/*#__NO_SIDE_EFFECTS__*/
function isMapLike(value) {
return !!(value &&
isFunction(value.get) &&
isFunction(value.set) &&
isFunction(value.has) &&
isFunction(value.delete) &&
isNumber(value.size));
}
function isSetLike(value) {
return !!(value &&
isFunction(value.add) &&
isFunction(value.has) &&
isFunction(value.delete) &&
isNumber(value.size));
}
/*#__NO_SIDE_EFFECTS__*/
function isNotTruthy(value) {
return !value || !isTruthy(value);
}
/*#__NO_SIDE_EFFECTS__*/
function isTruthy(value) {
return !(!value || safeGet(() => !(value && (0 + value)), !value));
}
const isBigInt = ( /*#__PURE__*/_createIsWithPoly("bigint"));
function _returnNothing() {
return;
}
function _returnEmptyArray() {
return [];
}
function _returnFalse() {
return false;
}
const asString = ( /*#__PURE__*/_pureAssign(StrCls));
const ERROR_TYPE = "[object Error]";
/*#__NO_SIDE_EFFECTS__*/
function dumpObj(object, format) {
let propertyValueDump = EMPTY;
const 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);
}
function _throwIfNullOrUndefined(obj) {
if (isStrictNullOrUndefined(obj)) {
throwTypeError("Cannot convert undefined or null to object");
}
}
function _throwIfNotString(value) {
if (!isString(value)) {
throwTypeError("'" + dumpObj(value) + "' is not a string");
}
}
/*#__NO_SIDE_EFFECTS__*/
function objHasOwnProperty(obj, prop) {
return !!obj && ObjProto.hasOwnProperty[CALL](obj, prop);
}
const _objGetOwnPropertyDescriptor$2 = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
const objHasOwn = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, "hasOwn")), polyObjHasOwn));
/*#__NO_SIDE_EFFECTS__*/
function polyObjHasOwn(obj, prop) {
_throwIfNullOrUndefined(obj);
return objHasOwnProperty(obj, prop) || !!_objGetOwnPropertyDescriptor$2(obj, prop);
}
/*#__NO_SIDE_EFFECTS__*/
function isUnsafePropKey(key) {
return key === __PROTO__ || key === CONSTRUCTOR || key === PROTOTYPE;
}
function objForEachKey(theObject, callbackfn, thisArg) {
if (theObject && (isObject(theObject) || isFunction(theObject))) {
for (const prop in theObject) {
if (objHasOwn(theObject, prop)) {
if (callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? theObject : thisArg, prop, theObject[prop]) === -1) {
break;
}
}
}
}
}
function objForEachKeySafe(theObject, callbackfn, thisArg) {
objForEachKey(theObject, (key, value) => {
if (!isUnsafePropKey(key)) {
return callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? theObject : thisArg, key, value);
}
}, thisArg);
}
function arrForEach(theArray, callbackfn, thisArg) {
if (theArray) {
const len = theArray[LENGTH] >>> 0;
for (let idx = 0; idx < len; idx++) {
if (idx in theArray) {
if (callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? theArray : thisArg, theArray[idx], idx, theArray) === -1) {
break;
}
}
}
}
}
const _unwrapFunction = _unwrapFunctionWithPoly;
/*#__NO_SIDE_EFFECTS__*/
function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
let clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
return function (thisArg) {
let theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || clsFn;
if (theFunc || polyFunc) {
let 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 _unwrapFunctionNoInstWithPoly(funcName, clsProto, polyFunc) {
let clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
return function (thisArg) {
let theFunc = clsFn;
if (theFunc || polyFunc) {
let 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];
};
}
function _objPropertyIsEnum(obj, propKey) {
let desc;
let fn = ObjClass.getOwnPropertyDescriptor;
if (!isStrictNullOrUndefined(obj) && fn) {
desc = safe(fn, [obj, propKey]).v || NULL_VALUE;
}
if (!desc && !isStrictNullOrUndefined(obj)) {
desc = safe(() => {
for (const key in obj) {
if (key == propKey) {
return { enumerable: objHasOwnProperty(obj, key) };
}
}
}).v;
}
return (desc && desc.enumerable) || false;
}
const objPropertyIsEnumerable = ( /*#__PURE__*/_unwrapFunctionWithPoly("propertyIsEnumerable", NULL_VALUE, _objPropertyIsEnum));
const _objPropertyIsEnumerable = ( /*#__PURE__*/_unwrapFunctionNoInstWithPoly("propertyIsEnumerable", ObjProto, _objPropertyIsEnum));
const _objGetOwnPropertyDescriptor$1 = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
const _objGetOwnPropertySymbols = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
const propMap = {
e: "enumerable",
c: "configurable",
v: "value",
w: "writable",
g: "get",
s: "set"
};
/*#__NO_SIDE_EFFECTS__*/
function _createProp(value) {
let prop = {};
prop[propMap["c"]] = true;
prop[propMap["e"]] = true;
if (value.l) {
prop.get = () => value.l.v;
let desc = _objGetOwnPropertyDescriptor$1(value.l, "v");
if (desc && desc.set) {
prop.set = (newValue) => {
value.l.v = newValue;
};
}
}
objForEachKey(value, (key, value) => {
prop[propMap[key]] = isStrictUndefined(value) ? prop[propMap[key]] : value;
});
return prop;
}
const objDefineProp = ( /*#__PURE__*/_pureRef(ObjClass, "defineProperty"));
const objDefineProperties = ( /*#__PURE__*/_pureRef(ObjClass, "defineProperties"));
function objDefineGet(target, key, value, configurable, enumerable) {
return objDefineProp(target, key, _createProp({
e: enumerable,
c: configurable,
[isFunction(value) ? "g" : "v"]: value
}));
}
function objDefineAccessors(target, prop, getProp, setProp, configurable, enumerable) {
let 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) {
let props = {};
objForEachKey(propDescMap, (key, value) => {
props[key] = _createProp(value);
});
arrForEach(_objGetOwnPropertySymbols(propDescMap), (sym) => {
if (_objPropertyIsEnumerable(propDescMap, sym)) {
props[sym] = _createProp(propDescMap[sym]);
}
});
return objDefineProperties(target, props);
}
/*#__NO_SIDE_EFFECTS__*/
function _createKeyValueMap(values, keyType, valueType, completeFn, writable) {
let theMap = {};
objForEachKey(values, (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
});
}
function _objIterateEntries(obj, mapper) {
const result = [];
objForEachKey(obj, (key, val) => {
result.push(mapper(key, val));
});
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function polyObjKeys(obj) {
_throwIfNullOrUndefined(obj);
if (!isObject(obj)) {
throwTypeError("non-object " + dumpObj(obj));
}
return _objIterateEntries(obj, (k, _) => k);
}
/*#__NO_SIDE_EFFECTS__*/
function polyObjEntries(value) {
return _objIterateEntries(value, (k, v) => [k, v]);
}
/*#__NO_SIDE_EFFECTS__*/
function polyObjValues(value) {
return _objIterateEntries(value, (_, v) => v);
}
function polyObjIs(value1, value2) {
if (value1 !== value1) {
return value2 !== value2;
}
if (value1 === 0 && value2 === 0) {
return 1 / value1 === 1 / value2;
}
return value1 === value2;
}
const objIsFrozen = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, "isFrozen")), _returnFalse));
const objIsSealed = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, "isSealed")), _returnFalse));
const _objFreeze = ( /*#__PURE__*/_pureRef(ObjClass, "freeze"));
function _doNothing(value) {
return value;
}
/*#__NO_SIDE_EFFECTS__*/
function _getProto(value) {
_throwIfNullOrUndefined(value);
return value[__PROTO__] || NULL_VALUE;
}
const objAssign = ( /*#__PURE__*/_pureRef(ObjClass, "assign"));
const objKeys = ( /*#__PURE__*/_pureRef(ObjClass, "keys"));
function _deepFreeze(val, visited) {
if ((isArray(val) || isObject(val) || isFunction(val)) && !objIsFrozen(val)) {
for (let lp = 0; lp < visited.length; lp++) {
if (visited[lp] === val) {
return val;
}
}
visited.push(val);
objForEachKey(val, (_key, propValue) => {
_deepFreeze(propValue, visited);
});
objFreeze(val);
}
return val;
}
function objDeepFreeze(value) {
return _objFreeze ? _deepFreeze(value, []) : value;
}
const objFreeze = ( /*#__PURE__*/_pureAssign(_objFreeze, _doNothing));
const objSeal = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, "seal")), _doNothing));
const objGetPrototypeOf = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, "getPrototypeOf")), _getProto));
const objEntries = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, "entries")), polyObjEntries));
const objValues = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, "values")), polyObjValues));
const objIs = ( /*#__PURE__*/_pureAssign(( /*#__PURE__*/_pureRef(ObjClass, "is")), polyObjIs));
/*#__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) {
let mapClass = {};
objForEachKey(values, (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);
}
const _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
}));
const GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
let _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) {
let gbl = safe(_getGlobalValue).v || {};
_globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};
}
return _globalCfg;
}
const mathMin = ( /*#__PURE__*/_pureRef(MathCls, "min"));
const mathMax = ( /*#__PURE__*/_pureRef(MathCls, "max"));
const strSlice = ( /*#__PURE__*/_unwrapFunction("slice", StrProto));
const strSubstring = ( /*#__PURE__*/_unwrapFunction("substring", StrProto));
const strSubstr = ( /*#__PURE__*/_unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr));
/*#__NO_SIDE_EFFECTS__*/
function polyStrSubstr(value, start, length) {
_throwIfNullOrUndefined(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);
}
function _tagAsPolyfill(target, polyfillTypeName) {
if (target) {
safe(() => {
target[POLYFILL_TAG] = true;
target[POLYFILL_TYPE_NAME] = polyfillTypeName;
});
safe(objDefine, [target, POLYFILL_TAG, {
v: true,
w: false,
e: false
}]);
safe(objDefine, [target, POLYFILL_TYPE_NAME, {
v: polyfillTypeName,
w: false,
e: false
}]);
}
return target;
}
const objCreate = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ObjClass, "create")), polyObjCreate));
/*#__NO_SIDE_EFFECTS__*/
function polyObjCreate(obj, properties) {
let newObj = null;
function tempFunc() { }
if (!isStrictNullOrUndefined(obj)) {
let type = typeof obj;
if (type !== OBJECT && type !== FUNCTION) {
throwTypeError("Prototype must be an Object or function: " + dumpObj(obj));
}
tempFunc[PROTOTYPE] = obj;
safe(() => {
tempFunc[__PROTO__] = obj;
});
newObj = new tempFunc();
}
else {
newObj = {};
}
if (properties) {
safe(objDefineProperties, [newObj, properties]);
}
return newObj;
}
/*#__NO_SIDE_EFFECTS__*/
function utcNow() {
return (Date.now || polyUtcNow)();
}
/*#__NO_SIDE_EFFECTS__*/
function polyUtcNow() {
return new Date().getTime();
}
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));
}
let _globalLazyTestHooks;
function _initTestHooks() {
_globalLazyTestHooks = _getGlobalConfig();
}
/*#__NO_SIDE_EFFECTS__*/
function getLazy(cb, argArray) {
let lazyValue = {};
!_globalLazyTestHooks && _initTestHooks();
lazyValue.b = _globalLazyTestHooks.lzy;
objDefineProp(lazyValue, "v", {
configurable: true,
get: function () {
let result = fnApply(cb, null, argArray);
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, argArray) {
let lazyValue = {};
!_globalLazyTestHooks && _initTestHooks();
lazyValue.b = _globalLazyTestHooks.lzy;
let _setValue = (newValue) => {
objDefineProp(lazyValue, "v", {
value: newValue,
writable: true
});
if (lazyValue.b) {
delete lazyValue.b;
}
};
objDefineProp(lazyValue, "v", {
configurable: true,
get: function () {
let result = fnApply(cb, null, argArray);
if (!_globalLazyTestHooks.lzy) {
_setValue(result);
}
if (_globalLazyTestHooks.lzy && lazyValue.b !== _globalLazyTestHooks.lzy) {
lazyValue.b = _globalLazyTestHooks.lzy;
}
return result;
},
set: _setValue
});
return lazyValue;
}
const mathRandom = ( /*#__PURE__*/_pureRef(MathCls, "random"));
let _uniqueInstanceId = ( /*#__PURE__*/getLazy(() => {
let value = (utcNow().toString(36).slice(2));
while (value.length < 16) {
value += mathRandom().toString(36).slice(2);
}
value = value.substring(0, 16);
return value;
}));
const UNIQUE_REGISTRY_ID = "_urid";
const POLY_SYM = "$nw21sym";
let _polySymbols;
let _polyId = 0;
/*#__NO_SIDE_EFFECTS__*/
function _globalSymbolRegistry() {
if (!_polySymbols) {
let gblCfg = _getGlobalConfig();
_polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };
}
return _polySymbols;
}
let _wellKnownSymbolCache;
/*#__NO_SIDE_EFFECTS__*/
function polyNewSymbol(description) {
const uniqueId = "_" + _polyId++ + "_" + _uniqueInstanceId.v;
const symString = SYMBOL + "(" + description + ")";
function _setProp(name, value) {
objDefine(theSymbol, name, {
v: value,
e: false,
w: false
});
}
let theSymbol = objCreate(null);
_setProp("description", asString(description));
_setProp(TO_STRING, () => symString + POLY_SYM + uniqueId);
_setProp("valueOf", () => theSymbol);
_setProp("v", symString);
_setProp("_uid", uniqueId);
return _tagAsPolyfill(theSymbol, "symbol");
}
/*#__NO_SIDE_EFFECTS__*/
function polySymbolFor(key) {
let registry = _globalSymbolRegistry();
if (!objHasOwn(registry.k, key)) {
let newSymbol = polyNewSymbol(key);
let regId = objKeys(registry.s).length;
newSymbol[UNIQUE_REGISTRY_ID] = () => regId + "_" + newSymbol[TO_STRING]();
registry.k[key] = newSymbol;
registry.s[newSymbol[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");
}
const regId = _isPolyfill(sym) && sym[UNIQUE_REGISTRY_ID] && sym[UNIQUE_REGISTRY_ID]();
return regId ? _globalSymbolRegistry().s[regId] : undefined;
}
/*#__NO_SIDE_EFFECTS__*/
function polyGetKnownSymbol(name) {
!_wellKnownSymbolCache && (_wellKnownSymbolCache = {});
let result;
let knownName = _wellKnownSymbolMap[name];
if (knownName) {
result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
}
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function createCachedValue(value) {
return objDefineProp({
toJSON: () => value
}, "v", { value });
}
const createDeferredCachedValue = getDeferred;
/*#__NO_SIDE_EFFECTS__*/
function getDeferred(cb, argArray) {
let theValue = {
toJSON: () => theValue.v
};
return objDefineProp(theValue, "v", {
get: () => {
let result = fnApply(cb, null, argArray);
cb = NULL_VALUE;
objDefineProp(theValue, "v", { value: result });
return result;
},
configurable: true
});
}
/*#__NO_SIDE_EFFECTS__*/
function getWritableDeferred(cb, argArray) {
let theValue = {
toJSON: () => theValue.v
};
let _setValue = (newValue) => {
objDefineProp(theValue, "v", {
value: newValue,
writable: true
});
};
return objDefineProp(theValue, "v", {
get: () => {
let result = fnApply(cb, null, argArray);
_setValue(result);
cb = NULL_VALUE;
return result;
},
set: _setValue,
configurable: true
});
}
const WINDOW = "window";
let _cachedGlobal;
function _getGlobalInstFn(getFn, theArgs) {
let 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(() => 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) {
let 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());
}
const getDocument = ( /*#__PURE__*/_getGlobalInstFn(getInst, ["document"]));
/*#__NO_SIDE_EFFECTS__*/
function hasWindow() {
return !!( /*#__PURE__*/getWindow());
}
const getWindow = ( /*#__PURE__*/_getGlobalInstFn(getInst, [WINDOW]));
/*#__NO_SIDE_EFFECTS__*/
function hasNavigator() {
return !!( /*#__PURE__*/getNavigator());
}
const getNavigator = ( /*#__PURE__*/_getGlobalInstFn(getInst, ["navigator"]));
/*#__NO_SIDE_EFFECTS__*/
function hasHistory() {
return !!( /*#__PURE__*/getHistory());
}
const getHistory = ( /*#__PURE__*/_getGlobalInstFn(getInst, ["history"]));
const isNode = ( /*#__PURE__*/_getGlobalInstFn(() => {
return !!( /*#__PURE__*/safe(() => (process && (process.versions || {}).node)).v);
}));
const isWebWorker = ( /*#__PURE__*/_getGlobalInstFn(() => {
return !!( /*#__PURE__*/safe(() => self && self instanceof WorkerGlobalScope).v);
}));
let _symbol;
let _symbolFor;
let _symbolKeyFor;
/*#__NO_SIDE_EFFECTS__*/
function _initSymbol() {
_symbol = ( /*#__PURE__*/createCachedValue(safe((getInst), [SYMBOL]).v));
return _symbol;
}
function _getSymbolKey(key) {
let gblSym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
return (gblSym.v ? gblSym.v[key] : UNDEF_VALUE);
}
const isSymbol = ( /*#__PURE__*/_createIsWithPoly("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) {
let knownName = _wellKnownSymbolMap[name];
!_globalLazyTestHooks && _initTestHooks();
let 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();
let 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 )]);
}
/*#__NO_SIDE_EFFECTS__*/
function isAsyncIterable(value) {
return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(0 )]);
}
let _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)) {
let err = UNDEF_VALUE;
let iterResult = UNDEF_VALUE;
try {
let count = 0;
while (!(iterResult = iter.next()).done) {
if (callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? iter : thisArg, 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) {
throw err.e;
}
}
}
}
}
}
function arrAppend(target, elms) {
if (!isUndefined(elms) && target) {
if (isArray(elms)) {
fnApply(target.push, target, elms);
}
else if (isIterator(elms) || isIterable(elms)) {
iterForOf(elms, (elm) => {
target.push(elm);
});
}
else {
target.push(elms);
}
}
return target;
}
const arrAt = /*#__PURE__*/ _unwrapFunctionWithPoly("at", ArrProto, polyArrAt);
/*#__NO_SIDE_EFFECTS__*/
function polyArrAt(theArray, index) {
let result;
if (isArrayLike(theArray)) {
const len = theArray.length;
let idx = index;
if (idx < 0) {
idx = len + idx;
}
if (idx >= 0 && idx < len) {
result = theArray[idx];
}
}
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function arrChunk(theArray, size) {
const result = [];
if (isArrayLike(theArray) && size > 0) {
let idx = 0;
let chunkIdx = -1;
arrForEach(theArray, (item) => {
if (idx % size === 0) {
result.push([]);
chunkIdx++;
}
result[chunkIdx].push(item);
idx++;
});
}
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function arrCompact(theArray) {
const result = [];
if (isArrayLike(theArray)) {
arrForEach(theArray, (item) => {
if (item) {
result.push(item);
}
});
}
return result;
}
const arrIndexOf = ( /*#__PURE__*/_unwrapFunction("indexOf", ArrProto));
const arrLastIndexOf = ( /*#__PURE__*/_unwrapFunction("lastIndexOf", ArrProto));
const 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) {
let result;
let idx = polyArrFindIndex(theArray, callbackFn, thisArg);
return idx !== -1 ? theArray[idx] : result;
}
function polyArrFindIndex(theArray, callbackFn, thisArg) {
let result = -1;
arrForEach(theArray, (value, index) => {
if (callbackFn[CALL](isStrictNullOrUndefined(thisArg) ? theArray : thisArg, value, index, theArray)) {
result = index;
return -1;
}
});
return result;
}
function polyArrFindLast(theArray, callbackFn, thisArg) {
let result;
let idx = polyArrFindLastIndex(theArray, callbackFn, thisArg);
return idx !== -1 ? theArray[idx] : result;
}
function polyArrFindLastIndex(theArray, callbackFn, thisArg) {
let result = -1;
let len = theArray[LENGTH] >>> 0;
for (let idx = len - 1; idx >= 0; idx--) {
if (idx in theArray && callbackFn[CALL](isStrictNullOrUndefined(thisArg) ? theArray : thisArg, theArray[idx], idx, theArray)) {
result = idx;
break;
}
}
return result;
}
function polyArrFrom(theValue, mapFn, thisArg) {
if (isArray(theValue)) {
let result = arrSlice(theValue);
return mapFn ? arrMap(result, mapFn, thisArg) : result;
}
let result = [];
iterForOf(theValue, (value, cnt) => {
return result.push(mapFn ? mapFn[CALL](thisArg, value, cnt) : value);
});
return result;
}
const arrIncludes = ( /*#__PURE__*/_unwrapFunctionWithPoly("includes", ArrProto, polyArrIncludes));
const arrContains = arrIncludes;
/*#__NO_SIDE_EFFECTS__*/
function arrDifference(theArray, ...excludeArrays) {
let result = [];
if (isArrayLike(theArray)) {
arrForEach(theArray, (item) => {
let excluded = false;
for (let lp = 0; lp < excludeArrays.length; lp++) {
let exclValue = excludeArrays[lp];
if (isArrayLike(exclValue) && arrIncludes(exclValue, item)) {
excluded = true;
break;
}
}
if (!excluded) {
result.push(item);
}
});
}
return result;
}
/*#__NO_SIDE_EFFECTS__*/
function arrDrop(theArray, count) {
return arrSlice(theArray, mathMax(0, count));
}
/*#__NO_SIDE_EFFECTS__*/
function arrDropWhile(theArray, callbackFn, thisArg) {
let result;
if (isArrayLike(theArray)) {
arrForEach(theArray, (item, index) => {
if (!fnCall(callbackFn, thisArg, item, index, theArray)) {
result = arrSlice(theArray, index);
return -1;
}
});
}
return result || [];
}
const arrEvery = /*#__PURE__*/ _unwrapFunction("every", ArrProto);
const arrFilter = /*#__PURE__*/ _unwrapFunction("filter", ArrProto);
const getLength = ( /*#__PURE__*/_unwrapProp(LENGTH));
const arrFill = /*#__PURE__*/ _unwrapFunctionWithPoly("fill", ArrProto, polyArrFill);
/*#__NO_SIDE_EFFECTS__*/
function polyArrFill(theArray, value, start, end) {
if (isArrayLike(theArray)) {
const len = getLength(theArray);
let startIdx = start === UNDEF_VALUE ? 0 : start;
let endIdx = end === UNDEF_VALUE ? len : end;
if (startIdx < 0) {
startIdx = mathMax(len + startIdx, 0);
}
else {
startIdx = mathMin(startIdx, len);
}
if (endIdx < 0) {
endIdx = mathMax(len + endIdx, 0);
}
else {
endIdx = mathMin(endIdx, len);
}
for (let i = startIdx; i < endIdx; i++) {
theArray[i] = value;
}
}
return theArray;
}
const arrFind = /*#__PURE__*/ _unwrapFunctionWithPoly("find", ArrProto, polyArrFind);
const arrFindIndex = /*#__PURE__*/ _unwrapFunctionWithPoly("findIndex", ArrProto, polyArrFindIndex);
const arrFindLast = /*#__PURE__*/ _unwrapFunctionWithPoly("findLast", ArrProto, polyArrFindLast);
const arrFindLastIndex = /*#__PURE__*/ _unwrapFunctionWithPoly("findLastIndex", ArrProto, polyArrFindLastIndex);
const arrFlatMap = /*#__PURE__*/ _unwrapFunctionWithPoly("flatMap", ArrProto, polyArrFlatMap);
/*#__NO_SIDE_EFFECTS__*/
function polyArrFlatMap(theArray, callbackFn, thisArg) {
_throwIfNullOrUndefined(theArray);
if (!isFunction(callbackFn)) {
throwTypeError("callbackFn must be a function");
}
let result = [];
let callbackThis = arguments.length > 2 ? thisArg : undefined;
arrForEach(theArray, (theValue, index) => {
let value = fnCall(callbackFn, callbackThis, theValue, index, theArray);
if (isArray(value)) {
arrForEach(value, (mappedValue) => {
result.push(mappedValue);
});
}
else {
result.push(value);
}
});
return result;
}
function _addItems(result, arr, d) {
const arrLen = arr.length;
let arrIdx = 0;
while (arrIdx < arrLen) {
const item = arr[arrIdx];
if (d > 0 && isArray(item)) {
_addItems(result, item, d - 1);
}
else {
result.push(item);
}
arrIdx++;
}
}
/*#__NO_SIDE_EFFECTS__*/
function arrFlatten(theArray, depth) {
const result = [];
if (isArrayLike(theArray)) {
const d = isUndefined(depth) ? 1 : depth;
arrForEach(theArray, (item) => {
if (d > 0 && isArray(item)) {
_addItems(result, item, d - 1);
}
else {
result.push(item);
}
});
}
return result;
}
const arrFrom = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ArrCls, "from")), polyArrFrom));
/*#__NO_SIDE_EFFECTS__*/
function arrGroupBy(theArray, callbackFn, thisArg) {
const result = {};
if (isArrayLike(theArray) && isFunction(callbackFn)) {
arrForEach(theArray, (item, idx) => {
const keyVal = callbackFn.call(thisArg, item, idx, theArray);
const theKey = isSymbol(keyVal) ? keyVal : asString(keyVal);
if (!objHasOwn(result, theKey)) {
if (isUnsafePropKey(theKey)) {
objDefine(result, theKey, { v: [] });
}
else {
result[theKey] = [];
}
}
result[theKey].push(item);
});
}
return result;
}
function arrIntersection() {
const result = [];
let theArrays = arguments;
if (theArrays.length > 0) {
const firstArray = theArrays[0];
if (isArrayLike(firstArray)) {
arrForEach(firstArray, (item) => {
let inAll = true;
arrForEach(theArrays, (arr, index) => {
if (index > 0 && !arrIncludes(arr, item)) {
inAll = false;
return -1;
}
});
if (inAll && !arrIncludes(result, item)) {
result.push(item);
}
});
}
}
return result;
}
const mathFloor = ( /*#__PURE__*/_pureRef(MathCls, "floor"));
const mathCeil = ( /*#__PURE__*/_pureRef(MathCls, "ceil"));
const mathTrunc = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(MathCls, "trunc")), polyMathTrunc));
/*#__NO_SIDE_EFFECTS__*/
function polyMathTrunc(value) {
let theValue = +value;
return (theValue > 0 ? mathFloor : mathCeil)(theValue);
}
/*#__NO_SIDE_EFFECTS__*/
function mathToInt(value, throwInfinity) {
let result = +value;
if (throwInfinity && (result === Infinity || result == Infinity)) {
throwRangeError("invalid value [" + dumpObj(value) + "]");
}
return result !== result || result === 0 ? 0 : mathTrunc(result);
}
/*#__NO_SIDE_EFFECTS__*/
function arrIndexKeys(value) {
_throwIfNullOrUndefined(value);
let keys = [];
let len = mathToInt(getLength(value));
if (len > 0) {
for (let lp = 0; lp < len; lp++) {
if (objHasOwn(value, lp)) {
keys.push(lp);
}
}
}
return keys;
}
/*#__NO_SIDE_EFFECTS__*/
function createIterable(ctx) {
return makeIterable({}, ctx);
}
function makeIterable(target, ctx) {
let itSymbol = getKnownSymbol(3 );
function _createIterator() {
return createIterator(ctx);
}
target[itSymbol] = _createIterator;
return target;
}
/*#__NO_SIDE_EFFECTS__*/
function createIterableIterator(ctx) {
let iterator = createIterator(ctx);
let itSymbol = getKnownSymbol(3 );
function _createIterator() {
return iterator;
}
iterator[itSymbol] = _createIterator;
return iterator;
}
/*#__NO_SIDE_EFFECTS__*/
function createIterator(ctx) {
let isDone = false;
function _value() {
return ctx.v;
}
function _next() {
if (!isDone) {
isDone = (ctx.n ? ctx.n(arguments) : true);