{"version":3,"sources":["../../../../node_modules/.pnpm/@microsoft+load-themed-styles@1.10.295/node_modules/@microsoft/load-themed-styles/lib-es6/index.js","../../../../node_modules/.pnpm/@nevware21+ts-async@0.5.2/node_modules/@nevware21/ts-async/dist/es5/mod/ts-async.js","../../../../node_modules/.pnpm/@microsoft+dynamicproto-js@2.0.3/node_modules/@microsoft/dynamicproto-js/dist-es5/DynamicProto.js","../../../../node_modules/.pnpm/@microsoft+dynamicproto-js@1.1.11/node_modules/@microsoft/dynamicproto-js/lib/dist/esm/dynamicproto-js.js","../../../../node_modules/.pnpm/@nevware21+ts-utils@0.11.4/node_modules/@nevware21/ts-utils/dist/es5/mod/ts-utils.js"],"names":["global","__webpack_require__","d","__webpack_exports__","loadStyles","loadTheme","__assign","Object","assign","t","s","i","n","arguments","length","p","prototype","hasOwnProperty","call","apply","this","_root","window","_styleNonce","CSPSettings","nonce","_themeState","state","__themeState__","theme","undefined","lastStyleElement","registeredStyles","runState","perf","count","duration","flushTimer","mode","buffer","registeredThemableStyles","initializeThemeState","_themeTokenRegex","now","performance","Date","measure","func","start","end","styles","loadAsync","styleParts","Array","isArray","splitStyles","_a","push","setTimeout","styleArrays","slice","mergedStyleArray","concat","applyThemableStyles","stylesArray","styleRecord","resolveThemableArray","styleString","styleArray","document","head","getElementsByTagName","styleElement","createElement","themable","setAttribute","appendChild","createTextNode","ev","createEvent","initEvent","args","newStyle","dispatchEvent","record","themableStyle","registerStyles","themableStyles","_i","option","clearStylesInternal","clearStyles","reloadStyles","records","forEach","parentElement","removeChild","splitStyleArray","map","currentValue","themeSlot","themedValue","defaultValue","console","DEBUG","warn","rawString","join","result","pos","tokenMatch","exec","matchIndex","index","substring","lastIndex","process","createAllPromise","createPromise","doAwaitResponse","_debugState","_debugResult","_debugHandled","_nevware21_ts_utils__WEBPACK_IMPORTED_MODULE_0__","STR_PROMISE","REJECTED","value","cb","doAwait","status","rejected","reason","resolveFn","rejectFn","finallyFn","then","err","doFinally","finally","_promiseDebugEnabled","_hasInitEvent","STRING_STATES","DISPATCH_EVENT","_hasInitEventFn","doc","evt","_hasPromiseRejectionEvent","NODE_UNHANDLED_REJECTION","UNHANDLED_REJECTION","toLowerCase","_currentPromiseId","_uniquePromiseId","_unhandledRejectionTimeout","dumpFnObj","toString","_createPromise","newPromise","processor","executor","_settledValue","_thePromise","additionalArgs","_state","_hasResolved","_queue","_id","_parentId","_handled","_unHandledRejectionHandler","_then","onResolved","onRejected","cancel","resolve","reject","handler","e","_processQueue","pop","_strState","pending","_createSettleIfFn","newState","allowState","theValue","_notifyUnhandledRejection","emit","gbl","v","target","evtName","populateEvent","useNewEvent","theEvt","Event","theConsole","emitEvent","g","catch","onFinally","thenFinally","catchFinally","get","thePromise","stateFn","resultFn","handledFn","props","_addDebugState$1","_rejectFn","_createAllPromise","input","values_1","pending_1","item","idx","syncItemProcessor","fn","createAsyncPromise","timeout","callbackTimeout","timeoutItemProcessor","_promiseCls","createNativePromise","PrmCls","_promiseCreator","dynamicProto","Constructor","Prototype","strFunction","DynInstFuncTable","DynProxyTag","DynClassName","DynClassNamePrefix","DynInstChkTag","DynAllowInstChkTag","DynProtoDefaultOptions","UnknownValue","str__Proto","DynProtoBaseProto","DynProtoCurrent","strUseBaseInst","strSetInstFuncs","Obj","_objGetPrototypeOf","_objGetOwnProps","_gbl","_gblInst","o","_isObjectOrArrayPrototype","_isObjectArrayOrFunctionPrototype","Function","_getObjProto","newProto","curProto","_forEachProp","name_1","lp","_isDynamicCandidate","funcName","skipOwn","_throwTypeError","message","_hasVisited","values","_populatePrototype","proto","className","baseInstFuncs","setInstanceFunc","_createDynamicPrototype","dynProtoProxy","currentDynProtoProxy","instFunc","instFuncTable","canAddInst","objProto","visited","protoFunc","_getInstFunc","_getProtoFunc","instFuncs_1","name","_getObjName","unknownValue","theClass","delegateFunc","options","classProto","thisTarget","thisProto","_checkPrototype","perfOptions","useBaseInst","instFuncs","_getInstanceFuncs","_instFuncProxy","funcHost","theFunc","baseFuncs","baseProto","_getBaseFuncs","UNDEFINED","globalThis","self","_getGlobal","_hasOwnProperty","obj","prop","TypeError","_newObject","create","_pureAssign","func1","func2","_pureRef","arrAppend","arrForEach","arrIndexOf","arrMap","arrSlice","asString","createCachedValue","createCustomError","createEnum","createTimeout","createTypeMap","deepExtend","dumpObj","fnCall","getDocument","getGlobal","getHistory","getInst","getKnownSymbol","getLazy","getLength","getNavigator","getPerformance","getWindow","hasDocument","hasHistory","hasNavigator","hasSymbol","hasWindow","isBoolean","isDefined","isError","isFunction","isIterable","isIterator","isNode","isNullOrUndefined","isNumber","isObject","isPlainObject","isPromiseLike","isString","isTruthy","isUndefined","isWebWorker","iterForOf","newSymbol","objAssign","objCreate","objDeepFreeze","objDefine","objDefineProp","objDefineProperties","objDefineProps","objForEachKey","objFreeze","objGetOwnPropertyDescriptor","objHasOwn","objHasOwnProperty","objKeys","objToString","perfNow","safe","scheduleIdleCallback","scheduleTimeout","scheduleTimeoutWith","strEndsWith","strIndexOf","strLeft","strStartsWith","strSubstr","strSubstring","strTrim","symbolFor","throwError","throwTypeError","utcNow","_primitiveTypes","UNDEF_VALUE","NULL_VALUE","EMPTY","FUNCTION","OBJECT","PROTOTYPE","__PROTO__","CONSTRUCTOR","SYMBOL","POLYFILL_TAG","LENGTH","NAME","CALL","TO_STRING","ObjClass","ObjProto","StrCls","String","StrProto","MathCls","Math","ArrCls","ArrProto","ArrSlice","argArray","_createIs","theType","_createObjIs","theName","arg","isPrimitiveType","indexOf","isDate","defValue","safeGet","polyObjHasOwn","theObject","callbackfn","thisArg","propMap","c","w","_createProp","l","desc","set","newValue","key","propDesc","propDescMap","_createKeyValueMap","keyType","valueType","completeFn","writable","theMap","_assignMapValue","enumerable","ERROR_TYPE","object","format","propertyValueDump","objType","stack","JSON","stringify","replace","Error","_objFreeze","_doNothing","_getProto","objGetPrototypeOf","createEnumKeyMap","mapClass","createSimpleMap","_globalCfg","_wellKnownSymbolMap","asyncIterator","hasInstance","isConcatSpreadable","iterator","match","matchAll","search","species","split","toPrimitive","toStringTag","unscopables","GLOBAL_CONFIG_KEY","_getGlobalValue","_getGlobalConfig","_unwrapFunction","_unwrapFunctionWithPoly","clsProto","polyFunc","clsFn","theArgs","_unwrapProp","propName","mathMax","strSlice","polyStrSubstr","_polySymbols","_wellKnownSymbolCache","_globalLazyTestHooks","UNIQUE_REGISTRY_ID","_globalSymbolRegistry","gblCfg","gblSym","k","polyNewSymbol","description","theSymbol","_initTestHooks","lazyValue","b","lzy","configurable","toJSON","_cachedGlobal","WINDOW","_getGlobalInstFn","getFn","cachedValue","useCached","_symbol","_symbolFor","versions","node","WorkerGlobalScope","_initSymbol","_getSymbolKey","_iterSymbol$1","getSymbol","noPoly","knownName","sym","polyGetKnownSymbol","registry","newSymbol_1","regId_1","next","isStrictNullOrUndefined","iter","iterResult","done","failed","throw","return","fnApply","elms","elm","theArray","len","_isProtoArray","polyObjCreate","type","tempFunc","objSetPrototypeOf","_setName","baseClass","constructCb","errorBase","theBaseClass","orgName","captureFn","captureStackTrace","__","_createCustomError","_self","orgProto","getTime","_createTrimFn","exp","polyStrTrim","_fnToString","_objCtrFnString","_gblWindow","ex","_defaultDeepCopyHandler","details","plainObjDeepCopyHandler","defaultDeepCopyHandlers","copyTo","_deepCopy","visitMap","ctx","userHandler","newPath","path","newCtx","src","isPlain","isPrim","origin","copy","source","newKey","_copyProps","theEntry","entry","_getSetVisited","newEntry","_doExtend","theArg","objCopyProps","obj1","obj2","obj3","obj4","obj5","obj6","_perf","polyStrEndsWith","searchString","searchValue","polyStrStartsWith","position","REF","UNREF","HAS_REF","ENABLED","_createTimerHandler","startTimer","refreshFn","cancelFn","theTimerHandler","ref","timerId","_unref","_cancel","_refresh","refresh","h","dn","_createTimeoutWith","overrideFn","isArr","setFn","clearFn","clearTimeout","timerFn","callback","_defaultIdleTimeout","_maxExecutionTime","getIdleCallback","getCancelIdleCallback","_createDeadline","timedOut","startTime","didTimeout","timeRemaining","elapsedTime","handler_1","idleId","deadline"],"mappings":"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","file":"static/js/vendor.initial~455ff15e.5c711b4e.chunk.js","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\n// Store the theming state in __themeState__ global scope for reuse in the case of duplicate\n// load-themed-styles hosted on the page.\nvar _root = typeof window === 'undefined' ? global : window; // eslint-disable-line @typescript-eslint/no-explicit-any\n// Nonce string to inject into script tag if one provided. This is used in CSP (Content Security Policy).\nvar _styleNonce = _root && _root.CSPSettings && _root.CSPSettings.nonce;\nvar _themeState = initializeThemeState();\n/**\n * Matches theming tokens. For example, \"[theme: themeSlotName, default: #FFF]\" (including the quotes).\n */\nvar _themeTokenRegex = /[\\'\\\"]\\[theme:\\s*(\\w+)\\s*(?:\\,\\s*default:\\s*([\\\\\"\\']?[\\.\\,\\(\\)\\#\\-\\s\\w]*[\\.\\,\\(\\)\\#\\-\\w][\\\"\\']?))?\\s*\\][\\'\\\"]/g;\nvar now = function () {\n    return typeof performance !== 'undefined' && !!performance.now ? performance.now() : Date.now();\n};\nfunction measure(func) {\n    var start = now();\n    func();\n    var end = now();\n    _themeState.perf.duration += end - start;\n}\n/**\n * initialize global state object\n */\nfunction initializeThemeState() {\n    var state = _root.__themeState__ || {\n        theme: undefined,\n        lastStyleElement: undefined,\n        registeredStyles: []\n    };\n    if (!state.runState) {\n        state = __assign(__assign({}, state), { perf: {\n                count: 0,\n                duration: 0\n            }, runState: {\n                flushTimer: 0,\n                mode: 0 /* Mode.sync */,\n                buffer: []\n            } });\n    }\n    if (!state.registeredThemableStyles) {\n        state = __assign(__assign({}, state), { registeredThemableStyles: [] });\n    }\n    _root.__themeState__ = state;\n    return state;\n}\n/**\n * Loads a set of style text. If it is registered too early, we will register it when the window.load\n * event is fired.\n * @param {string | ThemableArray} styles Themable style text to register.\n * @param {boolean} loadAsync When true, always load styles in async mode, irrespective of current sync mode.\n */\nexport function loadStyles(styles, loadAsync) {\n    if (loadAsync === void 0) { loadAsync = false; }\n    measure(function () {\n        var styleParts = Array.isArray(styles) ? styles : splitStyles(styles);\n        var _a = _themeState.runState, mode = _a.mode, buffer = _a.buffer, flushTimer = _a.flushTimer;\n        if (loadAsync || mode === 1 /* Mode.async */) {\n            buffer.push(styleParts);\n            if (!flushTimer) {\n                _themeState.runState.flushTimer = asyncLoadStyles();\n            }\n        }\n        else {\n            applyThemableStyles(styleParts);\n        }\n    });\n}\n/**\n * Allows for customizable loadStyles logic. e.g. for server side rendering application\n * @param {(processedStyles: string, rawStyles?: string | ThemableArray) => void}\n * a loadStyles callback that gets called when styles are loaded or reloaded\n */\nexport function configureLoadStyles(loadStylesFn) {\n    _themeState.loadStyles = loadStylesFn;\n}\n/**\n * Configure run mode of load-themable-styles\n * @param mode load-themable-styles run mode, async or sync\n */\nexport function configureRunMode(mode) {\n    _themeState.runState.mode = mode;\n}\n/**\n * external code can call flush to synchronously force processing of currently buffered styles\n */\nexport function flush() {\n    measure(function () {\n        var styleArrays = _themeState.runState.buffer.slice();\n        _themeState.runState.buffer = [];\n        var mergedStyleArray = [].concat.apply([], styleArrays);\n        if (mergedStyleArray.length > 0) {\n            applyThemableStyles(mergedStyleArray);\n        }\n    });\n}\n/**\n * register async loadStyles\n */\nfunction asyncLoadStyles() {\n    return setTimeout(function () {\n        _themeState.runState.flushTimer = 0;\n        flush();\n    }, 0);\n}\n/**\n * Loads a set of style text. If it is registered too early, we will register it when the window.load event\n * is fired.\n * @param {string} styleText Style to register.\n * @param {IStyleRecord} styleRecord Existing style record to re-apply.\n */\nfunction applyThemableStyles(stylesArray, styleRecord) {\n    if (_themeState.loadStyles) {\n        _themeState.loadStyles(resolveThemableArray(stylesArray).styleString, stylesArray);\n    }\n    else {\n        registerStyles(stylesArray);\n    }\n}\n/**\n * Registers a set theme tokens to find and replace. If styles were already registered, they will be\n * replaced.\n * @param {theme} theme JSON object of theme tokens to values.\n */\nexport function loadTheme(theme) {\n    _themeState.theme = theme;\n    // reload styles.\n    reloadStyles();\n}\n/**\n * Clear already registered style elements and style records in theme_State object\n * @param option - specify which group of registered styles should be cleared.\n * Default to be both themable and non-themable styles will be cleared\n */\nexport function clearStyles(option) {\n    if (option === void 0) { option = 3 /* ClearStyleOptions.all */; }\n    if (option === 3 /* ClearStyleOptions.all */ || option === 2 /* ClearStyleOptions.onlyNonThemable */) {\n        clearStylesInternal(_themeState.registeredStyles);\n        _themeState.registeredStyles = [];\n    }\n    if (option === 3 /* ClearStyleOptions.all */ || option === 1 /* ClearStyleOptions.onlyThemable */) {\n        clearStylesInternal(_themeState.registeredThemableStyles);\n        _themeState.registeredThemableStyles = [];\n    }\n}\nfunction clearStylesInternal(records) {\n    records.forEach(function (styleRecord) {\n        var styleElement = styleRecord && styleRecord.styleElement;\n        if (styleElement && styleElement.parentElement) {\n            styleElement.parentElement.removeChild(styleElement);\n        }\n    });\n}\n/**\n * Reloads styles.\n */\nfunction reloadStyles() {\n    if (_themeState.theme) {\n        var themableStyles = [];\n        for (var _i = 0, _a = _themeState.registeredThemableStyles; _i < _a.length; _i++) {\n            var styleRecord = _a[_i];\n            themableStyles.push(styleRecord.themableStyle);\n        }\n        if (themableStyles.length > 0) {\n            clearStyles(1 /* ClearStyleOptions.onlyThemable */);\n            applyThemableStyles([].concat.apply([], themableStyles));\n        }\n    }\n}\n/**\n * Find theme tokens and replaces them with provided theme values.\n * @param {string} styles Tokenized styles to fix.\n */\nexport function detokenize(styles) {\n    if (styles) {\n        styles = resolveThemableArray(splitStyles(styles)).styleString;\n    }\n    return styles;\n}\n/**\n * Resolves ThemingInstruction objects in an array and joins the result into a string.\n * @param {ThemableArray} splitStyleArray ThemableArray to resolve and join.\n */\nfunction resolveThemableArray(splitStyleArray) {\n    var theme = _themeState.theme;\n    var themable = false;\n    // Resolve the array of theming instructions to an array of strings.\n    // Then join the array to produce the final CSS string.\n    var resolvedArray = (splitStyleArray || []).map(function (currentValue) {\n        var themeSlot = currentValue.theme;\n        if (themeSlot) {\n            themable = true;\n            // A theming annotation. Resolve it.\n            var themedValue = theme ? theme[themeSlot] : undefined;\n            var defaultValue = currentValue.defaultValue || 'inherit';\n            // Warn to console if we hit an unthemed value even when themes are provided, but only if \"DEBUG\" is true.\n            // Allow the themedValue to be undefined to explicitly request the default value.\n            if (theme &&\n                !themedValue &&\n                console &&\n                !(themeSlot in theme) &&\n                typeof DEBUG !== 'undefined' &&\n                DEBUG) {\n                console.warn(\"Theming value not provided for \\\"\".concat(themeSlot, \"\\\". Falling back to \\\"\").concat(defaultValue, \"\\\".\"));\n            }\n            return themedValue || defaultValue;\n        }\n        else {\n            // A non-themable string. Preserve it.\n            return currentValue.rawString;\n        }\n    });\n    return {\n        styleString: resolvedArray.join(''),\n        themable: themable\n    };\n}\n/**\n * Split tokenized CSS into an array of strings and theme specification objects\n * @param {string} styles Tokenized styles to split.\n */\nexport function splitStyles(styles) {\n    var result = [];\n    if (styles) {\n        var pos = 0; // Current position in styles.\n        var tokenMatch = void 0;\n        while ((tokenMatch = _themeTokenRegex.exec(styles))) {\n            var matchIndex = tokenMatch.index;\n            if (matchIndex > pos) {\n                result.push({\n                    rawString: styles.substring(pos, matchIndex)\n                });\n            }\n            result.push({\n                theme: tokenMatch[1],\n                defaultValue: tokenMatch[2] // May be undefined\n            });\n            // index of the first character after the current match\n            pos = _themeTokenRegex.lastIndex;\n        }\n        // Push the rest of the string after the last match.\n        result.push({\n            rawString: styles.substring(pos)\n        });\n    }\n    return result;\n}\n/**\n * Registers a set of style text. If it is registered too early, we will register it when the\n * window.load event is fired.\n * @param {ThemableArray} styleArray Array of IThemingInstruction objects to register.\n * @param {IStyleRecord} styleRecord May specify a style Element to update.\n */\nfunction registerStyles(styleArray) {\n    if (typeof document === 'undefined') {\n        return;\n    }\n    var head = document.getElementsByTagName('head')[0];\n    var styleElement = document.createElement('style');\n    var _a = resolveThemableArray(styleArray), styleString = _a.styleString, themable = _a.themable;\n    styleElement.setAttribute('data-load-themed-styles', 'true');\n    if (_styleNonce) {\n        styleElement.setAttribute('nonce', _styleNonce);\n    }\n    styleElement.appendChild(document.createTextNode(styleString));\n    _themeState.perf.count++;\n    head.appendChild(styleElement);\n    var ev = document.createEvent('HTMLEvents');\n    ev.initEvent('styleinsert', true /* bubbleEvent */, false /* cancelable */);\n    ev.args = {\n        newStyle: styleElement\n    };\n    document.dispatchEvent(ev);\n    var record = {\n        styleElement: styleElement,\n        themableStyle: styleArray\n    };\n    if (themable) {\n        _themeState.registeredThemableStyles.push(record);\n    }\n    else {\n        _themeState.registeredStyles.push(record);\n    }\n}\n//# sourceMappingURL=index.js.map","/*!\n * NevWare21 Solutions LLC - ts-async, 0.5.2\n * https://github.com/nevware21/ts-async\n * Copyright (c) NevWare21 Solutions LLC and contributors. All rights reserved.\n * Licensed under the MIT license.\n */\nimport { isPromiseLike, objDefineProperties, getDocument, createCachedValue, safe, getInst, dumpObj, arrSlice, objDefineProp, hasSymbol, getKnownSymbol, isFunction, throwTypeError, iterForOf, scheduleTimeout, isNode, getWindow, getGlobal, objDefine, objToString, isUndefined, isArray, arrForEach, isIterable, createCustomError, isNumber, scheduleIdleCallback, utcNow, getLength, isIterator, fnCall, arrIndexOf } from '@nevware21/ts-utils';\n\nvar STR_PROMISE = \"Promise\";\nvar DONE = \"done\";\nvar VALUE = \"value\";\nvar RETURN = \"return\";\nvar REJECTED = \"rejected\";\n\nfunction doAwaitResponse(value, cb) {\n    return doAwait(value, function (value) {\n        return cb ? cb({\n            status: \"fulfilled\",\n            rejected: false,\n            value: value\n        }) : value;\n    }, function (reason) {\n        return cb ? cb({\n            status: REJECTED,\n            rejected: true,\n            reason: reason\n        }) : reason;\n    });\n}\nfunction doAwait(value, resolveFn, rejectFn, finallyFn) {\n    var result = value;\n    try {\n        if (isPromiseLike(value)) {\n            if (resolveFn || rejectFn) {\n                result = value.then(resolveFn, rejectFn);\n            }\n        }\n        else {\n            try {\n                if (resolveFn) {\n                    result = resolveFn(value);\n                }\n            }\n            catch (err) {\n                if (rejectFn) {\n                    result = rejectFn(err);\n                }\n                else {\n                    throw err;\n                }\n            }\n        }\n    }\n    finally {\n        if (finallyFn) {\n            doFinally(result, finallyFn);\n        }\n    }\n    return result;\n}\nfunction doFinally(value, finallyFn) {\n    var result = value;\n    if (finallyFn) {\n        if (isPromiseLike(value)) {\n            if (value.finally) {\n                result = value.finally(finallyFn);\n            }\n            else {\n                result = value.then(function (value) {\n                    finallyFn();\n                    return value;\n                }, function (reason) {\n                    finallyFn();\n                    throw reason;\n                });\n            }\n        }\n        else {\n            finallyFn();\n        }\n    }\n    return result;\n}\n\nvar _debugState;\nvar _debugResult;\nvar _debugHandled;\nvar _promiseDebugEnabled = false;\nfunction _addDebugState$1(thePromise, stateFn, resultFn, handledFn) {\n    _debugState = _debugState || { toString: function () { return \"[[PromiseState]]\"; } };\n    _debugResult = _debugResult || { toString: function () { return \"[[PromiseResult]]\"; } };\n    _debugHandled = _debugHandled || { toString: function () { return \"[[PromiseIsHandled]]\"; } };\n    var props = {};\n    props[_debugState] = { get: stateFn };\n    props[_debugResult] = { get: resultFn };\n    props[_debugHandled] = { get: handledFn };\n    objDefineProperties(thePromise, props);\n}\nfunction setPromiseDebugState(enabled, logger) {\n    _promiseDebugEnabled = enabled;\n}\n\nvar STRING_STATES =  [\n    \"pending\", \"resolving\", \"resolved\", REJECTED\n];\n\nvar DISPATCH_EVENT = \"dispatchEvent\";\nvar _hasInitEvent;\nfunction _hasInitEventFn(doc) {\n    var evt;\n    if (doc && doc.createEvent) {\n        evt = doc.createEvent(\"Event\");\n    }\n    return (!!evt && evt.initEvent);\n}\nfunction emitEvent(target, evtName, populateEvent, useNewEvent) {\n    var doc = getDocument();\n    !_hasInitEvent && (_hasInitEvent = createCachedValue(!!safe(_hasInitEventFn, [doc]).v));\n    var theEvt = _hasInitEvent.v ? doc.createEvent(\"Event\") : (useNewEvent ? new Event(evtName) : {});\n    populateEvent && populateEvent(theEvt);\n    if (_hasInitEvent.v) {\n        theEvt.initEvent(evtName, false, true);\n    }\n    if (theEvt && target[DISPATCH_EVENT]) {\n        target[DISPATCH_EVENT](theEvt);\n    }\n    else {\n        var handler = target[\"on\" + evtName];\n        if (handler) {\n            handler(theEvt);\n        }\n        else {\n            var theConsole = getInst(\"console\");\n            theConsole && (theConsole[\"error\"] || theConsole[\"log\"])(evtName, dumpObj(theEvt));\n        }\n    }\n}\n\nvar NODE_UNHANDLED_REJECTION = \"unhandledRejection\";\nvar UNHANDLED_REJECTION = NODE_UNHANDLED_REJECTION.toLowerCase();\nvar _currentPromiseId = [];\nvar _uniquePromiseId = 0;\nvar _unhandledRejectionTimeout = 10;\nvar _aggregationError;\nvar _hasPromiseRejectionEvent;\nfunction dumpFnObj(value) {\n    if (isFunction(value)) {\n        return value.toString();\n    }\n    return dumpObj(value);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createAggregationError(values) {\n    !_aggregationError && (_aggregationError = createCachedValue(safe(getInst, [\"AggregationError\"]).v || createCustomError(\"AggregationError\", function (self, args) {\n        self.errors = args[0];\n    })));\n    return new _aggregationError.v(values);\n}\nfunction _createPromise(newPromise, processor, executor) {\n    var additionalArgs = arrSlice(arguments, 3);\n    var _state = 0 ;\n    var _hasResolved = false;\n    var _settledValue;\n    var _queue = [];\n    var _id = _uniquePromiseId++;\n    var _parentId = _currentPromiseId.length > 0 ? _currentPromiseId[_currentPromiseId.length - 1] : undefined;\n    var _handled = false;\n    var _unHandledRejectionHandler = null;\n    var _thePromise;\n    function _then(onResolved, onRejected) {\n        try {\n            _currentPromiseId.push(_id);\n            _handled = true;\n            _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();\n            _unHandledRejectionHandler = null;\n            var thenPromise = newPromise(function (resolve, reject) {\n                _queue.push(function () {\n                    try {\n                        var handler = _state === 2  ? onResolved : onRejected;\n                        var value = isUndefined(handler) ? _settledValue : (isFunction(handler) ? handler(_settledValue) : handler);\n                        if (isPromiseLike(value)) {\n                            value.then(resolve, reject);\n                        }\n                        else if (handler) {\n                            resolve(value);\n                        }\n                        else if (_state === 3 ) {\n                            reject(value);\n                        }\n                        else {\n                            resolve(value);\n                        }\n                    }\n                    catch (e) {\n                        reject(e);\n                    }\n                });\n                if (_hasResolved) {\n                    _processQueue();\n                }\n            }, additionalArgs);\n            return thenPromise;\n        }\n        finally {\n            _currentPromiseId.pop();\n        }\n    }\n    function _catch(onRejected) {\n        return _then(undefined, onRejected);\n    }\n    function _finally(onFinally) {\n        var thenFinally = onFinally;\n        var catchFinally = onFinally;\n        if (isFunction(onFinally)) {\n            thenFinally = function (value) {\n                onFinally && onFinally();\n                return value;\n            };\n            catchFinally = function (reason) {\n                onFinally && onFinally();\n                throw reason;\n            };\n        }\n        return _then(thenFinally, catchFinally);\n    }\n    function _strState() {\n        return STRING_STATES[_state];\n    }\n    function _processQueue() {\n        if (_queue.length > 0) {\n            var pending = _queue.slice();\n            _queue = [];\n            _handled = true;\n            _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();\n            _unHandledRejectionHandler = null;\n            processor(pending);\n        }\n    }\n    function _createSettleIfFn(newState, allowState) {\n        return function (theValue) {\n            if (_state === allowState) {\n                if (newState === 2  && isPromiseLike(theValue)) {\n                    _state = 1 ;\n                    theValue.then(_createSettleIfFn(2 , 1 ), _createSettleIfFn(3 , 1 ));\n                    return;\n                }\n                _state = newState;\n                _hasResolved = true;\n                _settledValue = theValue;\n                _processQueue();\n                if (!_handled && newState === 3  && !_unHandledRejectionHandler) {\n                    _unHandledRejectionHandler = scheduleTimeout(_notifyUnhandledRejection, _unhandledRejectionTimeout);\n                }\n            }\n        };\n    }\n    function _notifyUnhandledRejection() {\n        if (!_handled) {\n            _handled = true;\n            if (isNode()) {\n                process.emit(NODE_UNHANDLED_REJECTION, _settledValue, _thePromise);\n            }\n            else {\n                var gbl = getWindow() || getGlobal();\n                !_hasPromiseRejectionEvent && (_hasPromiseRejectionEvent = createCachedValue(safe((getInst), [STR_PROMISE + \"RejectionEvent\"]).v));\n                emitEvent(gbl, UNHANDLED_REJECTION, function (theEvt) {\n                    objDefine(theEvt, \"promise\", { g: function () { return _thePromise; } });\n                    theEvt.reason = _settledValue;\n                    return theEvt;\n                }, !!_hasPromiseRejectionEvent.v);\n            }\n        }\n    }\n    _thePromise = {\n        then: _then,\n        \"catch\": _catch,\n        finally: _finally\n    };\n    objDefineProp(_thePromise, \"state\", {\n        get: _strState\n    });\n    if (_promiseDebugEnabled) {\n        _addDebugState$1(_thePromise, _strState, function () { return objToString(_settledValue); }, function () { return _handled; });\n    }\n    if (hasSymbol()) {\n        _thePromise[getKnownSymbol(11 )] = \"IPromise\";\n    }\n    function _toString() {\n        return \"IPromise\" + (_promiseDebugEnabled ? \"[\" + _id + (!isUndefined(_parentId) ? (\":\" + _parentId) : \"\") + \"]\" : \"\") + \" \" + _strState() + (_hasResolved ? (\" - \" + dumpFnObj(_settledValue)) : \"\") + (\"\");\n    }\n    _thePromise.toString = _toString;\n    (function _initialize() {\n        if (!isFunction(executor)) {\n            throwTypeError(STR_PROMISE + \": executor is not a function - \" + dumpFnObj(executor));\n        }\n        var _rejectFn = _createSettleIfFn(3 , 0 );\n        try {\n            executor.call(_thePromise, _createSettleIfFn(2 , 0 ), _rejectFn);\n        }\n        catch (e) {\n            _rejectFn(e);\n        }\n    })();\n    return _thePromise;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createAllPromise(newPromise) {\n    return function (input) {\n        var additionalArgs = arrSlice(arguments, 1);\n        return newPromise(function (resolve, reject) {\n            try {\n                var values_1 = [];\n                var pending_1 = 1;\n                iterForOf(input, function (item, idx) {\n                    if (item) {\n                        pending_1++;\n                        doAwait(item, function (value) {\n                            values_1[idx] = value;\n                            if (--pending_1 === 0) {\n                                resolve(values_1);\n                            }\n                        }, reject);\n                    }\n                });\n                pending_1--;\n                if (pending_1 === 0) {\n                    resolve(values_1);\n                }\n            }\n            catch (e) {\n                reject(e);\n            }\n        }, additionalArgs);\n    };\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createResolvedPromise(newPromise) {\n    return function (value) {\n        var additionalArgs = arrSlice(arguments, 1);\n        if (isPromiseLike(value)) {\n            return value;\n        }\n        return newPromise(function (resolve) {\n            resolve(value);\n        }, additionalArgs);\n    };\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createRejectedPromise(newPromise) {\n    return function (reason) {\n        var additionalArgs = arrSlice(arguments, 1);\n        return newPromise(function (_resolve, reject) {\n            reject(reason);\n        }, additionalArgs);\n    };\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createAllSettledPromise(newPromise) {\n    return createCachedValue(function (input) {\n        var additionalArgs = arrSlice(arguments, 1);\n        return newPromise(function (resolve, reject) {\n            var values = [];\n            var pending = 1;\n            function processItem(item, idx) {\n                pending++;\n                doAwaitResponse(item, function (value) {\n                    if (value.rejected) {\n                        values[idx] = {\n                            status: REJECTED,\n                            reason: value.reason\n                        };\n                    }\n                    else {\n                        values[idx] = {\n                            status: \"fulfilled\",\n                            value: value.value\n                        };\n                    }\n                    if (--pending === 0) {\n                        resolve(values);\n                    }\n                });\n            }\n            try {\n                if (isArray(input)) {\n                    arrForEach(input, processItem);\n                }\n                else if (isIterable(input)) {\n                    iterForOf(input, processItem);\n                }\n                else {\n                    throwTypeError(\"Input is not an iterable\");\n                }\n                pending--;\n                if (pending === 0) {\n                    resolve(values);\n                }\n            }\n            catch (e) {\n                reject(e);\n            }\n        }, additionalArgs);\n    });\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createRacePromise(newPromise) {\n    return createCachedValue(function (input) {\n        var additionalArgs = arrSlice(arguments, 1);\n        return newPromise(function (resolve, reject) {\n            var isDone = false;\n            function processItem(item) {\n                doAwaitResponse(item, function (value) {\n                    if (!isDone) {\n                        isDone = true;\n                        if (value.rejected) {\n                            reject(value.reason);\n                        }\n                        else {\n                            resolve(value.value);\n                        }\n                    }\n                });\n            }\n            try {\n                if (isArray(input)) {\n                    arrForEach(input, processItem);\n                }\n                else if (isIterable(input)) {\n                    iterForOf(input, processItem);\n                }\n                else {\n                    throwTypeError(\"Input is not an iterable\");\n                }\n            }\n            catch (e) {\n                reject(e);\n            }\n        }, additionalArgs);\n    });\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createAnyPromise(newPromise) {\n    return createCachedValue(function (input) {\n        var additionalArgs = arrSlice(arguments, 1);\n        return newPromise(function (resolve, reject) {\n            var theErros = [];\n            var pending = 1;\n            var isDone = false;\n            function processItem(item, idx) {\n                pending++;\n                doAwaitResponse(item, function (value) {\n                    if (!value.rejected) {\n                        isDone = true;\n                        resolve(value.value);\n                        return;\n                    }\n                    else {\n                        theErros[idx] = value.reason;\n                    }\n                    if (--pending === 0 && !isDone) {\n                        reject(_createAggregationError(theErros));\n                    }\n                });\n            }\n            try {\n                if (isArray(input)) {\n                    arrForEach(input, processItem);\n                }\n                else if (isIterable(input)) {\n                    iterForOf(input, processItem);\n                }\n                else {\n                    throwTypeError(\"Input is not an iterable\");\n                }\n                pending--;\n                if (pending === 0 && !isDone) {\n                    reject(_createAggregationError(theErros));\n                }\n            }\n            catch (e) {\n                reject(e);\n            }\n        }, additionalArgs);\n    });\n}\n\nfunction syncItemProcessor(pending) {\n    arrForEach(pending, function (fn) {\n        try {\n            fn();\n        }\n        catch (e) {\n        }\n    });\n}\nfunction timeoutItemProcessor(timeout) {\n    var callbackTimeout = isNumber(timeout) ? timeout : 0;\n    return function (pending) {\n        scheduleTimeout(function () {\n            syncItemProcessor(pending);\n        }, callbackTimeout);\n    };\n}\nfunction idleItemProcessor(timeout) {\n    var options;\n    if (timeout >= 0) {\n        options = {\n            timeout: +timeout\n        };\n    }\n    return function (pending) {\n        scheduleIdleCallback(function (deadline) {\n            syncItemProcessor(pending);\n        }, options);\n    };\n}\n\nvar _allAsyncSettledCreator;\nvar _raceAsyncCreator;\nvar _anyAsyncCreator;\nfunction createAsyncPromise(executor, timeout) {\n    return _createPromise(createAsyncPromise, timeoutItemProcessor(timeout), executor, timeout);\n}\nvar createAsyncAllPromise = /*#__PURE__*/ _createAllPromise(createAsyncPromise);\nvar createAsyncResolvedPromise = /*#__PURE__*/ _createResolvedPromise(createAsyncPromise);\nvar createAsyncRejectedPromise = /*#__PURE__*/ _createRejectedPromise(createAsyncPromise);\nfunction createAsyncAllSettledPromise(input, timeout) {\n    !_allAsyncSettledCreator && (_allAsyncSettledCreator = _createAllSettledPromise(createAsyncPromise));\n    return _allAsyncSettledCreator.v(input, timeout);\n}\nfunction createAsyncRacePromise(values, timeout) {\n    !_raceAsyncCreator && (_raceAsyncCreator = _createRacePromise(createAsyncPromise));\n    return _raceAsyncCreator.v(values, timeout);\n}\nfunction createAsyncAnyPromise(values, timeout) {\n    !_anyAsyncCreator && (_anyAsyncCreator = _createAnyPromise(createAsyncPromise));\n    return _anyAsyncCreator.v(values, timeout);\n}\n\nvar _promiseCls;\nvar _allCreator;\nvar _allNativeSettledCreator;\nvar _raceNativeCreator;\nvar _anyNativeCreator;\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createNativePromiseHelper(name, func) {\n    !_promiseCls && (_promiseCls = createCachedValue((safe(getInst, [STR_PROMISE]).v) || null));\n    if (_promiseCls.v && _promiseCls.v[name]) {\n        return createCachedValue(function (input, timeout) {\n            return createNativePromise(function (resolve, reject) {\n                _promiseCls.v[name](input).then(resolve, reject);\n            });\n        });\n    }\n    return func();\n}\nfunction createNativePromise(executor, timeout) {\n    !_promiseCls && (_promiseCls = createCachedValue((safe(getInst, [STR_PROMISE]).v) || null));\n    var PrmCls = _promiseCls.v;\n    if (!PrmCls) {\n        return createAsyncPromise(executor);\n    }\n    if (!isFunction(executor)) {\n        throwTypeError(STR_PROMISE + \": executor is not a function - \" + dumpObj(executor));\n    }\n    var _state = 0 ;\n    function _strState() {\n        return STRING_STATES[_state];\n    }\n    var thePromise = new PrmCls(function (resolve, reject) {\n        function _resolve(value) {\n            _state = 2 ;\n            resolve(value);\n        }\n        function _reject(reason) {\n            _state = 3 ;\n            reject(reason);\n        }\n        executor(_resolve, _reject);\n    });\n    objDefineProp(thePromise, \"state\", {\n        get: _strState\n    });\n    return thePromise;\n}\nfunction createNativeAllPromise(input, timeout) {\n    !_allCreator && (_allCreator = _createNativePromiseHelper(\"all\", function () { return createCachedValue(_createAllPromise(createNativePromise)); }));\n    return _allCreator.v(input, timeout);\n}\nvar createNativeResolvedPromise = /*#__PURE__*/ _createResolvedPromise(createNativePromise);\nvar createNativeRejectedPromise = /*#__PURE__*/ _createRejectedPromise(createNativePromise);\nfunction createNativeAllSettledPromise(input, timeout) {\n    !_allNativeSettledCreator && (_allNativeSettledCreator = _createNativePromiseHelper(\"allSettled\", function () { return _createAllSettledPromise(createNativePromise); }));\n    return _allNativeSettledCreator.v(input, timeout);\n}\nfunction createNativeRacePromise(values, timeout) {\n    !_raceNativeCreator && (_raceNativeCreator = _createNativePromiseHelper(\"race\", function () { return _createRacePromise(createNativePromise); }));\n    return _raceNativeCreator.v(values, timeout);\n}\nfunction createNativeAnyPromise(values, timeout) {\n    !_anyNativeCreator && (_anyNativeCreator = _createNativePromiseHelper(\"any\", function () { return _createAnyPromise(createNativePromise); }));\n    return _anyNativeCreator.v(values, timeout);\n}\n\nvar _allSyncSettledCreator;\nvar _raceSyncCreator;\nvar _anySyncCreator;\nfunction createSyncPromise(executor) {\n    return _createPromise(createSyncPromise, syncItemProcessor, executor);\n}\nvar createSyncAllPromise = /*#__PURE__*/ _createAllPromise(createSyncPromise);\nvar createSyncResolvedPromise = /*#__PURE__*/ _createResolvedPromise(createSyncPromise);\nvar createSyncRejectedPromise = /*#__PURE__*/ _createRejectedPromise(createSyncPromise);\nfunction createSyncAllSettledPromise(input, timeout) {\n    !_allSyncSettledCreator && (_allSyncSettledCreator = _createAllSettledPromise(createSyncPromise));\n    return _allSyncSettledCreator.v(input, timeout);\n}\nfunction createSyncRacePromise(values, timeout) {\n    !_raceSyncCreator && (_raceSyncCreator = _createRacePromise(createSyncPromise));\n    return _raceSyncCreator.v(values, timeout);\n}\nfunction createSyncAnyPromise(values, timeout) {\n    !_anySyncCreator && (_anySyncCreator = _createAnyPromise(createSyncPromise));\n    return _anySyncCreator.v(values, timeout);\n}\n\nvar _defaultIdleTimeout;\nvar _allIdleSettledCreator;\nvar _raceIdleCreator;\nvar _anyIdleCreator;\nfunction setDefaultIdlePromiseTimeout(idleDeadline) {\n    _defaultIdleTimeout = idleDeadline;\n}\nvar setDefaultIdleTimeout = ( setDefaultIdlePromiseTimeout);\nfunction createIdlePromise(executor, timeout) {\n    var theTimeout = isUndefined(timeout) ? _defaultIdleTimeout : timeout;\n    return _createPromise(createIdlePromise, idleItemProcessor(theTimeout), executor, theTimeout);\n}\nvar createIdleAllPromise = /*#__PURE__*/ _createAllPromise(createIdlePromise);\nvar createIdleResolvedPromise = /*#__PURE__*/ _createResolvedPromise(createIdlePromise);\nvar createIdleRejectedPromise = /*#__PURE__*/ _createRejectedPromise(createIdlePromise);\nfunction createIdleAllSettledPromise(input, timeout) {\n    !_allIdleSettledCreator && (_allIdleSettledCreator = _createAllSettledPromise(createIdlePromise));\n    return _allIdleSettledCreator.v(input, timeout);\n}\nfunction createIdleRacePromise(values, timeout) {\n    !_raceIdleCreator && (_raceIdleCreator = _createRacePromise(createIdlePromise));\n    return _raceIdleCreator.v(values, timeout);\n}\nfunction createIdleAnyPromise(values, timeout) {\n    !_anyIdleCreator && (_anyIdleCreator = _createAnyPromise(createIdlePromise));\n    return _anyIdleCreator.v(values, timeout);\n}\n\nvar _promiseCreator;\nvar _allSettledCreator;\nvar _raceCreator;\nvar _anyCreator;\nfunction setCreatePromiseImpl(creator) {\n    _promiseCreator = creator ? createCachedValue(creator) : null;\n}\nfunction createPromise(executor, timeout) {\n    !_promiseCreator && (_promiseCreator = createCachedValue(createNativePromise));\n    return _promiseCreator.v.call(this, executor, timeout);\n}\nvar createAllPromise = /*#__PURE__*/ _createAllPromise(createPromise);\nvar createResolvedPromise = /*#__PURE__*/ _createResolvedPromise(createPromise);\nvar createRejectedPromise = /*#__PURE__*/ _createRejectedPromise(createPromise);\nfunction createAllSettledPromise(input, timeout) {\n    !_allSettledCreator && (_allSettledCreator = _createAllSettledPromise(createPromise));\n    return _allSettledCreator.v(input, timeout);\n}\nfunction createRacePromise(values, timeout) {\n    !_raceCreator && (_raceCreator = _createRacePromise(createPromise));\n    return _raceCreator.v(values, timeout);\n}\nfunction createAnyPromise(values, timeout) {\n    !_anyCreator && (_anyCreator = _createAnyPromise(createPromise));\n    return _anyCreator.v(values, timeout);\n}\n\nfunction createTimeoutPromise(timeout, resolveReject, message) {\n    return createPromise(function (resolve, reject) {\n        scheduleTimeout(function () {\n            (resolveReject ? resolve : reject)(!isUndefined(message) ? message : \"Timeout of \" + timeout + \"ms exceeded\");\n        }, timeout);\n    });\n}\n\nfunction _doneChk(isDone, state, value, thisArg) {\n    var result = isDone;\n    state.res = value;\n    if (!result) {\n        if (state.isDone && isFunction(state.isDone)) {\n            return doAwait(state.isDone.call(thisArg, state), function (done) {\n                state.iter++;\n                return !!done;\n            });\n        }\n        else {\n            result = !!state.isDone;\n        }\n    }\n    state.iter++;\n    return result;\n}\nfunction doWhileAsync(callbackFn, isDoneFn, thisArg) {\n    var promise;\n    var resolve;\n    var reject = function (reason) {\n        isDone = true;\n        throw reason;\n    };\n    var isDone = false;\n    var state = {\n        st: utcNow(),\n        iter: 0,\n        isDone: isDoneFn || false\n    };\n    if (callbackFn) {\n        var _createPromise_1 = function () {\n            return createPromise(function (res, rej) {\n                resolve = res;\n                reject = rej;\n            });\n        };\n        var _handleAsyncDone_1 = function (done) {\n            isDone = !!done;\n            if (!isDone) {\n                _processNext_1();\n            }\n            else {\n                resolve(state.res);\n            }\n        };\n        var _processNext_1 = function () {\n            while (!isDone) {\n                try {\n                    var cbResult = callbackFn.call(thisArg, state);\n                    if (isPromiseLike(cbResult)) {\n                        promise = promise || _createPromise_1();\n                        doAwait(cbResult, function (res) {\n                            try {\n                                doAwait(_doneChk(isDone, state, res, thisArg), _handleAsyncDone_1, reject);\n                            }\n                            catch (e) {\n                                reject(e);\n                            }\n                        }, reject);\n                        return promise;\n                    }\n                    else {\n                        var dnRes = _doneChk(isDone, state, cbResult, thisArg);\n                        if (isPromiseLike(dnRes)) {\n                            promise = promise || _createPromise_1();\n                            doAwait(dnRes, _handleAsyncDone_1, reject);\n                            return promise;\n                        }\n                        else {\n                            isDone = !!dnRes;\n                        }\n                    }\n                }\n                catch (e) {\n                    reject(e);\n                    return promise;\n                }\n            }\n            if (isDone && resolve) {\n                resolve(state.res);\n            }\n            return promise || state.res;\n        };\n        return _processNext_1();\n    }\n}\n\nfunction arrForEachAsync(theArray, callbackFn, thisArg) {\n    if (theArray) {\n        var len_1 = getLength(theArray);\n        if (len_1) {\n            var isDone = function (state) {\n                if (state.iter >= len_1 || state.res === -1) {\n                    return true;\n                }\n            };\n            return doWhileAsync(function (state) {\n                var idx = state.iter;\n                if (idx in theArray) {\n                    return callbackFn.call(thisArg || theArray, theArray[idx], idx, theArray);\n                }\n            }, isDone);\n        }\n    }\n}\n\nvar _iterSymbol;\nvar _iterAsyncSymbol;\nfunction iterForOfAsync(iter, callbackFn, thisArg) {\n    var err;\n    var iterResult;\n    var theIter = iter;\n    function onFailed(failed) {\n        err = { e: failed };\n        if (theIter.throw) {\n            iterResult = null;\n            theIter.throw(err);\n        }\n        throw failed;\n    }\n    function onFinally() {\n        try {\n            if (iterResult && !iterResult[DONE]) {\n                theIter[RETURN] && theIter[RETURN](iterResult);\n            }\n        }\n        finally {\n            if (err) {\n                throw err.e;\n            }\n        }\n    }\n    if (iter) {\n        if (!isIterator(iter)) {\n            !_iterAsyncSymbol && (_iterAsyncSymbol = createCachedValue(getKnownSymbol(0 )));\n            theIter = iter[_iterAsyncSymbol.v] ? iter[_iterAsyncSymbol.v]() : null;\n            if (!theIter) {\n                !_iterSymbol && (_iterSymbol = createCachedValue(getKnownSymbol(3 )));\n                theIter = iter[_iterSymbol.v] ? iter[_iterSymbol.v]() : null;\n            }\n        }\n        if (theIter && isIterator(theIter)) {\n            var result = void 0;\n            try {\n                result = doWhileAsync(function (state) {\n                    return doAwait(theIter.next(), function (res) {\n                        iterResult = res;\n                        if (!res[DONE]) {\n                            return fnCall(callbackFn, thisArg || theIter, iterResult[VALUE], state.iter, theIter);\n                        }\n                    }, function (reason) {\n                        state.isDone = true;\n                        onFailed(reason);\n                    });\n                }, function (state) {\n                    if (!iterResult || iterResult[DONE] || state.res === -1) {\n                        onFinally();\n                        return true;\n                    }\n                }, thisArg || theIter);\n                if (isPromiseLike(result)) {\n                    result = doFinally(result.catch(onFailed), onFinally);\n                }\n                return result;\n            }\n            catch (failed) {\n                onFailed(failed);\n            }\n            finally {\n                if (result && !isPromiseLike(result)) {\n                    onFinally();\n                }\n            }\n        }\n    }\n}\n\nvar REJECT = \"reject\";\nvar REJECTED_ERROR = \"Rejected\";\nvar _schedulerId = 0;\nvar _debugName;\nvar _debugIntState;\nvar _customErrors = {};\nfunction _rejectDone() {\n}\nfunction _createError(type, evt, message) {\n    !_customErrors[type] && (_customErrors[type] = createCustomError(type));\n    var now = utcNow();\n    return new (_customErrors[type])(\"Task [\".concat(evt.id, \"] \").concat(message || \"\", \"- \").concat((evt.st ? \"Running\" : \"Waiting\"), \": \").concat(_calcTime(now, evt.st || evt.cr)));\n}\nfunction _calcTime(now, start) {\n    return ((now - start) || \"0\") + \" ms\";\n}\nfunction _abortStaleTasks(taskQueue, staleTimeoutPeriod) {\n    var now = utcNow();\n    var expired = now - staleTimeoutPeriod;\n    arrForEach(taskQueue, function (evt) {\n        if (evt && !evt.rj && (evt.st && evt.st < expired) || (!evt.st && evt.cr && evt.cr < expired)) {\n            evt && evt[REJECT](evt.rj || _createError(\"Aborted\", evt, \"Stale \"));\n        }\n    });\n}\nfunction _removeTask(queue, taskDetail) {\n    var idx = arrIndexOf(queue, taskDetail);\n    if (idx !== -1) {\n        queue.splice(idx, 1);\n    }\n}\nfunction _addDebugState(theScheduler, nameFn, stateFn) {\n    _debugName = _debugName || { toString: function () { return \"[[SchedulerName]]\"; } };\n    _debugIntState = _debugIntState || { toString: function () { return \"[[SchedulerState]]\"; } };\n    objDefineProp(theScheduler, _debugName, { get: nameFn });\n    objDefineProp(theScheduler, _debugIntState, { get: stateFn });\n}\nfunction createTaskScheduler(newPromise, name) {\n    var _theTask;\n    var _running = [];\n    var _waiting = [];\n    var _staleTimeoutPeriod = 600000;\n    var _staleTimeoutCheckPeriod = _staleTimeoutPeriod / 10;\n    var _taskCount = 0;\n    var _schedulerName = (name ? (name + \".\") : \"\") + _schedulerId++;\n    var _blockedTimer;\n    newPromise = newPromise || createPromise;\n    var _startBlockedTimer = function () {\n        var hasTasks = (getLength(_running) + getLength(_waiting)) > 0;\n        if (_staleTimeoutPeriod > 0) {\n            if (!_blockedTimer) {\n                _blockedTimer = scheduleTimeout(function () {\n                    _abortStaleTasks(_running, _staleTimeoutPeriod);\n                    _abortStaleTasks(_waiting, _staleTimeoutPeriod);\n                    _blockedTimer && (_blockedTimer.enabled = ((getLength(_running) + getLength(_waiting)) > 0));\n                }, _staleTimeoutCheckPeriod);\n                _blockedTimer.unref();\n            }\n            _blockedTimer && (_blockedTimer.enabled = hasTasks);\n        }\n    };\n    var _queueTask = function (startAction, taskName, timeout) {\n        var _a;\n        var taskId = _schedulerName + \".\" + _taskCount++;\n        if (taskName) {\n            taskId += \"-(\" + taskName + \")\";\n        }\n        var newTask = (_a = {\n                id: taskId,\n                cr: utcNow(),\n                to: timeout\n            },\n            _a[REJECT] = function (reason) {\n                newTask.rj = reason || _createError(REJECTED_ERROR, newTask);\n                newTask[REJECT] = _rejectDone;\n            },\n            _a);\n        if (!_theTask) {\n            newTask.p = newPromise(_runTask(newTask, startAction));\n        }\n        else {\n            newTask.p = _waitForPreviousTask(newTask, _theTask, startAction);\n        }\n        _theTask = newTask;\n        return newTask.p;\n    };\n    var _runTask = function (taskDetail, startAction) {\n        taskDetail.st = utcNow();\n        _running.push(taskDetail);\n        _startBlockedTimer();\n        return function (onTaskResolve, onTaskReject) {\n            var _promiseReject = function (reason) {\n                taskDetail.rj = taskDetail.rj || reason || _createError(REJECTED_ERROR, taskDetail);\n                taskDetail[REJECT] = _rejectDone;\n                _doCleanup(taskDetail);\n                onTaskResolve = null;\n                onTaskReject && onTaskReject(reason);\n                onTaskReject = null;\n            };\n            var taskId = taskDetail.id;\n            if (taskDetail.rj) {\n                _promiseReject(taskDetail.rj);\n            }\n            else {\n                taskDetail[REJECT] = _promiseReject;\n                try {\n                    var startResult = startAction(taskId);\n                    if (taskDetail.to && isPromiseLike(startResult)) {\n                        taskDetail.t = scheduleTimeout(function () {\n                            _promiseReject(_createError(\"Timeout\", taskDetail));\n                        }, taskDetail.to);\n                    }\n                    doAwait(startResult, function (theResult) {\n                        _doCleanup(taskDetail);\n                        try {\n                            onTaskResolve && onTaskResolve(theResult);\n                        }\n                        catch (e) {\n                            onTaskReject && onTaskReject(e);\n                        }\n                        onTaskReject = null;\n                        onTaskResolve = null;\n                    }, _promiseReject);\n                }\n                catch (e) {\n                    _promiseReject(e);\n                }\n            }\n        };\n    };\n    var _waitForPreviousTask = function (taskDetail, prevTask, startAction) {\n        _waiting.push(taskDetail);\n        _startBlockedTimer();\n        return newPromise(function (onWaitResolve, onWaitReject) {\n            doAwaitResponse(prevTask.p, function () {\n                _removeTask(_waiting, taskDetail);\n                _runTask(taskDetail, startAction)(onWaitResolve, onWaitReject);\n            });\n        });\n    };\n    var _doCleanup = function (taskDetail) {\n        _removeTask(_running, taskDetail);\n        taskDetail.t && taskDetail.t.cancel();\n        taskDetail.t = null;\n        if (_theTask && _theTask === taskDetail) {\n            _theTask = null;\n            if (getLength(_running) + getLength(_waiting) === 0) {\n                _blockedTimer && _blockedTimer.cancel();\n                _blockedTimer = null;\n            }\n        }\n    };\n    var theScheduler = {\n        idle: true,\n        queue: _queueTask,\n        setStaleTimeout: function (staleTimeout, staleCheckPeriod) {\n            _blockedTimer && _blockedTimer.cancel();\n            _blockedTimer = null;\n            _staleTimeoutPeriod = staleTimeout;\n            _staleTimeoutCheckPeriod = staleCheckPeriod || staleTimeout / 10;\n            _startBlockedTimer();\n        }\n    };\n    objDefine(theScheduler, \"idle\", {\n        g: function () {\n            return getLength(_running) + getLength(_waiting) === 0;\n        }\n    });\n    _addDebugState(theScheduler, function () { return _schedulerName; }, function () {\n        return {\n            l: _theTask,\n            r: _running,\n            w: _waiting\n        };\n    });\n    return theScheduler;\n}\n\nvar toStringTagSymbol = getKnownSymbol(11 );\nvar PolyPromise = /*#__PURE__*/ (function () {\n    function PolyPromiseImpl(executor) {\n        this._$ = createAsyncPromise(executor);\n        if (toStringTagSymbol) {\n            this[toStringTagSymbol] = \"Promise\";\n        }\n        objDefineProp(this, \"state\", {\n            get: function () {\n                return this._$.state;\n            }\n        });\n    }\n    PolyPromiseImpl.all = createAsyncAllPromise;\n    PolyPromiseImpl.race = createAsyncRacePromise;\n    PolyPromiseImpl.any = createAsyncAnyPromise;\n    PolyPromiseImpl.reject = createAsyncRejectedPromise;\n    PolyPromiseImpl.resolve = createAsyncResolvedPromise;\n    PolyPromiseImpl.allSettled = createAsyncAllSettledPromise;\n    var theProto = PolyPromiseImpl.prototype;\n    theProto.then = function (onResolved, onRejected) {\n        return this._$.then(onResolved, onRejected);\n    };\n    theProto.catch = function (onRejected) {\n        return this._$.catch(onRejected);\n    };\n    theProto.finally = function (onfinally) {\n        return this._$.finally(onfinally);\n    };\n    return PolyPromiseImpl;\n}());\n\nexport { PolyPromise, arrForEachAsync, createAllPromise, createAllSettledPromise, createAnyPromise, createAsyncAllPromise, createAsyncAllSettledPromise, createAsyncAnyPromise, createAsyncPromise, createAsyncRacePromise, createAsyncRejectedPromise, createAsyncResolvedPromise, createIdleAllPromise, createIdleAllSettledPromise, createIdleAnyPromise, createIdlePromise, createIdleRacePromise, createIdleRejectedPromise, createIdleResolvedPromise, createNativeAllPromise, createNativeAllSettledPromise, createNativeAnyPromise, createNativePromise, createNativeRacePromise, createNativeRejectedPromise, createNativeResolvedPromise, createPromise, createRacePromise, createRejectedPromise, createResolvedPromise, createSyncAllPromise, createSyncAllSettledPromise, createSyncAnyPromise, createSyncPromise, createSyncRacePromise, createSyncRejectedPromise, createSyncResolvedPromise, createTaskScheduler, createTimeoutPromise, doAwait, doAwaitResponse, doFinally, doWhileAsync, iterForOfAsync, setCreatePromiseImpl, setDefaultIdlePromiseTimeout, setDefaultIdleTimeout, setPromiseDebugState };\n//# sourceMappingURL=ts-async.js.map\n","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nvar _a;\r\nimport { getGlobal, objCreate, objHasOwnProperty, throwTypeError } from \"@nevware21/ts-utils\";\r\n;\r\nvar UNDEFINED = \"undefined\";\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar Constructor = 'constructor';\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar Prototype = 'prototype';\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar strFunction = 'function';\r\n/**\r\n * Used to define the name of the instance function lookup table\r\n * @ignore\r\n */\r\nvar DynInstFuncTable = '_dynInstFuncs';\r\n/**\r\n * Name used to tag the dynamic prototype function\r\n * @ignore\r\n */\r\nvar DynProxyTag = '_isDynProxy';\r\n/**\r\n * Name added to a prototype to define the dynamic prototype \"class\" name used to lookup the function table\r\n * @ignore\r\n */\r\nvar DynClassName = '_dynClass';\r\n/**\r\n * Prefix added to the classname to avoid any name clashes with other instance level properties\r\n * @ignore\r\n */\r\nvar DynClassNamePrefix = '_dynCls$';\r\n/**\r\n * A tag which is used to check if we have already to attempted to set the instance function if one is not present\r\n * @ignore\r\n */\r\nvar DynInstChkTag = '_dynInstChk';\r\n/**\r\n * A tag which is used to check if we are allows to try and set an instance function is one is not present. Using the same\r\n * tag name as the function level but a different const name for readability only.\r\n */\r\nvar DynAllowInstChkTag = DynInstChkTag;\r\n/**\r\n * The global (imported) instances where the global performance options are stored\r\n */\r\nvar DynProtoDefaultOptions = '_dfOpts';\r\n/**\r\n * Value used as the name of a class when it cannot be determined\r\n * @ignore\r\n */\r\nvar UnknownValue = '_unknown_';\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar str__Proto = \"__proto__\";\r\n/**\r\n * The polyfill version of __proto__ so that it doesn't cause issues for anyone not expecting it to exist\r\n */\r\nvar DynProtoBaseProto = \"_dyn\" + str__Proto;\r\n/**\r\n * Runtime Global holder for dynamicProto settings\r\n */\r\nvar DynProtoGlobalSettings = \"__dynProto$Gbl\";\r\n/**\r\n * Track the current prototype for IE8 as you can't look back to get the prototype\r\n */\r\nvar DynProtoCurrent = \"_dynInstProto\";\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar strUseBaseInst = 'useBaseInst';\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar strSetInstFuncs = 'setInstFuncs';\r\nvar Obj = Object;\r\n/**\r\n * Pre-lookup to check if we are running on a modern browser (i.e. not IE8)\r\n * @ignore\r\n */\r\nvar _objGetPrototypeOf = Obj[\"getPrototypeOf\"];\r\n/**\r\n * Pre-lookup to check for the existence of this function\r\n */\r\nvar _objGetOwnProps = Obj[\"getOwnPropertyNames\"];\r\n// Since 1.1.7 moving these to the runtime global to work around mixed version and module issues\r\n// See Issue https://github.com/microsoft/DynamicProto-JS/issues/57 for details\r\nvar _gbl = getGlobal();\r\nvar _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {\r\n    o: (_a = {},\r\n        _a[strSetInstFuncs] = true,\r\n        _a[strUseBaseInst] = true,\r\n        _a),\r\n    n: 1000 // Start new global index @ 1000 so we \"fix\" some cases when mixed with 1.1.6 or earlier\r\n});\r\n/**\r\n * Helper used to check whether the target is an Object prototype or Array prototype\r\n * @ignore\r\n */\r\nfunction _isObjectOrArrayPrototype(target) {\r\n    return target && (target === Obj[Prototype] || target === Array[Prototype]);\r\n}\r\n/**\r\n * Helper used to check whether the target is an Object prototype, Array prototype or Function prototype\r\n * @ignore\r\n */\r\nfunction _isObjectArrayOrFunctionPrototype(target) {\r\n    return _isObjectOrArrayPrototype(target) || target === Function[Prototype];\r\n}\r\n/**\r\n * Helper used to get the prototype of the target object as getPrototypeOf is not available in an ES3 environment.\r\n * @ignore\r\n */\r\nfunction _getObjProto(target) {\r\n    var newProto;\r\n    if (target) {\r\n        // This method doesn't exist in older browsers (e.g. IE8)\r\n        if (_objGetPrototypeOf) {\r\n            return _objGetPrototypeOf(target);\r\n        }\r\n        var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);\r\n        // Using the pre-calculated value as IE8 doesn't support looking up the prototype of a prototype and thus fails for more than 1 base class\r\n        newProto = target[DynProtoBaseProto] || curProto;\r\n        if (!objHasOwnProperty(target, DynProtoBaseProto)) {\r\n            // As this prototype doesn't have this property then this is from an inherited class so newProto is the base to return so save it\r\n            // so we can look it up value (which for a multiple hierarchy dynamicProto will be the base class)\r\n            delete target[DynProtoCurrent]; // Delete any current value allocated to this instance so we pick up the value from prototype hierarchy\r\n            newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];\r\n            target[DynProtoCurrent] = curProto;\r\n        }\r\n    }\r\n    return newProto;\r\n}\r\n/**\r\n * Helper to get the properties of an object, including none enumerable ones as functions on a prototype in ES6\r\n * are not enumerable.\r\n * @param target\r\n */\r\nfunction _forEachProp(target, func) {\r\n    var props = [];\r\n    if (_objGetOwnProps) {\r\n        props = _objGetOwnProps(target);\r\n    }\r\n    else {\r\n        for (var name_1 in target) {\r\n            if (typeof name_1 === \"string\" && objHasOwnProperty(target, name_1)) {\r\n                props.push(name_1);\r\n            }\r\n        }\r\n    }\r\n    if (props && props.length > 0) {\r\n        for (var lp = 0; lp < props.length; lp++) {\r\n            func(props[lp]);\r\n        }\r\n    }\r\n}\r\n/**\r\n * Helper function to check whether the provided function name is a potential candidate for dynamic\r\n * callback and prototype generation.\r\n * @param target The target object, may be a prototype or class object\r\n * @param funcName The function name\r\n * @param skipOwn Skips the check for own property\r\n * @ignore\r\n */\r\nfunction _isDynamicCandidate(target, funcName, skipOwn) {\r\n    return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || objHasOwnProperty(target, funcName)) && funcName !== str__Proto && funcName !== Prototype);\r\n}\r\n/**\r\n * Helper to throw a TypeError exception\r\n * @param message the message\r\n * @ignore\r\n */\r\nfunction _throwTypeError(message) {\r\n    throwTypeError(\"DynamicProto: \" + message);\r\n}\r\n/**\r\n * Returns a collection of the instance functions that are defined directly on the thisTarget object, it does\r\n * not return any inherited functions\r\n * @param thisTarget The object to get the instance functions from\r\n * @ignore\r\n */\r\nfunction _getInstanceFuncs(thisTarget) {\r\n    // Get the base proto\r\n    var instFuncs = objCreate(null);\r\n    // Save any existing instance functions\r\n    _forEachProp(thisTarget, function (name) {\r\n        // Don't include any dynamic prototype instances - as we only want the real functions\r\n        if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {\r\n            // Create an instance callback for passing the base function to the caller\r\n            instFuncs[name] = thisTarget[name];\r\n        }\r\n    });\r\n    return instFuncs;\r\n}\r\n/**\r\n * Returns whether the value is included in the array\r\n * @param values The array of values\r\n * @param value  The value\r\n */\r\nfunction _hasVisited(values, value) {\r\n    for (var lp = values.length - 1; lp >= 0; lp--) {\r\n        if (values[lp] === value) {\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\n/**\r\n * Returns an object that contains callback functions for all \"base/super\" functions, this is used to \"save\"\r\n * enabling calling super.xxx() functions without requiring that the base \"class\" has defined a prototype references\r\n * @param target The current instance\r\n * @ignore\r\n */\r\nfunction _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {\r\n    function _instFuncProxy(target, funcHost, funcName) {\r\n        var theFunc = funcHost[funcName];\r\n        if (theFunc[DynProxyTag] && useBaseInst) {\r\n            // grab and reuse the hosted looking function (if available) otherwise the original passed function\r\n            var instFuncTable = target[DynInstFuncTable] || {};\r\n            if (instFuncTable[DynAllowInstChkTag] !== false) {\r\n                theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;\r\n            }\r\n        }\r\n        return function () {\r\n            // eslint-disable-next-line prefer-rest-params\r\n            return theFunc.apply(target, arguments);\r\n        };\r\n    }\r\n    // Start creating a new baseFuncs by creating proxies for the instance functions (as they may get replaced)\r\n    var baseFuncs = objCreate(null);\r\n    _forEachProp(instFuncs, function (name) {\r\n        // Create an instance callback for passing the base function to the caller\r\n        baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);\r\n    });\r\n    // Get the base prototype functions\r\n    var baseProto = _getObjProto(classProto);\r\n    var visited = [];\r\n    // Don't include base object functions for Object, Array or Function\r\n    while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {\r\n        // look for prototype functions\r\n        _forEachProp(baseProto, function (name) {\r\n            // Don't include any dynamic prototype instances - as we only want the real functions\r\n            // For IE 7/8 the prototype lookup doesn't provide the full chain so we need to bypass the \r\n            // hasOwnProperty check we get all of the methods, main difference is that IE7/8 doesn't return\r\n            // the Object prototype methods while bypassing the check\r\n            if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {\r\n                // Create an instance callback for passing the base function to the caller\r\n                baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);\r\n            }\r\n        });\r\n        // We need to find all possible functions that might be overloaded by walking the entire prototype chain\r\n        // This avoids the caller from needing to check whether it's direct base class implements the function or not\r\n        // by walking the entire chain it simplifies the usage and issues from upgrading any of the base classes.\r\n        visited.push(baseProto);\r\n        baseProto = _getObjProto(baseProto);\r\n    }\r\n    return baseFuncs;\r\n}\r\nfunction _getInstFunc(target, funcName, proto, currentDynProtoProxy) {\r\n    var instFunc = null;\r\n    // We need to check whether the class name is defined directly on this prototype otherwise\r\n    // it will walk the proto chain and return any parent proto classname.\r\n    if (target && objHasOwnProperty(proto, DynClassName)) {\r\n        var instFuncTable = target[DynInstFuncTable] || objCreate(null);\r\n        instFunc = (instFuncTable[proto[DynClassName]] || objCreate(null))[funcName];\r\n        if (!instFunc) {\r\n            // Avoid stack overflow from recursive calling the same function\r\n            _throwTypeError(\"Missing [\" + funcName + \"] \" + strFunction);\r\n        }\r\n        // We have the instance function, lets check it we can speed up further calls\r\n        // by adding the instance function back directly on the instance (avoiding the dynamic func lookup)\r\n        if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {\r\n            // If the instance already has an instance function we can't replace it\r\n            var canAddInst = !objHasOwnProperty(target, funcName);\r\n            // Get current prototype\r\n            var objProto = _getObjProto(target);\r\n            var visited = [];\r\n            // Lookup the function starting at the top (instance level prototype) and traverse down, if the first matching function\r\n            // if nothing is found or if the first hit is a dynamic proto instance then we can safely add an instance shortcut\r\n            while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {\r\n                var protoFunc = objProto[funcName];\r\n                if (protoFunc) {\r\n                    canAddInst = (protoFunc === currentDynProtoProxy);\r\n                    break;\r\n                }\r\n                // We need to find all possible initial functions to ensure that we don't bypass a valid override function\r\n                visited.push(objProto);\r\n                objProto = _getObjProto(objProto);\r\n            }\r\n            try {\r\n                if (canAddInst) {\r\n                    // This instance doesn't have an instance func and the class hierarchy does have a higher level prototype version\r\n                    // so it's safe to directly assign for any subsequent calls (for better performance)\r\n                    target[funcName] = instFunc;\r\n                }\r\n                // Block further attempts to set the instance function for any\r\n                instFunc[DynInstChkTag] = 1;\r\n            }\r\n            catch (e) {\r\n                // Don't crash if the object is readonly or the runtime doesn't allow changing this\r\n                // And set a flag so we don't try again for any function\r\n                instFuncTable[DynAllowInstChkTag] = false;\r\n            }\r\n        }\r\n    }\r\n    return instFunc;\r\n}\r\nfunction _getProtoFunc(funcName, proto, currentDynProtoProxy) {\r\n    var protoFunc = proto[funcName];\r\n    // Check that the prototype function is not a self reference -- try to avoid stack overflow!\r\n    if (protoFunc === currentDynProtoProxy) {\r\n        // It is so lookup the base prototype\r\n        protoFunc = _getObjProto(proto)[funcName];\r\n    }\r\n    if (typeof protoFunc !== strFunction) {\r\n        _throwTypeError(\"[\" + funcName + \"] is not a \" + strFunction);\r\n    }\r\n    return protoFunc;\r\n}\r\n/**\r\n * Add the required dynamic prototype methods to the the class prototype\r\n * @param proto - The class prototype\r\n * @param className - The instance classname\r\n * @param target - The target instance\r\n * @param baseInstFuncs - The base instance functions\r\n * @param setInstanceFunc - Flag to allow prototype function to reset the instance function if one does not exist\r\n * @ignore\r\n */\r\nfunction _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {\r\n    function _createDynamicPrototype(proto, funcName) {\r\n        var dynProtoProxy = function () {\r\n            // Use the instance or prototype function\r\n            var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);\r\n            // eslint-disable-next-line prefer-rest-params\r\n            return instFunc.apply(this, arguments);\r\n        };\r\n        // Tag this function as a proxy to support replacing dynamic proxy elements (primary use case is for unit testing\r\n        // via which can dynamically replace the prototype function reference)\r\n        dynProtoProxy[DynProxyTag] = 1;\r\n        return dynProtoProxy;\r\n    }\r\n    if (!_isObjectOrArrayPrototype(proto)) {\r\n        var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || objCreate(null);\r\n        if (!_isObjectOrArrayPrototype(instFuncTable)) {\r\n            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || objCreate(null)); // fetch and assign if as it may not exist yet\r\n            // Set whether we are allow to lookup instances, if someone has set to false then do not re-enable\r\n            if (instFuncTable[DynAllowInstChkTag] !== false) {\r\n                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;\r\n            }\r\n            if (!_isObjectOrArrayPrototype(instFuncs_1)) {\r\n                _forEachProp(target, function (name) {\r\n                    // Only add overridden functions\r\n                    if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {\r\n                        // Save the instance Function to the lookup table and remove it from the instance as it's not a dynamic proto function\r\n                        instFuncs_1[name] = target[name];\r\n                        delete target[name];\r\n                        // Add a dynamic proto if one doesn't exist or if a prototype function exists and it's not a dynamic one\r\n                        if (!objHasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {\r\n                            proto[name] = _createDynamicPrototype(proto, name);\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n        }\r\n    }\r\n}\r\n/**\r\n * Checks whether the passed prototype object appears to be correct by walking the prototype hierarchy of the instance\r\n * @param classProto The class prototype instance\r\n * @param thisTarget The current instance that will be checked whether the passed prototype instance is in the hierarchy\r\n * @ignore\r\n */\r\nfunction _checkPrototype(classProto, thisTarget) {\r\n    // This method doesn't existing in older browsers (e.g. IE8)\r\n    if (_objGetPrototypeOf) {\r\n        // As this is primarily a coding time check, don't bother checking if running in IE8 or lower\r\n        var visited = [];\r\n        var thisProto = _getObjProto(thisTarget);\r\n        while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {\r\n            if (thisProto === classProto) {\r\n                return true;\r\n            }\r\n            // This avoids the caller from needing to check whether it's direct base class implements the function or not\r\n            // by walking the entire chain it simplifies the usage and issues from upgrading any of the base classes.\r\n            visited.push(thisProto);\r\n            thisProto = _getObjProto(thisProto);\r\n        }\r\n        return false;\r\n    }\r\n    // If objGetPrototypeOf doesn't exist then just assume everything is ok.\r\n    return true;\r\n}\r\n/**\r\n * Gets the current prototype name using the ES6 name if available otherwise falling back to a use unknown as the name.\r\n * It's not critical for this to return a name, it's used to decorate the generated unique name for easier debugging only.\r\n * @param target\r\n * @param unknownValue\r\n * @ignore\r\n */\r\nfunction _getObjName(target, unknownValue) {\r\n    if (objHasOwnProperty(target, Prototype)) {\r\n        // Look like a prototype\r\n        return target.name || unknownValue || UnknownValue;\r\n    }\r\n    return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;\r\n}\r\n/**\r\n * Helper function when creating dynamic (inline) functions for classes, this helper performs the following tasks :-\r\n * - Saves references to all defined base class functions\r\n * - Calls the delegateFunc with the current target (this) and a base object reference that can be used to call all \"super\" functions.\r\n * - Will populate the class prototype for all overridden functions to support class extension that call the prototype instance.\r\n * Callers should use this helper when declaring all function within the constructor of a class, as mentioned above the delegateFunc is\r\n * passed both the target \"this\" and an object that can be used to call any base (super) functions, using this based object in place of\r\n * super.XXX() (which gets expanded to _super.prototype.XXX()) provides a better minification outcome and also ensures the correct \"this\"\r\n * context is maintained as TypeScript creates incorrect references using super.XXXX() for dynamically defined functions i.e. Functions\r\n * defined in the constructor or some other function (rather than declared as complete typescript functions).\r\n * ### Usage\r\n * ```typescript\r\n * import dynamicProto from \"@microsoft/dynamicproto-js\";\r\n * class ExampleClass extends BaseClass {\r\n *     constructor() {\r\n *         dynamicProto(ExampleClass, this, (_self, base) => {\r\n *             // This will define a function that will be converted to a prototype function\r\n *             _self.newFunc = () => {\r\n *                 // Access any \"this\" instance property\r\n *                 if (_self.someProperty) {\r\n *                     ...\r\n *                 }\r\n *             }\r\n *             // This will define a function that will be converted to a prototype function\r\n *             _self.myFunction = () => {\r\n *                 // Access any \"this\" instance property\r\n *                 if (_self.someProperty) {\r\n *                     // Call the base version of the function that we are overriding\r\n *                     base.myFunction();\r\n *                 }\r\n *                 ...\r\n *             }\r\n *             _self.initialize = () => {\r\n *                 ...\r\n *             }\r\n *             // Warnings: While the following will work as _self is simply a reference to\r\n *             // this, if anyone overrides myFunction() the overridden will be called first\r\n *             // as the normal JavaScript method resolution will occur and the defined\r\n *             // _self.initialize() function is actually gets removed from the instance and\r\n *             // a proxy prototype version is created to reference the created method.\r\n *             _self.initialize();\r\n *         });\r\n *     }\r\n * }\r\n * ```\r\n * @typeparam DPType This is the generic type of the class, used to keep intellisense valid\r\n * @typeparam DPCls The type that contains the prototype of the current class\r\n * @param theClass - This is the current class instance which contains the prototype for the current class\r\n * @param target - The current \"this\" (target) reference, when the class has been extended this.prototype will not be the 'theClass' value.\r\n * @param delegateFunc - The callback function (closure) that will create the dynamic function\r\n * @param options - Additional options to configure how the dynamic prototype operates\r\n */\r\nexport default function dynamicProto(theClass, target, delegateFunc, options) {\r\n    // Make sure that the passed theClass argument looks correct\r\n    if (!objHasOwnProperty(theClass, Prototype)) {\r\n        _throwTypeError(\"theClass is an invalid class definition.\");\r\n    }\r\n    // Quick check to make sure that the passed theClass argument looks correct (this is a common copy/paste error)\r\n    var classProto = theClass[Prototype];\r\n    if (!_checkPrototype(classProto, target)) {\r\n        _throwTypeError(\"[\" + _getObjName(theClass) + \"] not in hierarchy of [\" + _getObjName(target) + \"]\");\r\n    }\r\n    var className = null;\r\n    if (objHasOwnProperty(classProto, DynClassName)) {\r\n        // Only grab the class name if it's defined on this prototype (i.e. don't walk the prototype chain)\r\n        className = classProto[DynClassName];\r\n    }\r\n    else {\r\n        // As not all browser support name on the prototype creating a unique dynamic one if we have not already\r\n        // assigned one, so we can use a simple string as the lookup rather than an object for the dynamic instance\r\n        // function table lookup.\r\n        className = DynClassNamePrefix + _getObjName(theClass, \"_\") + \"$\" + _gblInst.n;\r\n        _gblInst.n++;\r\n        classProto[DynClassName] = className;\r\n    }\r\n    var perfOptions = dynamicProto[DynProtoDefaultOptions];\r\n    var useBaseInst = !!perfOptions[strUseBaseInst];\r\n    if (useBaseInst && options && options[strUseBaseInst] !== undefined) {\r\n        useBaseInst = !!options[strUseBaseInst];\r\n    }\r\n    // Get the current instance functions\r\n    var instFuncs = _getInstanceFuncs(target);\r\n    // Get all of the functions for any base instance (before they are potentially overridden)\r\n    var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);\r\n    // Execute the delegate passing in both the current target \"this\" and \"base\" function references\r\n    // Note casting the same type as we don't actually have the base class here and this will provide some intellisense support\r\n    delegateFunc(target, baseFuncs);\r\n    // Don't allow setting instance functions for older IE instances\r\n    var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];\r\n    if (setInstanceFunc && options) {\r\n        setInstanceFunc = !!options[strSetInstFuncs];\r\n    }\r\n    // Populate the Prototype for any overridden instance functions\r\n    _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);\r\n}\r\n/**\r\n * Exposes the default global options to allow global configuration, if the global values are disabled these will override\r\n * any passed values. This is primarily exposed to support unit-testing without the need for individual classes to expose\r\n * their internal usage of dynamic proto.\r\n */\r\ndynamicProto[DynProtoDefaultOptions] = _gblInst.o;\r\n//# sourceMappingURL=DynamicProto.js.map","/*!\n * Microsoft Dynamic Proto Utility, 1.1.11\n * Copyright (c) Microsoft and contributors. All rights reserved.\n */\nvar _a;\r\nvar UNDEFINED = \"undefined\";\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar Constructor = 'constructor';\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar Prototype = 'prototype';\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar strFunction = 'function';\r\n/**\r\n * Used to define the name of the instance function lookup table\r\n * @ignore\r\n */\r\nvar DynInstFuncTable = '_dynInstFuncs';\r\n/**\r\n * Name used to tag the dynamic prototype function\r\n * @ignore\r\n */\r\nvar DynProxyTag = '_isDynProxy';\r\n/**\r\n * Name added to a prototype to define the dynamic prototype \"class\" name used to lookup the function table\r\n * @ignore\r\n */\r\nvar DynClassName = '_dynClass';\r\n/**\r\n * Prefix added to the classname to avoid any name clashes with other instance level properties\r\n * @ignore\r\n */\r\nvar DynClassNamePrefix = '_dynCls$';\r\n/**\r\n * A tag which is used to check if we have already to attempted to set the instance function if one is not present\r\n * @ignore\r\n */\r\nvar DynInstChkTag = '_dynInstChk';\r\n/**\r\n * A tag which is used to check if we are allows to try and set an instance function is one is not present. Using the same\r\n * tag name as the function level but a different const name for readability only.\r\n */\r\nvar DynAllowInstChkTag = DynInstChkTag;\r\n/**\r\n * The global (imported) instances where the global performance options are stored\r\n */\r\nvar DynProtoDefaultOptions = '_dfOpts';\r\n/**\r\n * Value used as the name of a class when it cannot be determined\r\n * @ignore\r\n */\r\nvar UnknownValue = '_unknown_';\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar str__Proto = \"__proto__\";\r\n/**\r\n * The polyfill version of __proto__ so that it doesn't cause issues for anyone not expecting it to exist\r\n */\r\nvar DynProtoBaseProto = \"_dyn\" + str__Proto;\r\n/**\r\n * Runtime Global holder for dynamicProto settings\r\n */\r\nvar DynProtoGlobalSettings = \"__dynProto$Gbl\";\r\n/**\r\n * Track the current prototype for IE8 as you can't look back to get the prototype\r\n */\r\nvar DynProtoCurrent = \"_dynInstProto\";\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar strUseBaseInst = 'useBaseInst';\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nvar strSetInstFuncs = 'setInstFuncs';\r\nvar Obj = Object;\r\n/**\r\n * Pre-lookup to check if we are running on a modern browser (i.e. not IE8)\r\n * @ignore\r\n */\r\nvar _objGetPrototypeOf = Obj[\"getPrototypeOf\"];\r\n/**\r\n * Pre-lookup to check for the existence of this function\r\n */\r\nvar _objGetOwnProps = Obj[\"getOwnPropertyNames\"];\r\n/**\r\n * Gets the runtime global reference\r\n * @returns\r\n */\r\nfunction _getGlobal() {\r\n    var result;\r\n    if (typeof globalThis !== UNDEFINED) {\r\n        result = globalThis;\r\n    }\r\n    if (!result && typeof self !== UNDEFINED) {\r\n        result = self;\r\n    }\r\n    if (!result && typeof window !== UNDEFINED) {\r\n        result = window;\r\n    }\r\n    if (!result && typeof global !== UNDEFINED) {\r\n        result = global;\r\n    }\r\n    return result || {};\r\n}\r\n// Since 1.1.7 moving these to the runtime global to work around mixed version and module issues\r\n// See Issue https://github.com/microsoft/DynamicProto-JS/issues/57 for details\r\nvar _gbl = _getGlobal();\r\nvar _gblInst = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {\r\n    o: (_a = {},\r\n        _a[strSetInstFuncs] = true,\r\n        _a[strUseBaseInst] = true,\r\n        _a),\r\n    n: 1000 // Start new global index @ 1000 so we \"fix\" some cases when mixed with 1.1.6 or earlier\r\n});\r\n/**\r\n * Helper to check if the object contains a property of the name\r\n * @ignore\r\n */\r\nfunction _hasOwnProperty(obj, prop) {\r\n    return obj && Obj[Prototype].hasOwnProperty.call(obj, prop);\r\n}\r\n/**\r\n * Helper used to check whether the target is an Object prototype or Array prototype\r\n * @ignore\r\n */\r\nfunction _isObjectOrArrayPrototype(target) {\r\n    return target && (target === Obj[Prototype] || target === Array[Prototype]);\r\n}\r\n/**\r\n * Helper used to check whether the target is an Object prototype, Array prototype or Function prototype\r\n * @ignore\r\n */\r\nfunction _isObjectArrayOrFunctionPrototype(target) {\r\n    return _isObjectOrArrayPrototype(target) || target === Function[Prototype];\r\n}\r\n/**\r\n * Helper used to get the prototype of the target object as getPrototypeOf is not available in an ES3 environment.\r\n * @ignore\r\n */\r\nfunction _getObjProto(target) {\r\n    var newProto;\r\n    if (target) {\r\n        // This method doesn't exist in older browsers (e.g. IE8)\r\n        if (_objGetPrototypeOf) {\r\n            return _objGetPrototypeOf(target);\r\n        }\r\n        var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);\r\n        // Using the pre-calculated value as IE8 doesn't support looking up the prototype of a prototype and thus fails for more than 1 base class\r\n        newProto = target[DynProtoBaseProto] || curProto;\r\n        if (!_hasOwnProperty(target, DynProtoBaseProto)) {\r\n            // As this prototype doesn't have this property then this is from an inherited class so newProto is the base to return so save it\r\n            // so we can look it up value (which for a multiple hierarchy dynamicProto will be the base class)\r\n            delete target[DynProtoCurrent]; // Delete any current value allocated to this instance so we pick up the value from prototype hierarchy\r\n            newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];\r\n            target[DynProtoCurrent] = curProto;\r\n        }\r\n    }\r\n    return newProto;\r\n}\r\n/**\r\n * Helper to get the properties of an object, including none enumerable ones as functions on a prototype in ES6\r\n * are not enumerable.\r\n * @param target\r\n */\r\nfunction _forEachProp(target, func) {\r\n    var props = [];\r\n    if (_objGetOwnProps) {\r\n        props = _objGetOwnProps(target);\r\n    }\r\n    else {\r\n        for (var name_1 in target) {\r\n            if (typeof name_1 === \"string\" && _hasOwnProperty(target, name_1)) {\r\n                props.push(name_1);\r\n            }\r\n        }\r\n    }\r\n    if (props && props.length > 0) {\r\n        for (var lp = 0; lp < props.length; lp++) {\r\n            func(props[lp]);\r\n        }\r\n    }\r\n}\r\n/**\r\n * Helper function to check whether the provided function name is a potential candidate for dynamic\r\n * callback and prototype generation.\r\n * @param target The target object, may be a prototype or class object\r\n * @param funcName The function name\r\n * @param skipOwn Skips the check for own property\r\n * @ignore\r\n */\r\nfunction _isDynamicCandidate(target, funcName, skipOwn) {\r\n    return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || _hasOwnProperty(target, funcName)) && funcName !== str__Proto && funcName !== Prototype);\r\n}\r\n/**\r\n * Helper to throw a TypeError exception\r\n * @param message the message\r\n * @ignore\r\n */\r\nfunction _throwTypeError(message) {\r\n    throw new TypeError(\"DynamicProto: \" + message);\r\n}\r\nfunction _newObject() {\r\n    return Object.create ? (function(obj) { /* ai_es3_polyfil create */ var func = Object[\"create\"]; if (func) { return func(obj); } if (obj == null) { return {}; } var type = typeof obj; if (type !== 'object' && type !== 'function') { throw new TypeError('Object prototype may only be an Object:' + obj); } function tmpFunc() {} tmpFunc.prototype = obj; return new tmpFunc(); })(null) : {};\r\n}\r\n/**\r\n * Returns a collection of the instance functions that are defined directly on the thisTarget object, it does\r\n * not return any inherited functions\r\n * @param thisTarget The object to get the instance functions from\r\n * @ignore\r\n */\r\nfunction _getInstanceFuncs(thisTarget) {\r\n    // Get the base proto\r\n    var instFuncs = _newObject();\r\n    // Save any existing instance functions\r\n    _forEachProp(thisTarget, function (name) {\r\n        // Don't include any dynamic prototype instances - as we only want the real functions\r\n        if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {\r\n            // Create an instance callback for passing the base function to the caller\r\n            instFuncs[name] = thisTarget[name];\r\n        }\r\n    });\r\n    return instFuncs;\r\n}\r\n/**\r\n * Returns whether the value is included in the array\r\n * @param values The array of values\r\n * @param value  The value\r\n */\r\nfunction _hasVisited(values, value) {\r\n    for (var lp = values.length - 1; lp >= 0; lp--) {\r\n        if (values[lp] === value) {\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\n/**\r\n * Returns an object that contains callback functions for all \"base/super\" functions, this is used to \"save\"\r\n * enabling calling super.xxx() functions without requiring that the base \"class\" has defined a prototype references\r\n * @param target The current instance\r\n * @ignore\r\n */\r\nfunction _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {\r\n    function _instFuncProxy(target, funcHost, funcName) {\r\n        var theFunc = funcHost[funcName];\r\n        if (theFunc[DynProxyTag] && useBaseInst) {\r\n            // grab and reuse the hosted looking function (if available) otherwise the original passed function\r\n            var instFuncTable = target[DynInstFuncTable] || {};\r\n            if (instFuncTable[DynAllowInstChkTag] !== false) {\r\n                theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;\r\n            }\r\n        }\r\n        return function () {\r\n            // eslint-disable-next-line prefer-rest-params\r\n            return theFunc.apply(target, arguments);\r\n        };\r\n    }\r\n    // Start creating a new baseFuncs by creating proxies for the instance functions (as they may get replaced)\r\n    var baseFuncs = _newObject();\r\n    _forEachProp(instFuncs, function (name) {\r\n        // Create an instance callback for passing the base function to the caller\r\n        baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);\r\n    });\r\n    // Get the base prototype functions\r\n    var baseProto = _getObjProto(classProto);\r\n    var visited = [];\r\n    // Don't include base object functions for Object, Array or Function\r\n    while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {\r\n        // look for prototype functions\r\n        _forEachProp(baseProto, function (name) {\r\n            // Don't include any dynamic prototype instances - as we only want the real functions\r\n            // For IE 7/8 the prototype lookup doesn't provide the full chain so we need to bypass the \r\n            // hasOwnProperty check we get all of the methods, main difference is that IE7/8 doesn't return\r\n            // the Object prototype methods while bypassing the check\r\n            if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {\r\n                // Create an instance callback for passing the base function to the caller\r\n                baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);\r\n            }\r\n        });\r\n        // We need to find all possible functions that might be overloaded by walking the entire prototype chain\r\n        // This avoids the caller from needing to check whether it's direct base class implements the function or not\r\n        // by walking the entire chain it simplifies the usage and issues from upgrading any of the base classes.\r\n        visited.push(baseProto);\r\n        baseProto = _getObjProto(baseProto);\r\n    }\r\n    return baseFuncs;\r\n}\r\nfunction _getInstFunc(target, funcName, proto, currentDynProtoProxy) {\r\n    var instFunc = null;\r\n    // We need to check whether the class name is defined directly on this prototype otherwise\r\n    // it will walk the proto chain and return any parent proto classname.\r\n    if (target && _hasOwnProperty(proto, DynClassName)) {\r\n        var instFuncTable = target[DynInstFuncTable] || _newObject();\r\n        instFunc = (instFuncTable[proto[DynClassName]] || _newObject())[funcName];\r\n        if (!instFunc) {\r\n            // Avoid stack overflow from recursive calling the same function\r\n            _throwTypeError(\"Missing [\" + funcName + \"] \" + strFunction);\r\n        }\r\n        // We have the instance function, lets check it we can speed up further calls\r\n        // by adding the instance function back directly on the instance (avoiding the dynamic func lookup)\r\n        if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {\r\n            // If the instance already has an instance function we can't replace it\r\n            var canAddInst = !_hasOwnProperty(target, funcName);\r\n            // Get current prototype\r\n            var objProto = _getObjProto(target);\r\n            var visited = [];\r\n            // Lookup the function starting at the top (instance level prototype) and traverse down, if the first matching function\r\n            // if nothing is found or if the first hit is a dynamic proto instance then we can safely add an instance shortcut\r\n            while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {\r\n                var protoFunc = objProto[funcName];\r\n                if (protoFunc) {\r\n                    canAddInst = (protoFunc === currentDynProtoProxy);\r\n                    break;\r\n                }\r\n                // We need to find all possible initial functions to ensure that we don't bypass a valid override function\r\n                visited.push(objProto);\r\n                objProto = _getObjProto(objProto);\r\n            }\r\n            try {\r\n                if (canAddInst) {\r\n                    // This instance doesn't have an instance func and the class hierarchy does have a higher level prototype version\r\n                    // so it's safe to directly assign for any subsequent calls (for better performance)\r\n                    target[funcName] = instFunc;\r\n                }\r\n                // Block further attempts to set the instance function for any\r\n                instFunc[DynInstChkTag] = 1;\r\n            }\r\n            catch (e) {\r\n                // Don't crash if the object is readonly or the runtime doesn't allow changing this\r\n                // And set a flag so we don't try again for any function\r\n                instFuncTable[DynAllowInstChkTag] = false;\r\n            }\r\n        }\r\n    }\r\n    return instFunc;\r\n}\r\nfunction _getProtoFunc(funcName, proto, currentDynProtoProxy) {\r\n    var protoFunc = proto[funcName];\r\n    // Check that the prototype function is not a self reference -- try to avoid stack overflow!\r\n    if (protoFunc === currentDynProtoProxy) {\r\n        // It is so lookup the base prototype\r\n        protoFunc = _getObjProto(proto)[funcName];\r\n    }\r\n    if (typeof protoFunc !== strFunction) {\r\n        _throwTypeError(\"[\" + funcName + \"] is not a \" + strFunction);\r\n    }\r\n    return protoFunc;\r\n}\r\n/**\r\n * Add the required dynamic prototype methods to the the class prototype\r\n * @param proto - The class prototype\r\n * @param className - The instance classname\r\n * @param target - The target instance\r\n * @param baseInstFuncs - The base instance functions\r\n * @param setInstanceFunc - Flag to allow prototype function to reset the instance function if one does not exist\r\n * @ignore\r\n */\r\nfunction _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {\r\n    function _createDynamicPrototype(proto, funcName) {\r\n        var dynProtoProxy = function () {\r\n            // Use the instance or prototype function\r\n            var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);\r\n            // eslint-disable-next-line prefer-rest-params\r\n            return instFunc.apply(this, arguments);\r\n        };\r\n        // Tag this function as a proxy to support replacing dynamic proxy elements (primary use case is for unit testing\r\n        // via which can dynamically replace the prototype function reference)\r\n        dynProtoProxy[DynProxyTag] = 1;\r\n        return dynProtoProxy;\r\n    }\r\n    if (!_isObjectOrArrayPrototype(proto)) {\r\n        var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || _newObject();\r\n        if (!_isObjectOrArrayPrototype(instFuncTable)) {\r\n            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || _newObject()); // fetch and assign if as it may not exist yet\r\n            // Set whether we are allow to lookup instances, if someone has set to false then do not re-enable\r\n            if (instFuncTable[DynAllowInstChkTag] !== false) {\r\n                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;\r\n            }\r\n            if (!_isObjectOrArrayPrototype(instFuncs_1)) {\r\n                _forEachProp(target, function (name) {\r\n                    // Only add overridden functions\r\n                    if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {\r\n                        // Save the instance Function to the lookup table and remove it from the instance as it's not a dynamic proto function\r\n                        instFuncs_1[name] = target[name];\r\n                        delete target[name];\r\n                        // Add a dynamic proto if one doesn't exist or if a prototype function exists and it's not a dynamic one\r\n                        if (!_hasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {\r\n                            proto[name] = _createDynamicPrototype(proto, name);\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n        }\r\n    }\r\n}\r\n/**\r\n * Checks whether the passed prototype object appears to be correct by walking the prototype hierarchy of the instance\r\n * @param classProto The class prototype instance\r\n * @param thisTarget The current instance that will be checked whether the passed prototype instance is in the hierarchy\r\n * @ignore\r\n */\r\nfunction _checkPrototype(classProto, thisTarget) {\r\n    // This method doesn't existing in older browsers (e.g. IE8)\r\n    if (_objGetPrototypeOf) {\r\n        // As this is primarily a coding time check, don't bother checking if running in IE8 or lower\r\n        var visited = [];\r\n        var thisProto = _getObjProto(thisTarget);\r\n        while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {\r\n            if (thisProto === classProto) {\r\n                return true;\r\n            }\r\n            // This avoids the caller from needing to check whether it's direct base class implements the function or not\r\n            // by walking the entire chain it simplifies the usage and issues from upgrading any of the base classes.\r\n            visited.push(thisProto);\r\n            thisProto = _getObjProto(thisProto);\r\n        }\r\n        return false;\r\n    }\r\n    // If objGetPrototypeOf doesn't exist then just assume everything is ok.\r\n    return true;\r\n}\r\n/**\r\n * Gets the current prototype name using the ES6 name if available otherwise falling back to a use unknown as the name.\r\n * It's not critical for this to return a name, it's used to decorate the generated unique name for easier debugging only.\r\n * @param target\r\n * @param unknownValue\r\n * @ignore\r\n */\r\nfunction _getObjName(target, unknownValue) {\r\n    if (_hasOwnProperty(target, Prototype)) {\r\n        // Look like a prototype\r\n        return target.name || unknownValue || UnknownValue;\r\n    }\r\n    return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;\r\n}\r\n/**\r\n * Helper function when creating dynamic (inline) functions for classes, this helper performs the following tasks :-\r\n * - Saves references to all defined base class functions\r\n * - Calls the delegateFunc with the current target (this) and a base object reference that can be used to call all \"super\" functions.\r\n * - Will populate the class prototype for all overridden functions to support class extension that call the prototype instance.\r\n * Callers should use this helper when declaring all function within the constructor of a class, as mentioned above the delegateFunc is\r\n * passed both the target \"this\" and an object that can be used to call any base (super) functions, using this based object in place of\r\n * super.XXX() (which gets expanded to _super.prototype.XXX()) provides a better minification outcome and also ensures the correct \"this\"\r\n * context is maintained as TypeScript creates incorrect references using super.XXXX() for dynamically defined functions i.e. Functions\r\n * defined in the constructor or some other function (rather than declared as complete typescript functions).\r\n * ### Usage\r\n * ```typescript\r\n * import dynamicProto from \"@microsoft/dynamicproto-js\";\r\n * class ExampleClass extends BaseClass {\r\n *     constructor() {\r\n *         dynamicProto(ExampleClass, this, (_self, base) => {\r\n *             // This will define a function that will be converted to a prototype function\r\n *             _self.newFunc = () => {\r\n *                 // Access any \"this\" instance property\r\n *                 if (_self.someProperty) {\r\n *                     ...\r\n *                 }\r\n *             }\r\n *             // This will define a function that will be converted to a prototype function\r\n *             _self.myFunction = () => {\r\n *                 // Access any \"this\" instance property\r\n *                 if (_self.someProperty) {\r\n *                     // Call the base version of the function that we are overriding\r\n *                     base.myFunction();\r\n *                 }\r\n *                 ...\r\n *             }\r\n *             _self.initialize = () => {\r\n *                 ...\r\n *             }\r\n *             // Warnings: While the following will work as _self is simply a reference to\r\n *             // this, if anyone overrides myFunction() the overridden will be called first\r\n *             // as the normal JavaScript method resolution will occur and the defined\r\n *             // _self.initialize() function is actually gets removed from the instance and\r\n *             // a proxy prototype version is created to reference the created method.\r\n *             _self.initialize();\r\n *         });\r\n *     }\r\n * }\r\n * ```\r\n * @typeparam DPType This is the generic type of the class, used to keep intellisense valid\r\n * @typeparam DPCls The type that contains the prototype of the current class\r\n * @param theClass - This is the current class instance which contains the prototype for the current class\r\n * @param target - The current \"this\" (target) reference, when the class has been extended this.prototype will not be the 'theClass' value.\r\n * @param delegateFunc - The callback function (closure) that will create the dynamic function\r\n * @param options - Additional options to configure how the dynamic prototype operates\r\n */\r\nfunction dynamicProto(theClass, target, delegateFunc, options) {\r\n    // Make sure that the passed theClass argument looks correct\r\n    if (!_hasOwnProperty(theClass, Prototype)) {\r\n        _throwTypeError(\"theClass is an invalid class definition.\");\r\n    }\r\n    // Quick check to make sure that the passed theClass argument looks correct (this is a common copy/paste error)\r\n    var classProto = theClass[Prototype];\r\n    if (!_checkPrototype(classProto, target)) {\r\n        _throwTypeError(\"[\" + _getObjName(theClass) + \"] not in hierarchy of [\" + _getObjName(target) + \"]\");\r\n    }\r\n    var className = null;\r\n    if (_hasOwnProperty(classProto, DynClassName)) {\r\n        // Only grab the class name if it's defined on this prototype (i.e. don't walk the prototype chain)\r\n        className = classProto[DynClassName];\r\n    }\r\n    else {\r\n        // As not all browser support name on the prototype creating a unique dynamic one if we have not already\r\n        // assigned one, so we can use a simple string as the lookup rather than an object for the dynamic instance\r\n        // function table lookup.\r\n        className = DynClassNamePrefix + _getObjName(theClass, \"_\") + \"$\" + _gblInst.n;\r\n        _gblInst.n++;\r\n        classProto[DynClassName] = className;\r\n    }\r\n    var perfOptions = dynamicProto[DynProtoDefaultOptions];\r\n    var useBaseInst = !!perfOptions[strUseBaseInst];\r\n    if (useBaseInst && options && options[strUseBaseInst] !== undefined) {\r\n        useBaseInst = !!options[strUseBaseInst];\r\n    }\r\n    // Get the current instance functions\r\n    var instFuncs = _getInstanceFuncs(target);\r\n    // Get all of the functions for any base instance (before they are potentially overridden)\r\n    var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);\r\n    // Execute the delegate passing in both the current target \"this\" and \"base\" function references\r\n    // Note casting the same type as we don't actually have the base class here and this will provide some intellisense support\r\n    delegateFunc(target, baseFuncs);\r\n    // Don't allow setting instance functions for older IE instances\r\n    var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];\r\n    if (setInstanceFunc && options) {\r\n        setInstanceFunc = !!options[strSetInstFuncs];\r\n    }\r\n    // Populate the Prototype for any overridden instance functions\r\n    _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);\r\n}\r\n/**\r\n * Exposes the default global options to allow global configuration, if the global values are disabled these will override\r\n * any passed values. This is primarily exposed to support unit-testing without the need for individual classes to expose\r\n * their internal usage of dynamic proto.\r\n */\r\ndynamicProto[DynProtoDefaultOptions] = _gblInst.o;\n\nexport { dynamicProto as default };\n//# sourceMappingURL=dynamicproto-js.js.map\n","/*! https://github.com/nevware21/ts-utils v0.11.4 */\n/*\n * Copyright (c) NevWare21 Solutions LLC and contributors. All rights reserved.\n * Licensed under the MIT license.\n */\n/*#__NO_SIDE_EFFECTS__*/\nfunction _pureAssign(func1, func2) {\n    return func1 || func2;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _pureRef(value, name) {\n    return value[name];\n}\n\nvar UNDEF_VALUE = undefined;\nvar NULL_VALUE = null;\nvar EMPTY = \"\";\nvar FUNCTION = \"function\";\nvar OBJECT = \"object\";\nvar PROTOTYPE = \"prototype\";\nvar __PROTO__ = \"__proto__\";\nvar UNDEFINED = \"undefined\";\nvar CONSTRUCTOR = \"constructor\";\nvar SYMBOL = \"Symbol\";\nvar POLYFILL_TAG = \"_polyfill\";\nvar LENGTH = \"length\";\nvar NAME = \"name\";\nvar CALL = \"call\";\nvar TO_STRING = \"toString\";\nvar ObjClass = ( /*#__PURE__*/_pureAssign(Object));\nvar ObjProto = ( /*#__PURE__*/_pureRef(ObjClass, PROTOTYPE));\nvar StrCls = ( /*#__PURE__*/_pureAssign(String));\nvar StrProto = ( /*#__PURE__*/_pureRef(StrCls, PROTOTYPE));\nvar MathCls = ( /*#__PURE__*/_pureAssign(Math));\nvar ArrCls = ( /*#__PURE__*/_pureAssign(Array));\nvar ArrProto = ( /*#__PURE__*/_pureRef(ArrCls, PROTOTYPE));\nvar ArrSlice = ( /*#__PURE__*/_pureRef(ArrProto, \"slice\"));\n\nfunction safe(func, argArray) {\n    try {\n        return {\n            v: func.apply(this, argArray)\n        };\n    }\n    catch (e) {\n        return { e: e };\n    }\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction safeGet(cb, defValue) {\n    var result = safe(cb);\n    return result.e ? defValue : result.v;\n}\n\nvar _primitiveTypes;\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createIs(theType) {\n    return function (value) {\n        return typeof value === theType;\n    };\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createObjIs(theName) {\n    var theType = \"[object \" + theName + \"]\";\n    return function (value) {\n        return !!(value && objToString(value) === theType);\n    };\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction objToString(value) {\n    return ObjProto[TO_STRING].call(value);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction isTypeof(value, theType) {\n    return typeof value === theType;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction isUndefined(value) {\n    return typeof value === UNDEFINED || value === UNDEFINED;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction isStrictUndefined(arg) {\n    return !isDefined(arg);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction isNullOrUndefined(value) {\n    return value === NULL_VALUE || isUndefined(value);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction isStrictNullOrUndefined(value) {\n    return value === NULL_VALUE || !isDefined(value);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction isDefined(arg) {\n    return !!arg || arg !== UNDEF_VALUE;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction isPrimitive(value) {\n    return value === NULL_VALUE || isPrimitiveType(typeof value);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction isPrimitiveType(theType) {\n    !_primitiveTypes && (_primitiveTypes = [\"string\", \"number\", \"boolean\", UNDEFINED, \"symbol\", \"bigint\"]);\n    return !!(theType !== OBJECT && _primitiveTypes.indexOf(theType) !== -1);\n}\nvar isString = ( /*#__PURE__*/_createIs(\"string\"));\nvar isFunction = ( /*#__PURE__*/_createIs(FUNCTION));\n/*#__NO_SIDE_EFFECTS__*/\nfunction isObject(value) {\n    if (!value && isNullOrUndefined(value)) {\n        return false;\n    }\n    return !!value && typeof value === OBJECT;\n}\nvar isArray = ( /* #__PURE__*/_pureRef(ArrCls, \"isArray\"));\nvar isDate = ( /*#__PURE__*/_createObjIs(\"Date\"));\nvar isNumber = ( /*#__PURE__*/_createIs(\"number\"));\nvar isBoolean = ( /*#__PURE__*/_createIs(\"boolean\"));\nvar isRegExp = ( /*#__PURE__*/_createObjIs(\"RegExp\"));\nvar isFile = ( /*#__PURE__*/_createObjIs(\"File\"));\nvar isFormData = ( /*#__PURE__*/_createObjIs(\"FormData\"));\nvar isBlob = ( /*#__PURE__*/_createObjIs(\"Blob\"));\nvar isArrayBuffer = ( /*#__PURE__*/_createObjIs(\"ArrayBuffer\"));\nvar isError = ( /*#__PURE__*/_createObjIs(\"Error\"));\n/*#__NO_SIDE_EFFECTS__*/\nfunction isPromiseLike(value) {\n    return !!(value && value.then && isFunction(value.then));\n}\nvar isThenable = isPromiseLike;\n/*#__NO_SIDE_EFFECTS__*/\nfunction isPromise(value) {\n    return !!(value && value.then && value.catch && isFunction(value.then) && isFunction(value.catch));\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction isNotTruthy(value) {\n    return !value || !isTruthy(value);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction isTruthy(value) {\n    return !(!value || safeGet(function () { return !(value && (0 + value)); }, !value));\n}\n\nvar objGetOwnPropertyDescriptor = ( /* #__PURE__ */_pureRef(ObjClass, \"getOwnPropertyDescriptor\"));\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction objHasOwnProperty(obj, prop) {\n    return !!obj && ObjProto.hasOwnProperty[CALL](obj, prop);\n}\n\nvar objHasOwn = ( /*#__PURE__*/_pureAssign(( /* #__PURE__ */_pureRef(ObjClass, \"hasOwn\")), polyObjHasOwn));\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyObjHasOwn(obj, prop) {\n    return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);\n}\n\nfunction objForEachKey(theObject, callbackfn, thisArg) {\n    if (theObject && isObject(theObject)) {\n        for (var prop in theObject) {\n            if (objHasOwn(theObject, prop)) {\n                if (callbackfn[CALL](thisArg || theObject, prop, theObject[prop]) === -1) {\n                    break;\n                }\n            }\n        }\n    }\n}\n\nvar propMap = {\n    e: \"enumerable\",\n    c: \"configurable\",\n    v: \"value\",\n    w: \"writable\",\n    g: \"get\",\n    s: \"set\"\n};\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createProp(value) {\n    var prop = {};\n    prop[propMap[\"c\"]] = true;\n    prop[propMap[\"e\"]] = true;\n    if (value.l) {\n        prop.get = function () { return value.l.v; };\n        var desc = objGetOwnPropertyDescriptor(value.l, \"v\");\n        if (desc && desc.set) {\n            prop.set = function (newValue) {\n                value.l.v = newValue;\n            };\n        }\n    }\n    objForEachKey(value, function (key, value) {\n        prop[propMap[key]] = isStrictUndefined(value) ? prop[propMap[key]] : value;\n    });\n    return prop;\n}\nvar objDefineProp = ( /*#__PURE__*/_pureRef(ObjClass, \"defineProperty\"));\nvar objDefineProperties = ( /*#__PURE__*/_pureRef(ObjClass, \"defineProperties\"));\nfunction objDefineGet(target, key, value, configurable, enumerable) {\n    var _a;\n    return objDefineProp(target, key, _createProp((_a = {\n            e: enumerable,\n            c: configurable\n        },\n        _a[isFunction(value) ? \"g\" : \"v\"] = value,\n        _a)));\n}\nfunction objDefineAccessors(target, prop, getProp, setProp, configurable, enumerable) {\n    var desc = {\n        e: enumerable,\n        c: configurable\n    };\n    if (getProp) {\n        desc.g = getProp;\n    }\n    if (setProp) {\n        desc.s = setProp;\n    }\n    return objDefineProp(target, prop, _createProp(desc));\n}\nfunction objDefine(target, key, propDesc) {\n    return objDefineProp(target, key, _createProp(propDesc));\n}\nfunction objDefineProps(target, propDescMap) {\n    var props = {};\n    objForEachKey(propDescMap, function (key, value) {\n        props[key] = _createProp(value);\n    });\n    return objDefineProperties(target, props);\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createKeyValueMap(values, keyType, valueType, completeFn, writable) {\n    var theMap = {};\n    objForEachKey(values, function (key, value) {\n        _assignMapValue(theMap, key, keyType ? value : key, writable);\n        _assignMapValue(theMap, value, valueType ? value : key, writable);\n    });\n    return completeFn ? completeFn(theMap) : theMap;\n}\nfunction _assignMapValue(theMap, key, value, writable) {\n    objDefineProp(theMap, key, {\n        value: value,\n        enumerable: true,\n        writable: !!writable\n    });\n}\n\nvar asString = ( /* #__PURE__ */_pureAssign(StrCls));\n\nvar ERROR_TYPE = \"[object Error]\";\n/*#__NO_SIDE_EFFECTS__*/\nfunction dumpObj(object, format) {\n    var propertyValueDump = EMPTY;\n    var objType = ObjProto[TO_STRING][CALL](object);\n    if (objType === ERROR_TYPE) {\n        object = { stack: asString(object.stack), message: asString(object.message), name: asString(object.name) };\n    }\n    try {\n        propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? ((typeof format === \"number\") ? format : 4) : UNDEF_VALUE);\n        propertyValueDump = (propertyValueDump ? propertyValueDump.replace(/\"(\\w+)\"\\s*:\\s{0,1}/g, \"$1: \") : NULL_VALUE) || asString(object);\n    }\n    catch (e) {\n        propertyValueDump = \" - \" + dumpObj(e, format);\n    }\n    return objType + \": \" + propertyValueDump;\n}\n\nfunction throwError(message) {\n    throw new Error(message);\n}\nfunction throwTypeError(message) {\n    throw new TypeError(message);\n}\nfunction throwRangeError(message) {\n    throw new RangeError(message);\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyObjKeys(obj) {\n    if (!isObject(obj) || obj === NULL_VALUE) {\n        throwTypeError(\"non-object \" + dumpObj(obj));\n    }\n    var result = [];\n    for (var prop in obj) {\n        if (objHasOwn(obj, prop)) {\n            result.push(prop);\n        }\n    }\n    return result;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyObjEntries(value) {\n    var result = [];\n    objForEachKey(value, function (key, value) {\n        result.push([key, value]);\n    });\n    return result;\n}\n\nvar _objFreeze = ( /* #__PURE__ */_pureRef(ObjClass, \"freeze\"));\nfunction _doNothing(value) {\n    return value;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _getProto(value) {\n    return value[__PROTO__] || NULL_VALUE;\n}\nvar objAssign = ( /*#__PURE__*/_pureRef(ObjClass, \"assign\"));\nvar objKeys = ( /*#__PURE__*/_pureRef(ObjClass, \"keys\"));\nfunction objDeepFreeze(value) {\n    if (_objFreeze) {\n        objForEachKey(value, function (key, value) {\n            if (isArray(value) || isObject(value)) {\n                objDeepFreeze(value);\n            }\n        });\n    }\n    return objFreeze(value);\n}\nvar objFreeze = ( /* #__PURE__*/_pureAssign(_objFreeze, _doNothing));\nvar objSeal = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ObjClass, \"seal\")), _doNothing));\nvar objGetPrototypeOf = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ObjClass, \"getPrototypeOf\")), _getProto));\nvar objEntries = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ObjClass, \"entries\")), polyObjEntries));\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction createEnum(values) {\n    return _createKeyValueMap(values, 1 , 0 , objFreeze);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction createEnumKeyMap(values) {\n    return _createKeyValueMap(values, 0 , 0 , objFreeze);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction createEnumValueMap(values) {\n    return _createKeyValueMap(values, 1 , 1 , objFreeze);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction createSimpleMap(values) {\n    var mapClass = {};\n    objForEachKey(values, function (key, value) {\n        _assignMapValue(mapClass, key, value[1]);\n        _assignMapValue(mapClass, value[0], value[1]);\n    });\n    return objFreeze(mapClass);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction createTypeMap(values) {\n    return createSimpleMap(values);\n}\n\nvar _wellKnownSymbolMap = /*#__PURE__*/ createEnumKeyMap({\n    asyncIterator: 0 ,\n    hasInstance: 1 ,\n    isConcatSpreadable: 2 ,\n    iterator: 3 ,\n    match: 4 ,\n    matchAll: 5 ,\n    replace: 6 ,\n    search: 7 ,\n    species: 8 ,\n    split: 9 ,\n    toPrimitive: 10 ,\n    toStringTag: 11 ,\n    unscopables: 12\n});\n\nvar GLOBAL_CONFIG_KEY = \"__tsUtils$gblCfg\";\nvar _globalCfg;\n/*#__NO_SIDE_EFFECTS__*/\nfunction _getGlobalValue() {\n    var result;\n    if (typeof globalThis !== UNDEFINED) {\n        result = globalThis;\n    }\n    if (!result && typeof self !== UNDEFINED) {\n        result = self;\n    }\n    if (!result && typeof window !== UNDEFINED) {\n        result = window;\n    }\n    if (!result && typeof global !== UNDEFINED) {\n        result = global;\n    }\n    return result;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _getGlobalConfig() {\n    if (!_globalCfg) {\n        var gbl = safe(_getGlobalValue).v || {};\n        _globalCfg = gbl[GLOBAL_CONFIG_KEY] = gbl[GLOBAL_CONFIG_KEY] || {};\n    }\n    return _globalCfg;\n}\n\nvar _unwrapFunction = ( _unwrapFunctionWithPoly);\n/*#__NO_SIDE_EFFECTS__*/\nfunction _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {\n    var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;\n    return function (thisArg) {\n        var theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || clsFn;\n        if (theFunc || polyFunc) {\n            var theArgs = arguments;\n            return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);\n        }\n        throwTypeError(\"\\\"\" + asString(funcName) + \"\\\" not defined for \" + dumpObj(thisArg));\n    };\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _unwrapProp(propName) {\n    return function (thisArg) {\n        return thisArg[propName];\n    };\n}\n\nvar mathMin = ( /*#__PURE__*/_pureRef(MathCls, \"min\"));\nvar mathMax = ( /*#__PURE__*/_pureRef(MathCls, \"max\"));\n\nvar strSlice = ( /*#__PURE__*/_unwrapFunction(\"slice\", StrProto));\n\nvar strSubstring = ( /*#__PURE__*/_unwrapFunction(\"substring\", StrProto));\nvar strSubstr = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"substr\", StrProto, polyStrSubstr));\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyStrSubstr(value, start, length) {\n    if (isNullOrUndefined(value)) {\n        throwTypeError(\"Invalid \" + dumpObj(value));\n    }\n    if (length < 0) {\n        return EMPTY;\n    }\n    start = start || 0;\n    if (start < 0) {\n        start = mathMax(start + value[LENGTH], 0);\n    }\n    if (isUndefined(length)) {\n        return strSlice(value, start);\n    }\n    return strSlice(value, start, start + length);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction strLeft(value, count) {\n    return strSubstring(value, 0, count);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction strRight(value, count) {\n    return count <= 0 ? EMPTY : (value[LENGTH] > count ? strSlice(value, -count) : value);\n}\n\nvar UNIQUE_REGISTRY_ID = \"_urid\";\nvar _polySymbols;\n/*#__NO_SIDE_EFFECTS__*/\nfunction _globalSymbolRegistry() {\n    if (!_polySymbols) {\n        var gblCfg = _getGlobalConfig();\n        _polySymbols = gblCfg.gblSym = gblCfg.gblSym || { k: {}, s: {} };\n    }\n    return _polySymbols;\n}\nvar _wellKnownSymbolCache;\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyNewSymbol(description) {\n    var theSymbol = {\n        description: asString(description),\n        toString: function () { return SYMBOL + \"(\" + description + \")\"; }\n    };\n    theSymbol[POLYFILL_TAG] = true;\n    return theSymbol;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction polySymbolFor(key) {\n    var registry = _globalSymbolRegistry();\n    if (!objHasOwn(registry.k, key)) {\n        var newSymbol_1 = polyNewSymbol(key);\n        var regId_1 = objKeys(registry.s).length;\n        newSymbol_1[UNIQUE_REGISTRY_ID] = function () { return regId_1 + \"_\" + newSymbol_1[TO_STRING](); };\n        registry.k[key] = newSymbol_1;\n        registry.s[newSymbol_1[UNIQUE_REGISTRY_ID]()] = asString(key);\n    }\n    return registry.k[key];\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction polySymbolKeyFor(sym) {\n    if (!sym || !sym[TO_STRING] || strSubstring(sym[TO_STRING](), 0, 6) != SYMBOL) {\n        throwTypeError(sym + \" is not a symbol\");\n    }\n    var regId = sym[POLYFILL_TAG] && sym[UNIQUE_REGISTRY_ID] && sym[UNIQUE_REGISTRY_ID]();\n    return regId ? _globalSymbolRegistry().s[regId] : undefined;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyGetKnownSymbol(name) {\n    !_wellKnownSymbolCache && (_wellKnownSymbolCache = {});\n    var result;\n    var knownName = _wellKnownSymbolMap[name];\n    if (knownName) {\n        result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + \".\" + knownName);\n    }\n    return result;\n}\n\nvar _globalLazyTestHooks;\nfunction _initTestHooks() {\n    _globalLazyTestHooks = _getGlobalConfig();\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction getLazy(cb) {\n    var lazyValue = {};\n    !_globalLazyTestHooks && _initTestHooks();\n    lazyValue.b = _globalLazyTestHooks.lzy;\n    objDefineProp(lazyValue, \"v\", {\n        configurable: true,\n        get: function () {\n            var result = cb();\n            if (!_globalLazyTestHooks.lzy) {\n                objDefineProp(lazyValue, \"v\", {\n                    value: result\n                });\n            }\n            lazyValue.b = _globalLazyTestHooks.lzy;\n            return result;\n        }\n    });\n    return lazyValue;\n}\nfunction setBypassLazyCache(newValue) {\n    !_globalLazyTestHooks && _initTestHooks();\n    _globalLazyTestHooks.lzy = newValue;\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction createCachedValue(value) {\n    return objDefineProp({\n        toJSON: function () { return value; }\n    }, \"v\", { value: value });\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction createDeferredCachedValue(cb) {\n    var theValue = {\n        toJSON: function () { return theValue.v; }\n    };\n    return objDefineProp(theValue, \"v\", {\n        get: function () {\n            var result = cb();\n            cb = NULL_VALUE;\n            objDefineProp(theValue, \"v\", { value: result });\n            return result;\n        },\n        configurable: true\n    });\n}\n\nvar WINDOW = \"window\";\nvar _cachedGlobal;\nfunction _getGlobalInstFn(getFn, theArgs) {\n    var cachedValue;\n    return function () {\n        !_globalLazyTestHooks && _initTestHooks();\n        if (!cachedValue || _globalLazyTestHooks.lzy) {\n            cachedValue = createCachedValue(safe(getFn, theArgs).v);\n        }\n        return cachedValue.v;\n    };\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction lazySafeGetInst(name) {\n    return getLazy(function () { return safe((getInst), [name]).v || UNDEF_VALUE; });\n}\nfunction getGlobal(useCached) {\n    !_globalLazyTestHooks && _initTestHooks();\n    if (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) {\n        _cachedGlobal = createCachedValue(safe(_getGlobalValue).v || NULL_VALUE);\n    }\n    return _cachedGlobal.v;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction getInst(name, useCached) {\n    var gbl;\n    if (!_cachedGlobal || useCached === false) {\n        gbl = getGlobal(useCached);\n    }\n    else {\n        gbl = _cachedGlobal.v;\n    }\n    if (gbl && gbl[name]) {\n        return gbl[name];\n    }\n    if (name === WINDOW) {\n        try {\n            return window;\n        }\n        catch (e) {\n        }\n    }\n    return NULL_VALUE;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction hasDocument() {\n    return !!( /*#__PURE__*/getDocument());\n}\nvar getDocument = ( /*#__PURE__*/_getGlobalInstFn(getInst, [\"document\"]));\n/*#__NO_SIDE_EFFECTS__*/\nfunction hasWindow() {\n    return !!( /*#__PURE__*/getWindow());\n}\nvar getWindow = ( /*#__PURE__*/_getGlobalInstFn(getInst, [WINDOW]));\n/*#__NO_SIDE_EFFECTS__*/\nfunction hasNavigator() {\n    return !!( /*#__PURE__*/getNavigator());\n}\nvar getNavigator = ( /*#__PURE__*/_getGlobalInstFn(getInst, [\"navigator\"]));\n/*#__NO_SIDE_EFFECTS__*/\nfunction hasHistory() {\n    return !!( /*#__PURE__*/getHistory());\n}\nvar getHistory = ( /*#__PURE__*/_getGlobalInstFn(getInst, [\"history\"]));\nvar isNode = ( /*#__PURE__*/_getGlobalInstFn(function () {\n    return !!( /*#__PURE__*/safe(function () { return (process && (process.versions || {}).node); }).v);\n}));\nvar isWebWorker = ( /*#__PURE__*/_getGlobalInstFn(function () {\n    return !!( /*#__PURE__*/safe(function () { return self && self instanceof WorkerGlobalScope; }).v);\n}));\n\nvar _symbol;\nvar _symbolFor;\nvar _symbolKeyFor;\n/*#__NO_SIDE_EFFECTS__*/\nfunction _initSymbol() {\n    _symbol = ( /*#__PURE__*/createCachedValue(safe((getInst), [SYMBOL]).v));\n    return _symbol;\n}\nfunction _getSymbolKey(key) {\n    var gblSym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());\n    return (gblSym.v ? gblSym.v[key] : UNDEF_VALUE);\n}\nvar isSymbol = ( /*#__PURE__*/_createIs(\"symbol\"));\n/*#__NO_SIDE_EFFECTS__*/\nfunction hasSymbol() {\n    return !!( /*#__PURE__*/getSymbol());\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction getSymbol() {\n    !_globalLazyTestHooks && _initTestHooks();\n    return ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol()).v;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction getKnownSymbol(name, noPoly) {\n    var knownName = _wellKnownSymbolMap[name];\n    !_globalLazyTestHooks && _initTestHooks();\n    var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());\n    return sym.v ? sym.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction newSymbol(description, noPoly) {\n    !_globalLazyTestHooks && _initTestHooks();\n    var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());\n    return sym.v ? sym.v(description) : (!noPoly ? polyNewSymbol(description) : NULL_VALUE);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction symbolFor(key) {\n    !_globalLazyTestHooks && _initTestHooks();\n    _symbolFor = ((!_globalLazyTestHooks.lzy ? _symbolFor : 0) || ( /*#__PURE__*/createCachedValue(safe((_getSymbolKey), [\"for\"]).v)));\n    return (_symbolFor.v || polySymbolFor)(key);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction symbolKeyFor(sym) {\n    !_globalLazyTestHooks && _initTestHooks();\n    _symbolKeyFor = ((!_globalLazyTestHooks.lzy ? _symbolKeyFor : 0) || ( /*#__PURE__*/createCachedValue(safe((_getSymbolKey), [\"keyFor\"]).v)));\n    return (_symbolKeyFor.v || polySymbolKeyFor)(sym);\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction isIterator(value) {\n    return !!value && isFunction(value.next);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction isIterable(value) {\n    return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);\n}\n\nvar _iterSymbol$1;\nfunction iterForOf(iter, callbackfn, thisArg) {\n    if (iter) {\n        if (!isIterator(iter)) {\n            !_iterSymbol$1 && (_iterSymbol$1 = createCachedValue(getKnownSymbol(3 )));\n            iter = iter[_iterSymbol$1.v] ? iter[_iterSymbol$1.v]() : NULL_VALUE;\n        }\n        if (isIterator(iter)) {\n            var err = UNDEF_VALUE;\n            var iterResult = UNDEF_VALUE;\n            try {\n                var count = 0;\n                while (!(iterResult = iter.next()).done) {\n                    if (callbackfn[CALL](thisArg || iter, iterResult.value, count, iter) === -1) {\n                        break;\n                    }\n                    count++;\n                }\n            }\n            catch (failed) {\n                err = { e: failed };\n                if (iter.throw) {\n                    iterResult = NULL_VALUE;\n                    iter.throw(err);\n                }\n            }\n            finally {\n                try {\n                    if (iterResult && !iterResult.done) {\n                        iter.return && iter.return(iterResult);\n                    }\n                }\n                finally {\n                    if (err) {\n                        // eslint-disable-next-line no-unsafe-finally\n                        throw err.e;\n                    }\n                }\n            }\n        }\n    }\n}\n\nfunction fnApply(fn, thisArg, argArray) {\n    return fn.apply(thisArg, argArray);\n}\nfunction fnCall(fn, thisArg) {\n    return fn.apply(thisArg, ArrSlice[CALL](arguments, 2));\n}\nfunction fnBind(fn, thisArg) {\n    return fn.bind.apply(fn, ArrSlice[CALL](arguments, 1));\n}\n\nfunction arrAppend(target, elms) {\n    if (!isUndefined(elms) && target) {\n        if (isArray(elms)) {\n            fnApply(target.push, target, elms);\n        }\n        else if (isIterator(elms) || isIterable(elms)) {\n            iterForOf(elms, function (elm) {\n                target.push(elm);\n            });\n        }\n        else {\n            target.push(elms);\n        }\n    }\n    return target;\n}\n\nvar arrEvery = /*#__PURE__*/ _unwrapFunction(\"every\", ArrProto);\nvar arrFilter = /*#__PURE__*/ _unwrapFunction(\"filter\", ArrProto);\n\nfunction arrForEach(theArray, callbackfn, thisArg) {\n    if (theArray) {\n        var len = theArray[LENGTH] >>> 0;\n        for (var idx = 0; idx < len; idx++) {\n            if (idx in theArray) {\n                if (callbackfn[CALL](thisArg || theArray, theArray[idx], idx, theArray) === -1) {\n                    break;\n                }\n            }\n        }\n    }\n}\n\nvar arrIndexOf = ( /*#__PURE__*/_unwrapFunction(\"indexOf\", ArrProto));\nvar arrLastIndexOf = ( /*#__PURE__*/_unwrapFunction(\"lastIndexOf\", ArrProto));\n\nvar arrMap = ( /*#__PURE__*/_unwrapFunction(\"map\", ArrProto));\n\nfunction arrSlice(theArray, start, end) {\n    return ((theArray ? theArray[\"slice\"] : NULL_VALUE) || ArrSlice).apply(theArray, ArrSlice[CALL](arguments, 1));\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyIsArray(value) {\n    if (isNullOrUndefined(value)) {\n        return false;\n    }\n    return objToString(value) === \"[object Array]\";\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyArrIncludes(theArray, searchElement, fromIndex) {\n    return arrIndexOf(theArray, searchElement, fromIndex) !== -1;\n}\nfunction polyArrFind(theArray, callbackFn, thisArg) {\n    var result;\n    var idx = polyArrFindIndex(theArray, callbackFn, thisArg);\n    return idx !== -1 ? theArray[idx] : result;\n}\nfunction polyArrFindIndex(theArray, callbackFn, thisArg) {\n    var result = -1;\n    arrForEach(theArray, function (value, index) {\n        if (callbackFn[CALL](thisArg | theArray, value, index, theArray)) {\n            result = index;\n            return -1;\n        }\n    });\n    return result;\n}\nfunction polyArrFindLast(theArray, callbackFn, thisArg) {\n    var result;\n    var idx = polyArrFindLastIndex(theArray, callbackFn, thisArg);\n    return idx !== -1 ? theArray[idx] : result;\n}\nfunction polyArrFindLastIndex(theArray, callbackFn, thisArg) {\n    var result = -1;\n    var len = theArray[LENGTH] >>> 0;\n    for (var idx = len - 1; idx >= 0; idx--) {\n        if (idx in theArray && callbackFn[CALL](thisArg | theArray, theArray[idx], idx, theArray)) {\n            result = idx;\n            break;\n        }\n    }\n    return result;\n}\nfunction polyArrFrom(theValue, mapFn, thisArg) {\n    if (isArray(theValue)) {\n        var result_1 = arrSlice(theValue);\n        return mapFn ? arrMap(result_1, mapFn, thisArg) : result_1;\n    }\n    var result = [];\n    iterForOf(theValue, function (value, cnt) {\n        return result.push(mapFn ? mapFn[CALL](thisArg, value, cnt) : value);\n    });\n    return result;\n}\n\nvar arrFind = /*#__PURE__*/ _unwrapFunctionWithPoly(\"find\", ArrProto, polyArrFind);\nvar arrFindIndex = /*#__PURE__*/ _unwrapFunctionWithPoly(\"findIndex\", ArrProto, polyArrFindIndex);\nvar arrFindLast = /*#__PURE__*/ _unwrapFunctionWithPoly(\"findLast\", ArrProto, polyArrFindLast);\nvar arrFindLastIndex = /*#__PURE__*/ _unwrapFunctionWithPoly(\"findLastIndex\", ArrProto, polyArrFindLastIndex);\n\nvar arrFrom = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ArrCls, \"from\")), polyArrFrom));\n\nvar arrIncludes = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"includes\", ArrProto, polyArrIncludes));\nvar arrContains = arrIncludes;\n\nvar arrReduce = ( /*#__PURE__*/_unwrapFunction(\"reduce\", ArrProto));\n\nvar arrSome = ( /*#__PURE__*/_unwrapFunction(\"some\", ArrProto));\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction createFnDeferredProxy(hostFn, funcName) {\n    return function () {\n        var theArgs = ArrSlice[CALL](arguments);\n        var theHost = hostFn();\n        return fnApply(theHost[funcName], theHost, theArgs);\n    };\n}\nfunction createProxyFuncs(target, host, funcDefs) {\n    if (target && host && isArray(funcDefs)) {\n        var isDeferred_1 = isFunction(host);\n        arrForEach(funcDefs, function (funcDef) {\n            var targetName = (funcDef.as || funcDef.n);\n            if (funcDef.rp === false && target[targetName]) {\n                return;\n            }\n            target[targetName] = isDeferred_1 ?\n                createFnDeferredProxy(host, funcDef.n) :\n                fnBind(host[funcDef.n], host);\n        });\n    }\n    return target;\n}\n\nvar _iterSymbol;\n/*#__NO_SIDE_EFFECTS__*/\nfunction readArgs(theArgs, start, end) {\n    if (!objHasOwn(theArgs, LENGTH)) {\n        !_iterSymbol && (_iterSymbol = createCachedValue(hasSymbol() && getKnownSymbol(3 )));\n        var iterFn = void 0;\n        if (_iterSymbol.v) {\n            iterFn = theArgs[_iterSymbol.v];\n        }\n        if (iterFn) {\n            var values_1 = [];\n            var from_1 = (start === UNDEF_VALUE || start < 0) ? 0 : start;\n            var to_1 = end < 0 || start < 0 ? UNDEF_VALUE : end;\n            iterForOf(iterFn[CALL](theArgs), function (value, cnt) {\n                if (to_1 !== UNDEF_VALUE && cnt >= to_1) {\n                    return -1;\n                }\n                if (cnt >= from_1) {\n                    values_1.push(value);\n                }\n            });\n            if ((start === UNDEF_VALUE || start >= 0) && (end === UNDEF_VALUE || end >= 0)) {\n                return values_1;\n            }\n            theArgs = values_1;\n        }\n    }\n    return arrSlice(theArgs, start, end);\n}\n\nvar objCreate = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(ObjClass, \"create\")), polyObjCreate));\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyObjCreate(obj) {\n    if (!obj) {\n        return {};\n    }\n    var type = typeof obj;\n    if (type !== OBJECT && type !== FUNCTION) {\n        throwTypeError(\"Prototype must be an Object or function: \" + dumpObj(obj));\n    }\n    function tempFunc() { }\n    tempFunc[PROTOTYPE] = obj;\n    return new tempFunc();\n}\n\nvar _isProtoArray;\nfunction objSetPrototypeOf(obj, proto) {\n    var fn = ObjClass[\"setPrototypeOf\"] ||\n        function (d, b) {\n            var _a;\n            !_isProtoArray && (_isProtoArray = createCachedValue((_a = {}, _a[__PROTO__] = [], _a) instanceof Array));\n            _isProtoArray.v ? d[__PROTO__] = b : objForEachKey(b, function (key, value) { return d[key] = value; });\n        };\n    return fn(obj, proto);\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createCustomError(name, d, b) {\n    safe(objDefine, [d, NAME, { v: name, c: true, e: false }]);\n    d = objSetPrototypeOf(d, b);\n    function __() {\n        this[CONSTRUCTOR] = d;\n        safe(objDefine, [this, NAME, { v: name, c: true, e: false }]);\n    }\n    d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());\n    return d;\n}\nfunction _setName(baseClass, name) {\n    name && (baseClass[NAME] = name);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction createCustomError(name, constructCb, errorBase) {\n    var theBaseClass = errorBase || Error;\n    var orgName = theBaseClass[PROTOTYPE][NAME];\n    var captureFn = Error.captureStackTrace;\n    return _createCustomError(name, function () {\n        var _this = this;\n        var theArgs = arguments;\n        try {\n            safe(_setName, [theBaseClass, name]);\n            var _self = fnApply(theBaseClass, _this, ArrSlice[CALL](theArgs)) || _this;\n            if (_self !== _this) {\n                var orgProto = objGetPrototypeOf(_this);\n                if (orgProto !== objGetPrototypeOf(_self)) {\n                    objSetPrototypeOf(_self, orgProto);\n                }\n            }\n            captureFn && captureFn(_self, _this[CONSTRUCTOR]);\n            constructCb && constructCb(_self, theArgs);\n            return _self;\n        }\n        finally {\n            safe(_setName, [theBaseClass, orgName]);\n        }\n    }, theBaseClass);\n}\nvar _unsupportedError;\nfunction throwUnsupported(message) {\n    if (!_unsupportedError) {\n        _unsupportedError = createCustomError(\"UnsupportedError\");\n    }\n    throw new _unsupportedError(message);\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction utcNow() {\n    return (Date.now || polyUtcNow)();\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyUtcNow() {\n    return new Date().getTime();\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createTrimFn(exp) {\n    return function _doTrim(value) {\n        if (isNullOrUndefined(value)) {\n            throwTypeError(\"strTrim called [\" + dumpObj(value) + \"]\");\n        }\n        if (value && value.replace) {\n            value = value.replace(exp, EMPTY);\n        }\n        return value;\n    };\n}\nvar polyStrTrim = ( /*#__PURE__*/_createTrimFn(/^\\s+|(?=\\s)\\s+$/g));\nvar polyStrTrimStart = ( /*#__PURE__*/_createTrimFn(/^\\s+/g));\nvar polyStrTrimEnd = ( /*#__PURE__*/_createTrimFn(/(?=\\s)\\s+$/g));\n\nvar strTrim = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"trim\", StrProto, polyStrTrim));\nvar strTrimStart = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"trimStart\", StrProto, polyStrTrimStart));\nvar strTrimLeft = ( /*#__PURE__*/_pureAssign(strTrimStart));\nvar strTrimEnd = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"trimEnd\", StrProto, polyStrTrimEnd));\nvar strTrimRight = ( /*#__PURE__*/_pureAssign(strTrimEnd));\n\nvar strUpper = ( /*#__PURE__*/_unwrapFunction(\"toUpperCase\", StrProto));\nvar strLower = ( /*#__PURE__*/_unwrapFunction(\"toLowerCase\", StrProto));\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction _convertCase(value, newPrefix, upperWord) {\n    return strTrim(asString(value)).replace(/((_|\\W)+(\\w){0,1}|([a-z])([A-Z]))/g, function (_match, _g1, _g2, wordStart, upperPrefix, upperLetter) {\n        var convertMatch = wordStart || upperLetter || EMPTY;\n        if (upperWord) {\n            convertMatch = strUpper(convertMatch);\n        }\n        return (upperPrefix || EMPTY) + newPrefix + convertMatch;\n    });\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction strLetterCase(value) {\n    return asString(value).replace(/(_|\\b)\\w/g, strUpper);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction strCamelCase(value, upperFirst) {\n    var result = _convertCase(value, \"\", true);\n    return result.replace(/^\\w/, upperFirst ? strUpper : strLower);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction strKebabCase(value, scream) {\n    var result = _convertCase(value, \"-\");\n    return (scream ? strUpper : strLower)(result);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction strSnakeCase(value, scream) {\n    var result = _convertCase(value, \"_\");\n    return (scream ? strUpper : strLower)(result);\n}\n\nvar mathFloor = ( /*#__PURE__*/_pureRef(MathCls, \"floor\"));\nvar mathCeil = ( /*#__PURE__*/_pureRef(MathCls, \"ceil\"));\n\nvar mathTrunc = ( /* #__PURE__*/_pureAssign(( /* #__PURE__*/_pureRef(MathCls, \"trunc\")), polyMathTrunc));\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyMathTrunc(value) {\n    var theValue = +value;\n    return (theValue > 0 ? mathFloor : mathCeil)(theValue);\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction mathToInt(value, throwInfinity) {\n    var result = +value;\n    if (result == Infinity && throwInfinity) {\n        throwRangeError(\"invalid value [\" + dumpObj(value) + \"]\");\n    }\n    return result !== result || result === 0 ? 0 : mathTrunc(result);\n}\n\nvar strRepeat = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"repeat\", StrProto, polyStrRepeat));\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyStrRepeat(value, count) {\n    if (isNullOrUndefined(value)) {\n        throwTypeError(\"can't convert [\" + dumpObj(value) + \"]\");\n    }\n    count = mathToInt(count, true);\n    if (count < 0) {\n        throwRangeError(\"invalid count must be >= 0 && < Infinity\");\n    }\n    var pad = isString(value) ? value : asString(value);\n    var result = EMPTY;\n    for (; count > 0; (count >>>= 1) && (pad += pad)) {\n        if (count & 1) {\n            result += pad;\n        }\n    }\n    return result;\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction _padValue(value, targetLength, padString) {\n    var result = EMPTY;\n    targetLength = mathToInt(targetLength, true);\n    targetLength >>= 0;\n    var len = value[LENGTH];\n    if (len < targetLength) {\n        result = isNullOrUndefined(padString) ? \" \" : asString(padString);\n        targetLength = targetLength - len;\n        if (targetLength > result[LENGTH]) {\n            result = strRepeat(result, mathCeil(targetLength / result[LENGTH]));\n        }\n        if (result[LENGTH] > targetLength) {\n            result = strSubstring(result, 0, targetLength);\n        }\n    }\n    return result;\n}\nvar strPadStart = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"padStart\", StrProto, polyStrPadStart));\nvar strPadEnd = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"padEnd\", StrProto, polyStrPadEnd));\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyStrPadStart(value, targetLength, padString) {\n    return _padValue(value, targetLength, padString) + value;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyStrPadEnd(value, targetLength, padString) {\n    return value + _padValue(value, targetLength, padString);\n}\n\nvar DBL_QUOTE = \"\\\"\";\nvar INVALID_JS_NAME = /([^\\w\\d_$])/g;\nvar _htmlEntityCache;\n/*#__NO_SIDE_EFFECTS__*/\nfunction normalizeJsName(jsName, camelCase) {\n    var result = asString(jsName).replace(INVALID_JS_NAME, \"_\");\n    return !isUndefined(camelCase) ? strCamelCase(result, !camelCase) : result;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction encodeAsJson(value, format) {\n    var result;\n    if (isString(value)) {\n        result = DBL_QUOTE + value.replace(/[^\\w .,\\-!@#$%\\^&*\\(\\)_+={}\\[\\]:;|<>?]/g, function (match) {\n            if (match === DBL_QUOTE || match === \"\\\\\") {\n                return \"\\\\\" + match;\n            }\n            var hex = match.charCodeAt(0)[TO_STRING](16);\n            return \"\\\\u\" + strPadStart(strUpper(hex), 4, \"0\");\n        }) + DBL_QUOTE;\n    }\n    else {\n        try {\n            result = JSON.stringify(value, NULL_VALUE, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);\n        }\n        catch (e) {\n            result = DBL_QUOTE + dumpObj(e) + DBL_QUOTE;\n        }\n    }\n    return result;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction encodeAsHtml(value) {\n    !_htmlEntityCache && (_htmlEntityCache = {\n        \"&\": \"amp\",\n        \"<\": \"lt\",\n        \">\": \"gt\",\n        \"\\\"\": \"quot\",\n        \"'\": \"#39\"\n    });\n    return asString(value).replace(/[&<>\"']/g, function (match) { return \"&\" + _htmlEntityCache[match] + \";\"; });\n}\n\nvar _fnToString;\nvar _objCtrFnString;\nvar _gblWindow;\n/*#__NO_SIDE_EFFECTS__*/\nfunction isPlainObject(value) {\n    if (!value || typeof value !== OBJECT) {\n        return false;\n    }\n    if (!_gblWindow) {\n        _gblWindow = hasWindow() ? getWindow() : true;\n    }\n    var result = false;\n    if (value !== _gblWindow) {\n        if (!_objCtrFnString) {\n            _fnToString = Function[PROTOTYPE][TO_STRING];\n            _objCtrFnString = _fnToString[CALL](ObjClass);\n        }\n        try {\n            var proto = objGetPrototypeOf(value);\n            result = !proto;\n            if (!result) {\n                if (objHasOwnProperty(proto, CONSTRUCTOR)) {\n                    proto = proto[CONSTRUCTOR];\n                }\n                result = !!(proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString);\n            }\n        }\n        catch (ex) {\n        }\n    }\n    return result;\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction _defaultDeepCopyHandler(details) {\n    details.value && plainObjDeepCopyHandler(details);\n    return true;\n}\nvar defaultDeepCopyHandlers = [\n    arrayDeepCopyHandler,\n    plainObjDeepCopyHandler,\n    functionDeepCopyHandler,\n    dateDeepCopyHandler\n];\n/*#__NO_SIDE_EFFECTS__*/\nfunction _getSetVisited(visitMap, source, newPath, cb) {\n    var theEntry;\n    arrForEach(visitMap, function (entry) {\n        if (entry.k === source) {\n            theEntry = entry;\n            return -1;\n        }\n    });\n    if (!theEntry) {\n        theEntry = { k: source, v: source };\n        visitMap.push(theEntry);\n        cb(theEntry);\n    }\n    return theEntry.v;\n}\nfunction _deepCopy(visitMap, value, ctx, key) {\n    var userHandler = ctx.handler;\n    var newPath = ctx.path ? (key ? ctx.path.concat(key) : ctx.path) : [];\n    var newCtx = {\n        handler: ctx.handler,\n        src: ctx.src,\n        path: newPath\n    };\n    var theType = typeof value;\n    var isPlain = false;\n    var isPrim = value === NULL_VALUE;\n    if (!isPrim) {\n        if (value && theType === OBJECT) {\n            isPlain = isPlainObject(value);\n        }\n        else {\n            isPrim = isPrimitiveType(theType);\n        }\n    }\n    var details = {\n        type: theType,\n        isPrim: isPrim,\n        isPlain: isPlain,\n        value: value,\n        result: value,\n        path: newPath,\n        origin: ctx.src,\n        copy: function (source, newKey) {\n            return _deepCopy(visitMap, source, newKey ? newCtx : ctx, newKey);\n        },\n        copyTo: function (target, source) {\n            return _copyProps(visitMap, target, source, newCtx);\n        }\n    };\n    if (!details.isPrim) {\n        return _getSetVisited(visitMap, value, newPath, function (newEntry) {\n            objDefine(details, \"result\", {\n                g: function () {\n                    return newEntry.v;\n                },\n                s: function (newValue) {\n                    newEntry.v = newValue;\n                }\n            });\n            var idx = 0;\n            var handler = userHandler;\n            while (!(handler || (idx < defaultDeepCopyHandlers.length ? defaultDeepCopyHandlers[idx++] : _defaultDeepCopyHandler))[CALL](ctx, details)) {\n                handler = NULL_VALUE;\n            }\n        });\n    }\n    if (userHandler && userHandler[CALL](ctx, details)) {\n        return details.result;\n    }\n    return value;\n}\nfunction _copyProps(visitMap, target, source, ctx) {\n    if (!isNullOrUndefined(source)) {\n        for (var key in source) {\n            target[key] = _deepCopy(visitMap, source[key], ctx, key);\n        }\n    }\n    return target;\n}\nfunction objCopyProps(target, source, handler) {\n    var ctx = {\n        handler: handler,\n        src: source,\n        path: []\n    };\n    return _copyProps([], target, source, ctx);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction objDeepCopy(source, handler) {\n    var ctx = {\n        handler: handler,\n        src: source\n    };\n    return _deepCopy([], source, ctx);\n}\nfunction arrayDeepCopyHandler(details) {\n    var value = details.value;\n    if (isArray(value)) {\n        var target = details.result = [];\n        target.length = value.length;\n        details.copyTo(target, value);\n        return true;\n    }\n    return false;\n}\nfunction dateDeepCopyHandler(details) {\n    var value = details.value;\n    if (isDate(value)) {\n        details.result = new Date(value.getTime());\n        return true;\n    }\n    return false;\n}\nfunction functionDeepCopyHandler(details) {\n    if (details.type === FUNCTION) {\n        return true;\n    }\n    return false;\n}\nfunction plainObjDeepCopyHandler(details) {\n    var value = details.value;\n    if (value && details.isPlain) {\n        var target = details.result = {};\n        details.copyTo(target, value);\n        return true;\n    }\n    return false;\n}\n\nfunction _doExtend(target, theArgs) {\n    arrForEach(theArgs, function (theArg) {\n        objCopyProps(target, theArg);\n    });\n    return target;\n}\nfunction deepExtend(target, obj1, obj2, obj3, obj4, obj5, obj6) {\n    return _doExtend(objDeepCopy(target) || {}, ArrSlice[CALL](arguments));\n}\nfunction objExtend(target, obj1, obj2, obj3, obj4, obj5, obj6) {\n    return _doExtend(target || {}, ArrSlice[CALL](arguments));\n}\n\nvar getLength = ( /*#__PURE__*/_unwrapProp(LENGTH));\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction getIntValue(value, defValue) {\n    if (!isNullOrUndefined(value)) {\n        if (isNumber(value)) {\n            return value;\n        }\n        var theValue = parseInt(value, 10);\n        return isNaN(theValue) ? defValue : theValue;\n    }\n    return defValue;\n}\n\nvar _perf;\n/*#__NO_SIDE_EFFECTS__*/\nfunction hasPerformance() {\n    return !!getPerformance();\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction getPerformance() {\n    !_globalLazyTestHooks && _initTestHooks();\n    if (!_perf || _globalLazyTestHooks.lzy) {\n        _perf = createCachedValue(safe((getInst), [\"performance\"]).v);\n    }\n    return _perf.v;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction perfNow() {\n    var perf = getPerformance();\n    if (perf && perf.now) {\n        return perf.now();\n    }\n    return utcNow();\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction elapsedTime(startTime) {\n    return perfNow() - startTime;\n}\n\nvar MATCH_ANY = \"(.*)\";\nvar MATCH_SINGLE = \"(.)\";\nfunction _createRegExp(value, escapeRgx, replaceFn, ignoreCase, fullMatch) {\n    // eslint-disable-next-line security/detect-non-literal-regexp\n    return new RegExp((fullMatch ? \"^\" : EMPTY) + replaceFn(value.replace(escapeRgx, \"\\\\$1\")) + (fullMatch ? \"$\" : EMPTY), ignoreCase ? \"i\" : \"\");\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction createWildcardRegex(value, ignoreCase, fullMatch) {\n    return _createRegExp(asString(value), /([-+|^$#.\\?{}()\\[\\]\\\\/\\\"\\'])/g, function (value) {\n        return value.replace(/\\*/g, MATCH_ANY);\n    }, !!ignoreCase, fullMatch);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction createFilenameRegex(value, ignoreCase, fullMatch) {\n    return _createRegExp(asString(value), /([-+|^$#.{}()\\\\\\/\\[\\]\\\"\\'])/g, function (value) {\n        return value.replace(/(\\\\\\\\|\\\\\\/|\\*|\\?)/g, function (_all, g1) {\n            if (g1 == \"\\\\/\" || g1 == \"\\\\\\\\\") {\n                return \"[\\\\\\\\\\\\/]{1}\";\n            }\n            return g1 == \"*\" ? MATCH_ANY : MATCH_SINGLE;\n        });\n    }, !!ignoreCase, fullMatch);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction makeGlobRegex(value, ignoreCase, fullMatch) {\n    return _createRegExp(asString(value), /([-+|^$#.{}()\\\\\\/\\[\\]\\\"\\'])/g, function (value) {\n        return value.replace(/(\\*\\*\\\\[\\\\\\/]|\\\\\\\\|\\\\\\/|\\*\\*|\\*|\\?)/g, function (_all, g1) {\n            if (g1 == \"**\\\\/\" || g1 == \"**\\\\\\\\\") {\n                return \"(.*[\\\\\\\\\\\\/])*\";\n            }\n            if (g1 === \"\\\\/\" || g1 == \"\\\\\\\\\") {\n                return \"[\\\\\\\\\\\\/]{1}\";\n            }\n            if (g1 === \"**\") {\n                return MATCH_ANY;\n            }\n            return g1 === \"*\" ? \"([^\\\\\\\\\\\\/]*)\" : \"([^\\\\\\\\\\\\/]{1})\";\n        });\n    }, !!ignoreCase, fullMatch);\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction safeGetLazy(cb, defValue) {\n    return getLazy(function () {\n        var result = safe(cb);\n        return result.e ? defValue : result.v;\n    });\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction _checkLength(value, props) {\n    var result;\n    arrForEach(props, function (prop) {\n        if (prop in value) {\n            var propValue = value[prop];\n            result = (isFunction(propValue) ? propValue() : propValue) > 0;\n            return -1;\n        }\n    });\n    return result;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction _hasValue(value, depth) {\n    var result = value === false || value === 0;\n    if (!result && !isNullOrUndefined(value)) {\n        if (isArray(value)) {\n            result = value[LENGTH] > 0;\n        }\n        else if (isDate(value)) {\n            result = !isNaN(value.getTime());\n        }\n        else if (isBoolean(value)) {\n            return true;\n        }\n        else if (isObject(value)) {\n            try {\n                var chkValue = _checkLength(value, [LENGTH, \"byteLength\", \"size\", \"count\"]);\n                if (isBoolean(chkValue)) {\n                    return chkValue;\n                }\n                if (isFunction(value.valueOf) && depth < 5) {\n                    return _hasValue(value.valueOf(), ++depth);\n                }\n            }\n            catch (e) {\n            }\n            return !!objKeys(value)[LENGTH];\n        }\n        else {\n            result = isTruthy(value);\n        }\n    }\n    return result;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction hasValue(value) {\n    return _hasValue(value, 0);\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction createIterable(ctx) {\n    return makeIterable({}, ctx);\n}\nfunction makeIterable(target, ctx) {\n    var itSymbol = getKnownSymbol(3 );\n    function _createIterator() {\n        return createIterator(ctx);\n    }\n    target[itSymbol] = _createIterator;\n    return target;\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction createIterator(ctx) {\n    var isDone = false;\n    function _value() {\n        return ctx.v;\n    }\n    function _next() {\n        if (!isDone) {\n            isDone = (ctx.n ? ctx.n(arguments) : true);\n        }\n        var result = {\n            done: isDone\n        };\n        if (!isDone) {\n            objDefine(result, \"value\", { g: _value });\n        }\n        return result;\n    }\n    function _return(value) {\n        isDone = true;\n        return {\n            done: true,\n            value: ctx.r && ctx.r(value)\n        };\n    }\n    function _throw(e) {\n        isDone = true;\n        return {\n            done: true,\n            value: ctx.t && ctx.t(e)\n        };\n    }\n    var theIterator = {\n        next: _next\n    };\n    if (ctx.r) {\n        theIterator.return = _return;\n    }\n    if (ctx.t) {\n        theIterator.throw = _throw;\n    }\n    return theIterator;\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction createArrayIterator(values) {\n    var idx = -1;\n    var theValues = values ? values.slice() : [];\n    var len = theValues[LENGTH];\n    function _value() {\n        if (idx >= 0 && idx < len) {\n            return theValues[idx];\n        }\n    }\n    function _getNext() {\n        idx++;\n        return idx >= len;\n    }\n    var ctx = {\n        n: _getNext\n    };\n    objDefine(ctx, \"v\", { g: _value });\n    return createIterator(ctx);\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction createRangeIterator(start, end, step) {\n    var nextValue = start;\n    var theValue = UNDEF_VALUE;\n    if (isNullOrUndefined(end)) {\n        end = start;\n    }\n    var theStep = step;\n    if (!theStep) {\n        theStep = (start <= end) ? 1 : -1;\n    }\n    function _value() {\n        return theValue;\n    }\n    function _getNext() {\n        var isDone = (theStep > 0) ? (nextValue > end) : (nextValue < end);\n        if (!isDone) {\n            theValue = nextValue;\n            nextValue += theStep;\n        }\n        return isDone;\n    }\n    return createIterator(objDefine({\n        n: _getNext\n    }, \"v\", { g: _value }));\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyStrSymSplit(value, splitter, limit) {\n    var splitFn = splitter ? splitter[getKnownSymbol(9 )] : UNDEF_VALUE;\n    return splitFn ? splitFn(value, limit) : [value];\n}\n\nvar strSplit = ( /*#__PURE__*/_unwrapFunction(\"split\", StrProto));\nvar strSymSplit = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"split\", StrProto, !hasSymbol() ? polyStrSymSplit : NULL_VALUE));\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction getValueByKey(target, path, defValue) {\n    if (!path || !target) {\n        return defValue;\n    }\n    var parts = strSplit(path, \".\");\n    var cnt = parts.length;\n    for (var lp = 0; lp < cnt && !isNullOrUndefined(target); lp++) {\n        target = target[parts[lp]];\n    }\n    return (!isNullOrUndefined(target) ? target : defValue);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction getValueByIter(target, iter, defValue) {\n    if (!iter || !target) {\n        return defValue;\n    }\n    iterForOf(iter, function (value) {\n        if (isNullOrUndefined(target)) {\n            return -1;\n        }\n        target = target[value];\n    });\n    return (!isNullOrUndefined(target) ? target : defValue);\n}\nfunction setValueByKey(target, path, value) {\n    if (target && path) {\n        var parts = strSplit(path, \".\");\n        var lastKey = parts.pop();\n        arrForEach(parts, function (key) {\n            if (isNullOrUndefined(target[key])) {\n                target[key] = {};\n            }\n            target = target[key];\n        });\n        target[lastKey] = value;\n    }\n}\nfunction setValueByIter(target, iter, value) {\n    if (target && iter) {\n        var lastKey_1;\n        iterForOf(iter, function (key) {\n            if (lastKey_1) {\n                if (isNullOrUndefined(target[lastKey_1])) {\n                    target[lastKey_1] = {};\n                }\n                target = target[lastKey_1];\n            }\n            lastKey_1 = key;\n        });\n        target[lastKey_1] = value;\n    }\n}\n\nvar strEndsWith = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"endsWith\", StrProto, polyStrEndsWith));\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyStrEndsWith(value, searchString, length) {\n    if (!isString(value)) {\n        throwTypeError(\"'\" + dumpObj(value) + \"' is not a string\");\n    }\n    var searchValue = isString(searchString) ? searchString : asString(searchString);\n    var end = (!isUndefined(length) && length < value[LENGTH]) ? length : value[LENGTH];\n    return strSubstring(value, end - searchValue[LENGTH], end) === searchValue;\n}\n\nvar strIndexOf = ( /*#__PURE__*/_unwrapFunction(\"indexOf\", StrProto));\nvar strLastIndexOf = ( /*#__PURE__*/_unwrapFunction(\"lastIndexOf\", StrProto));\n\nvar strIncludes = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"includes\", StrProto, polyStrIncludes));\nvar strContains = ( /*#__PURE__*/_pureAssign(strIncludes));\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyStrIncludes(value, searchString, position) {\n    if (isRegExp(searchString)) {\n        throwTypeError(\"'searchString' must not be a regular expression\" + dumpObj(searchString));\n    }\n    return strIndexOf(value, asString(searchString), position) !== -1;\n}\n\n/*#__NO_SIDE_EFFECTS__*/\nfunction strIsNullOrWhiteSpace(value) {\n    if (isString(value)) {\n        return value.replace(/[\\s\\t\\r\\n\\f]+/g, EMPTY) === EMPTY;\n    }\n    return isNullOrUndefined(value);\n}\n/*#__NO_SIDE_EFFECTS__*/\nfunction strIsNullOrEmpty(value) {\n    if (isString(value)) {\n        return value === EMPTY;\n    }\n    return isNullOrUndefined(value);\n}\n\nvar strStartsWith = ( /*#__PURE__*/_unwrapFunctionWithPoly(\"startsWith\", StrProto, polyStrStartsWith));\n/*#__NO_SIDE_EFFECTS__*/\nfunction polyStrStartsWith(value, searchString, position) {\n    if (!isString(value)) {\n        throwTypeError(\"'\" + dumpObj(value) + \"' is not a string\");\n    }\n    var searchValue = isString(searchString) ? searchString : asString(searchString);\n    var pos = position > 0 ? position : 0;\n    return strSubstring(value, pos, pos + searchValue[LENGTH]) === searchValue;\n}\n\nvar REF = \"ref\";\nvar UNREF = \"unref\";\nvar HAS_REF = \"hasRef\";\nvar ENABLED = \"enabled\";\n/*#__NO_SIDE_EFFECTS__*/\nfunction _createTimerHandler(startTimer, refreshFn, cancelFn) {\n    var ref = true;\n    var timerId = startTimer ? refreshFn(NULL_VALUE) : NULL_VALUE;\n    var theTimerHandler;\n    function _unref() {\n        ref = false;\n        timerId && timerId[UNREF] && timerId[UNREF]();\n        return theTimerHandler;\n    }\n    function _cancel() {\n        timerId && cancelFn(timerId);\n        timerId = NULL_VALUE;\n    }\n    function _refresh() {\n        timerId = refreshFn(timerId);\n        if (!ref) {\n            _unref();\n        }\n        return theTimerHandler;\n    }\n    function _setEnabled(value) {\n        !value && timerId && _cancel();\n        value && !timerId && _refresh();\n    }\n    theTimerHandler = {\n        cancel: _cancel,\n        refresh: _refresh\n    };\n    theTimerHandler[HAS_REF] = function () {\n        if (timerId && timerId[HAS_REF]) {\n            return timerId[HAS_REF]();\n        }\n        return ref;\n    };\n    theTimerHandler[REF] = function () {\n        ref = true;\n        timerId && timerId[REF] && timerId[REF]();\n        return theTimerHandler;\n    };\n    theTimerHandler[UNREF] = _unref;\n    theTimerHandler = objDefineProp(theTimerHandler, ENABLED, {\n        get: function () { return !!timerId; },\n        set: _setEnabled\n    });\n    return {\n        h: theTimerHandler,\n        dn: function () {\n            timerId = NULL_VALUE;\n        }\n    };\n}\n\nfunction _createTimeoutWith(startTimer, overrideFn, theArgs) {\n    var isArr = isArray(overrideFn);\n    var len = isArr ? overrideFn.length : 0;\n    var setFn = (len > 0 ? overrideFn[0] : (!isArr ? overrideFn : UNDEF_VALUE)) || setTimeout;\n    var clearFn = (len > 1 ? overrideFn[1] : UNDEF_VALUE) || clearTimeout;\n    var timerFn = theArgs[0];\n    theArgs[0] = function () {\n        handler.dn();\n        fnApply(timerFn, UNDEF_VALUE, ArrSlice[CALL](arguments));\n    };\n    var handler = _createTimerHandler(startTimer, function (timerId) {\n        if (timerId) {\n            if (timerId.refresh) {\n                timerId.refresh();\n                return timerId;\n            }\n            fnApply(clearFn, UNDEF_VALUE, [timerId]);\n        }\n        return fnApply(setFn, UNDEF_VALUE, theArgs);\n    }, function (timerId) {\n        fnApply(clearFn, UNDEF_VALUE, [timerId]);\n    });\n    return handler.h;\n}\nfunction scheduleTimeout(callback, timeout) {\n    return _createTimeoutWith(true, UNDEF_VALUE, ArrSlice[CALL](arguments));\n}\nfunction scheduleTimeoutWith(overrideFn, callback, timeout) {\n    return _createTimeoutWith(true, overrideFn, ArrSlice[CALL](arguments, 1));\n}\nfunction createTimeout(callback, timeout) {\n    return _createTimeoutWith(false, UNDEF_VALUE, ArrSlice[CALL](arguments));\n}\nfunction createTimeoutWith(overrideFn, callback, timeout) {\n    return _createTimeoutWith(false, overrideFn, ArrSlice[CALL](arguments, 1));\n}\n\nvar _defaultIdleTimeout = 100;\nvar _maxExecutionTime = 50;\n/*#__NO_SIDE_EFFECTS__*/\nfunction hasIdleCallback() {\n    return !!( /*#__PURE__*/getIdleCallback());\n}\nvar getIdleCallback = ( /*#__PURE__*/_getGlobalInstFn(getInst, [\"requestIdleCallback\"]));\nvar getCancelIdleCallback = ( /*#__PURE__*/_getGlobalInstFn(getInst, [\"cancelIdleCallback\"]));\nfunction setDefaultIdleTimeout(timeout) {\n    _defaultIdleTimeout = timeout;\n}\nfunction setDefaultMaxExecutionTime(maxTime) {\n    _maxExecutionTime = maxTime;\n}\nfunction scheduleIdleCallback(callback, options) {\n    function _createDeadline(timedOut) {\n        var startTime = perfNow();\n        return {\n            didTimeout: timedOut,\n            timeRemaining: function () {\n                return _maxExecutionTime - elapsedTime(startTime);\n            }\n        };\n    }\n    if (hasIdleCallback()) {\n        var handler_1 = _createTimerHandler(true, function (idleId) {\n            idleId && getCancelIdleCallback()(idleId);\n            return getIdleCallback()(function (deadline) {\n                handler_1.dn();\n                callback(deadline || _createDeadline(false));\n            }, options);\n        }, function (idleId) {\n            getCancelIdleCallback()(idleId);\n        });\n        return handler_1.h;\n    }\n    var timeout = (options || {}).timeout;\n    if (isUndefined(timeout)) {\n        timeout = _defaultIdleTimeout;\n    }\n    return scheduleTimeout(function () {\n        callback(_createDeadline(true));\n    }, timeout);\n}\n\nfunction scheduleInterval(callback, timeout) {\n    var theArguments = ArrSlice[CALL](arguments);\n    var handler = _createTimerHandler(true, function (intervalId) {\n        intervalId && clearInterval(intervalId);\n        return fnApply(setInterval, UNDEF_VALUE, theArguments);\n    }, function (intervalId) {\n        fnApply(clearInterval, UNDEF_VALUE, [intervalId]);\n    });\n    return handler.h;\n}\n\nexport { arrAppend, arrContains, arrEvery, arrFilter, arrFind, arrFindIndex, arrFindLast, arrFindLastIndex, arrForEach, arrFrom, arrIncludes, arrIndexOf, arrLastIndexOf, arrMap, arrReduce, arrSlice, arrSome, arrayDeepCopyHandler, asString, createArrayIterator, createCachedValue, createCustomError, createDeferredCachedValue, createEnum, createEnumKeyMap, createEnumValueMap, createFilenameRegex, createFnDeferredProxy, createIterable, createIterator, createProxyFuncs, createRangeIterator, createSimpleMap, createTimeout, createTimeoutWith, createTypeMap, createWildcardRegex, dateDeepCopyHandler, deepExtend, dumpObj, elapsedTime, encodeAsHtml, encodeAsJson, fnApply, fnBind, fnCall, functionDeepCopyHandler, getCancelIdleCallback, getDocument, getGlobal, getHistory, getIdleCallback, getInst, getIntValue, getKnownSymbol, getLazy, getLength, getNavigator, getPerformance, getSymbol, getValueByIter, getValueByKey, getWindow, hasDocument, hasHistory, hasIdleCallback, hasNavigator, hasPerformance, hasSymbol, hasValue, hasWindow, isArray, isArrayBuffer, isBlob, isBoolean, isDate, isDefined, isError, isFile, isFormData, isFunction, isIterable, isIterator, isNode, isNotTruthy, isNullOrUndefined, isNumber, isObject, isPlainObject, isPrimitive, isPrimitiveType, isPromise, isPromiseLike, isRegExp, isStrictNullOrUndefined, isStrictUndefined, isString, isSymbol, isThenable, isTruthy, isTypeof, isUndefined, isWebWorker, iterForOf, lazySafeGetInst, makeGlobRegex, makeIterable, mathCeil, mathFloor, mathMax, mathMin, mathToInt, mathTrunc, newSymbol, normalizeJsName, objAssign, objCopyProps, objCreate, objDeepCopy, objDeepFreeze, objDefine, objDefineAccessors, objDefineGet, objDefineProp, objDefineProperties, objDefineProps, objEntries, objExtend, objForEachKey, objFreeze, objGetOwnPropertyDescriptor, objGetPrototypeOf, objHasOwn, objHasOwnProperty, objKeys, objSeal, objSetPrototypeOf, objToString, perfNow, plainObjDeepCopyHandler, polyArrFind, polyArrFindIndex, polyArrFindLast, polyArrFindLastIndex, polyArrFrom, polyArrIncludes, polyGetKnownSymbol, polyIsArray, polyNewSymbol, polyObjEntries, polyObjHasOwn, polyObjKeys, polyStrIncludes, polyStrSubstr, polyStrSymSplit, polyStrTrim, polyStrTrimEnd, polyStrTrimStart, polySymbolFor, polySymbolKeyFor, polyUtcNow, readArgs, safe, safeGet, safeGetLazy, scheduleIdleCallback, scheduleInterval, scheduleTimeout, scheduleTimeoutWith, setBypassLazyCache, setDefaultIdleTimeout, setDefaultMaxExecutionTime, setValueByIter, setValueByKey, strCamelCase, strContains, strEndsWith, strIncludes, strIndexOf, strIsNullOrEmpty, strIsNullOrWhiteSpace, strKebabCase, strLastIndexOf, strLeft, strLetterCase, strLower, strPadEnd, strPadStart, strRepeat, strRight, strSlice, strSnakeCase, strSplit, strStartsWith, strSubstr, strSubstring, strSymSplit, strTrim, strTrimEnd, strTrimLeft, strTrimRight, strTrimStart, strUpper, symbolFor, symbolKeyFor, throwError, throwRangeError, throwTypeError, throwUnsupported, utcNow };\n//# sourceMappingURL=ts-utils.js.map\n"],"sourceRoot":""}