{"version":3,"sources":["functions.ts"],"sourcesContent":["/**\n * This file contains utility funtions to transform pointer to other pointers.\n * The resulting pointers are automatically updated when the input pointers are updated\n */\n\n\nimport { AsyncTransformFunction, INSERT_MARK, MaybeObjectRef, MinimalJSRef, Pointer, ReactiveValue, RefLike, RefOrValue, SmartTransformFunction, SmartTransformOptions, TransformFunction, TransformFunctionInputs, logger } from \"./datex_all.ts\";\nimport { Datex } from \"./mod.ts\";\nimport { PointerError } from \"./types/errors.ts\";\nimport { IterableHandler } from \"./utils/iterable-handler.ts\";\nimport { AsyncSmartTransformFunction, MinimalJSRefWithIndirectRef, RestrictSameType } from \"./runtime/pointers.ts\";\nimport { handleError } from \"./utils/error-handling.ts\";\nimport { KnownError } from \"./utils/error-handling.ts\";\n\n/**\n * A generic transform function, creates a new pointer containing the result of the callback function.\n * At any point in time, the pointer is the result of the callback function.\n * In contrast to the `transform` function, dependency references are automatically detected, they don't need to be explicitly specified.\n * ```ts\n * const x = $$(10);\n * const y = always (() => x * 2);\n * y.val // 20\n * x.val = 5;\n * y.val // 10\n * ```\n */\nexport function always<T>(transform:SmartTransformFunction<T>, options?: SmartTransformOptions): MinimalJSRefWithIndirectRef<T> // return signature from Value.collapseValue(Pointer.smartTransform())\n\n\n// only works with JUSIX compilation\nexport function always<const T>(value:T, options?: SmartTransformOptions): MinimalJSRef<T>\n\n/**\n * Shortcut for datex `always (...)`\n * @param script \n * @param vars \n */\nexport function always<T=unknown>(script:TemplateStringsArray, ...vars:any[]): Promise<MinimalJSRefWithIndirectRef<T>>\nexport function always(scriptOrJSTransform:TemplateStringsArray|SmartTransformFunction<any>, ...vars:any[]) {\n    // js function\n    if (typeof scriptOrJSTransform == \"function\") {\n        const options: SmartTransformOptions|undefined = typeof vars[0] == \"object\" ? vars[0] : undefined;\n        // make sure handler is not an async function\n        if (scriptOrJSTransform.constructor.name == \"AsyncFunction\" && !options?._allowAsync) {\n            throw new Error(\"Async functions are not allowed as always transforms\")\n        }\n        const ptr = Pointer.createSmartTransform(scriptOrJSTransform, undefined, undefined, undefined, options);\n        if (options?._allowAsync && !ptr.value_initialized && ptr.waiting_for_initial_async_transform) {\n            return ptr.waiting_for_initial_async_transform.then(()=>collapseTransformPointer(ptr, options?._collapseStatic, options?._returnWrapper, options?._allowAnyType, options?._rebindStaticToPointers));\n        }\n        if (!ptr.value_initialized && ptr.waiting_for_initial_async_transform) {\n            throw new PointerError(`Promises cannot be returned from always transforms - use 'asyncAlways' instead`);\n        }\n        else {\n            return collapseTransformPointer(ptr, options?._collapseStatic, options?._returnWrapper, options?._allowAnyType, options?._rebindStaticToPointers);\n        }\n    }\n    // datex script\n    else if (scriptOrJSTransform.raw instanceof Array) {\n        return (async ()=>collapseTransformPointer(await datex(`always (${scriptOrJSTransform.raw.join(INSERT_MARK)})`, vars)))()\n    }\n    else {\n        handleError(new KnownError(\"You called 'always' with invalid arguments. It seems like you are not using Deno for UIX.\", [\n            \"Install Deno for UIX, see https://docs.unyt.org/manual/uix/getting-started#install-deno\",\n            \"Call 'always' with a function: always(() => ...)\"\n        ]))\n    }\n}\n\n\nfunction collapseTransformPointer(ptr: Pointer, collapseStatic = false, alwaysReturnWrapper = false, _allowAnyType = false, _rebindStaticToPointers = false) {\n    // collapse if transform function is static\n    const collapse = collapseStatic && ptr.isStaticTransform;\n\n    if (_allowAnyType) {\n        ptr.allowAnyType(true);\n    }\n    \n    if (alwaysReturnWrapper && !collapse) {\n        return ptr;\n    }\n    \n    const val = ReactiveValue.collapseValue(ptr, false, collapse);\n\n    if (collapse) ptr.delete();\n    // TODO: deproxify static non-primitive objects to garbage-collect pointer and associated data\n    if (_rebindStaticToPointers) {\n        if (!(val instanceof ReactiveValue)) {\n            return Pointer.createOrGet(val);\n        }\n        else {\n            return val;\n        }\n    }\n    else {\n        return val;\n    }\n}\n\n/**\n * A generic transform function, creates a new pointer containing the result of the callback function.\n * At any point in time, the pointer is the result of the callback function.\n * In contrast to the always function, this function can return a Promise\n * ```ts\n * const x = $$(42);\n * const y = await asyncAlways (() => complexCalculation(x.val * 10));\n * \n * async function complexCalculation(input: number) {\n *    const res = await ...// some async operation\n *    return res\n * }\n * ```\n */\nexport async function asyncAlways<T>(transform:AsyncSmartTransformFunction<T>, options?: SmartTransformOptions): Promise<MinimalJSRefWithIndirectRef<T>> { // return signature from Value.collapseValue(Pointer.smartTransform())\n    const ptr = Pointer.createSmartTransform(transform, undefined, undefined, undefined, options);\n    if (!ptr.value_initialized && ptr.waiting_for_initial_async_transform) {\n        await ptr.waiting_for_initial_async_transform;\n    }\n    else {\n        logger.warn(\"asyncAlways: transform function did not return a Promise, you should use 'always' instead\")\n    }\n    return ReactiveValue.collapseValue(ptr) as MinimalJSRef<T>\n}\n\n/**\n * Decorator for creating a reactive function.\n * Functions decorated with `reactiveFn` always return a pointer that is automatically updated when input references are updated.\n * This has the same effect as wrapping the function body with `always`.\n * A reactive functions accepts references or values as arguments, but is always called with collapsed values. \n * This means that you don't have to specifiy `Ref` values as arguments, but can use regular types.\n * \n * Example:\n * ```ts\n * // create reactive function 'getSquared'\n * const getSquared = reactiveFn((x: number) => x * x);\n * \n * const x = $$(2);\n * const y = getSquared(x); // Ref<4>\n * x.val = 3;\n * y // Ref<9>\n * ```\n */\nexport function reactiveFn<ReturnType, Args extends unknown[]>(fn: (...args: Args) => Awaited<RestrictSameType<RefOrValue<ReturnType>>>) {\n    return (...args: MapToRefOrVal<Args>) => always(() => {\n        const collapsedArgs = args.map(arg => ReactiveValue.collapseValue(arg, true, true)) as Args;\n        return fn(...collapsedArgs)\n    });\n}\n\ntype MapToRefOrVal<T extends unknown[]> = {[K in keyof T]: T[K] extends ReactiveValue ? T[K] : RefOrValue<T[K]>}\n\n\nconst getGreetingMessage = (country: RefOrValue<string>) => {\n    return always(() => {\n        switch (country) {\n            case \"de\": return \"Hallo\";\n            case \"fr\": return \"Bonjour\";\n            case \"es\": return \"Hola\";\n            default: return \"Hello\";\n        }\n    })\n}\n\n/**\n * Runs each time a dependency reference value changes.\n * Dependency references are automatically detected.\n * ```ts\n * const x = $$(10);\n * effect (() => console.log(\"x is \" + x));\n * x.val = 5; // logs \"x is 5\"\n * ```\n * \n * Disposing effects:\n * ```ts\n * const x = $$(10);\n * const {dispose} = effect (() => console.log(\"x is \" + x));\n * x.val = 5; // logs \"x is 5\"\n * dispose();\n * x.val = 6; // no log\n * ```\n */\nexport function effect<W extends Record<string, WeakKey>|undefined>(handler:W extends undefined ? () => void|Promise<void> :(weakVariables: W) => void|Promise<void>, weakVariables?: W): {dispose: () => void, [Symbol.dispose]: () => void} {\n    \n    let ptr: Pointer;\n\n    // weak variable binding\n    if (weakVariables) {\n        const weakVariablesProxy = {};\n        for (const [k, v] of Object.entries(weakVariables)) {\n            const weakRef = new WeakRef(v);\n            Object.defineProperty(weakVariablesProxy, k, {get() {\n              const val = weakRef.deref()\n              if (!val) {\n                // dispose effect\n                ptr.is_persistent = false;\n                ptr.delete()\n                throw Pointer.WEAK_EFFECT_DISPOSED;\n              }\n              else return val;\n            }})\n        }\n        const originalHandler = handler;\n        handler = (() => originalHandler(weakVariablesProxy)) as any;\n    }\n    \n    ptr = Pointer.createSmartTransform(handler as any, undefined, true, true);\n    ptr.is_persistent = true;\n\n    return {\n        [Symbol.dispose||Symbol.for(\"Symbol.dispose\")]() {\n            ptr.is_persistent = false;\n            ptr.delete()\n        },\n        dispose() {\n            ptr.is_persistent = false;\n            ptr.delete()\n        }\n    }\n}\n\n\n/**\n * A generic transform function, creates a new pointer containing the result of the callback function.\n * At any point in time, the pointer is the result of the callback function.\n * Dependency references have to be specified. If one of the dependencies changes, the resulting pointe\n * value is recalculated.\n * @param dependencies dependency references\n * @param transform transform function\n * @param persistent_datex_transform optional equivalent datex script describing the transform\n * @returns \n */\nexport function transform<T,V extends TransformFunctionInputs>(dependencies:V, transform:TransformFunction<V,T>, persistent_datex_transform?:string) {\n    return ReactiveValue.collapseValue(Pointer.createTransform(dependencies, transform, persistent_datex_transform));\n}\n/**\n * A generic transform function, creates a new pointer containing the result of the callback function.\n * At any point in time, the pointer is the result of the callback function.\n * Dependency references have to be specified. If one of the dependencies changes, the resulting pointe\n * value is recalculated.\n * @param dependencies dependency references\n * @param transform an async transform function (returning a Promise)\n * @param persistent_datex_transform optional equivalent datex script describing the transform\n * @returns \n */\nexport async function transformAsync<T,V extends TransformFunctionInputs>(dependencies:V, transform:AsyncTransformFunction<V,T>, persistent_datex_transform?:string) {\n    return ReactiveValue.collapseValue(await Pointer.createTransformAsync(dependencies, transform, persistent_datex_transform));\n}\n\n\nexport function map<T, U, O extends 'array'|'map' = 'array'>(iterable: Iterable<T>, mapFn: (value: MaybeObjectRef<T>, index: number, array: Iterable<T>) => U, options?: {outType: O}): O extends \"array\" ? U[] : Map<number, U> {\n    let mapped:U[]|Map<number, U>\n    \n    // live map\n    if (Datex.ReactiveValue.isRef(iterable)) {\n\n        // return map\n        if (options?.outType == \"map\") {\n            mapped = $(new Map())\n\n            const iterableHandler = new IterableHandler(iterable, {\n                map: (v,k)=>{\n                    return mapFn(v,k,iterable)\n                },\n                onEntryRemoved: (v,k) => {\n                    (mapped as Map<number,U>).delete(k)\n                },\n                onNewEntry: (v,k) => (mapped as Map<number,U>).set(k,v),\n                onEmpty: () => (mapped as Map<number,U>).clear()\n            })\n            // reverse transform binding\n            Datex.Pointer.bindDisposable(mapped, iterableHandler)\n        }\n\n        // return array\n        else {\n            mapped = $([])\n\n            // no gaps in a set -> array splice required\n            const spliceArray = iterable instanceof Set; \n\n            const iterableHandler = new IterableHandler(iterable, {\n                map: (v,k)=>{\n                    return mapFn(v,k,iterable)\n                },\n                onEntryRemoved: (v,k) => {\n                    if (spliceArray) (mapped as U[]).splice(k, 1);\n                    else delete (mapped as U[])[k];\n                },\n                onNewEntry: (v,k) => {\n                    (mapped as U[])[k] = v;\n                },\n                onEmpty: () => {\n                    (mapped as U[]).length = 0\n                }\n            })\n            // reverse transform binding\n            Datex.Pointer.bindDisposable(mapped, iterableHandler)\n        }\n\n    }\n\n    // static map\n    else {\n        if (options?.outType == \"map\") {\n            mapped = new Map()\n            let i = 0;\n            for (const val of iterable) {\n                mapped.set(i, mapFn(val, i++, iterable))\n            }\n        }\n        else {\n            mapped = []\n            let i = 0;\n            for (const val of iterable) {\n                mapped.push(mapFn(val, i++, iterable))\n            }\n        }\n        \n    }\n\n    const ptr = Pointer.getByValue(mapped);\n    if (ptr) ptr.isTransform = true;\n    \n    return mapped as any;\n}\n\n\n// TODO: (remove empty entries inbetween)\nexport function filter<T, U>(array: Array<T>, predicate: (value: T, index: number, array: T[]) => boolean, deps?: Datex.RefOrValue<any>[]): T[] {\n    // live map\n    if (Datex.ReactiveValue.isRef(array)) {\n\n        const filtered: U[] = $([])\n        const spliceArray = true;\n\n        const observers = new Map<number, [Ref<boolean>, ()=>void]>();\n        const removeObserver = (key: number) => {\n            const observer = observers.get(key);\n            if (observer) {\n                unobserve(observer[0], observer[1]);\n                // explicitly delete ref\n                observer[0].delete();\n            }\n        }\n\n        const handler = new IterableHandler<T,U>(array, {\n            filter: (v,k):v is T&U => {\n                // remove previous observer if it exists\n                removeObserver(k);\n                // make filter function reactive, re-evaluate when dependencies changes\n                const filtered = always(() => predicate(array[k],k,array));\n                const observer = () => {\n                    handler.handleNewEntry(array[k],k,filtered.val);\n                }\n                observers.set(k, [filtered, observer])\n                observe(filtered, observer);\n                return filtered.val;              \n            },\n            onEntryRemoved: (v,k) => {\n                if (spliceArray) filtered.splice(k, 1);\n                else delete filtered[k];\n            },\n            onNewEntry: (v,k) => {\n                filtered[k] = v\n            },\n            onSplice: (start, deleteCount, ...items) => {\n                filtered.splice(start, deleteCount, ...items)\n            },\n            onEmpty: () => {\n                filtered.length = 0\n            }\n        });\n\n        if (deps) {\n            // TODO cleanup gargabe\n            const _deps = $(deps);\n            const originalRef = Datex.Pointer.getByValue(array);\n            const filteredRef = Datex.Pointer.getByValue(filtered);\n            if (originalRef)\n                observe(_deps, () => {\n                    // Trigger event for iterable handler\n                    originalRef.triggerValueInitEvent(false);\n                    // Trigger event on always value of filtered array\n                    filteredRef?.triggerValueInitEvent(false);\n                    // filteredRef?.triggerValueEvent(ReactiveValue.UPDATE_TYPE.UPDATE, false);\n                });\n        }\n\n        return filtered as unknown as T[];\n\n    }\n\n    // static map\n    else return array.filter(predicate)\n}\n\n\n/**\n * Switches between two values depending if a value is true or false\n * @param value input value\n * @param if_true value selected if true\n * @param if_false value selected if false\n */\nexport function toggle<T>(value:RefLike<boolean>, if_true:T, if_false:T = null as T): MinimalJSRef<T> {\n    return transform([value], v=>v?<any>if_true:<any>if_false, \n    // dx transforms not working correctly (with uix)\n    /*`\n    always (\n        if (${Runtime.valueToDatexString(value)}) (${Runtime.valueToDatexString(if_true)}) \n        else (${Runtime.valueToDatexString(if_false)})\n    )`*/);\n}\n\n\n/**\n * @deprecated, use toggle()\n */\nexport const select = toggle;\n\n\n/**\n * Returns a pointer representing a === b\n * @param a input value\n * @param b input value\n */\nexport function equals<T,V>(a:RefLike<T>|T, b: RefLike<V>|V): Datex.Pointer<boolean> {\n    return transform([a, b], (a,b) =>  Datex.ReactiveValue.collapseValue(a, true, true) === Datex.ReactiveValue.collapseValue(b, true, true), \n    // dx transforms not working correctly (with uix)\n        /*`always (${Runtime.valueToDatexString(a)} === ${Runtime.valueToDatexString(b)})`*/) as any;\n}\n\n\n/**\n * Selects a property from an object\n * @param property property name\n * @param object the reference object\n * @returns \n */\nexport function selectProperty<K extends string|number, V>(property:RefLike<K>, object:Readonly<Record<K, V>>):MinimalJSRef<V> {\n    return <MinimalJSRef<V>> transform([property], (v)=><any>object[<K>v]);\n}\n\n\n/**\n * Inverts a boolean value/reference\n * @param value \n * @returns \n */\nexport function not(value:RefOrValue<boolean>): Pointer<boolean> {\n    return transform([value], v=>!v);\n}\n\n/**\n * Performs a boolean 'and' operation on one or more boolean values/references\n * @param values \n * @returns \n */\nexport function and(...values:RefOrValue<boolean>[]): Pointer<boolean> {\n    return transform(values, (...values)=>{\n        for (const v of values) {\n            if (!v) return false;\n        }\n        return true;\n    });\n}\n\n/**\n * Performs a boolean 'or' operation on one or more boolean values/references\n * @param values \n * @returns \n */\nexport function or(...values:RefOrValue<boolean>[]): Pointer<boolean> {\n    return transform(values, (...values)=>{\n        for (const v of values) {\n            if (v) return true;\n        }\n        return false;\n    });\n}\n\n/**\n * Performs an 'add' operation on one or more values (strings, numbers)\n * @param numbers \n * @returns \n */\nexport function add<T>(...numbers:RefOrValue<T>[]): MinimalJSRef<T>\nexport function add(...args:any[]) {\n    return transform([...args], (...args) => args.reduce((a, b) => a + b, 0));\n}\n\n/**\n * Performs a 'subtract' operation on one or more numbers\n * @param numbers \n * @returns \n */\nexport function sub(...numbers:RefOrValue<bigint>[]): MinimalJSRef<bigint>\nexport function sub(...numbers:RefOrValue<number>[]): MinimalJSRef<number>\nexport function sub(...args:any[]) {\n    return transform([...args], (...args) => args.slice(1).reduce((a, b) => a - b, args[0]));\n}\n\n/**\n * Performs a 'multiply' operation on one or more numbers\n * @param numbers \n * @returns \n */\nexport function mul(...numbers:RefOrValue<bigint>[]): MinimalJSRef<bigint>\nexport function mul(...numbers:RefOrValue<number>[]): MinimalJSRef<number>\nexport function mul(...args:any[]) {\n    return transform([...args], (...args) => args.reduce((a, b) => a * b, 1));\n}\n\n/**\n * Performs a 'division' operation on one or more numbers\n * @param numbers \n * @returns \n */\nexport function div(...numbers:RefOrValue<bigint>[]): MinimalJSRef<bigint>\nexport function div(...numbers:RefOrValue<number>[]): MinimalJSRef<number>\nexport function div(...args:any[]) {\n    return transform([...args], (...args) => args.slice(1).reduce((a, b) => a / b, args[0]));\n}\n\n/**\n * Performs a 'power' operation on one or more numbers\n * @param numbers \n * @returns \n */\nexport function pow(...numbers:RefOrValue<bigint>[]): MinimalJSRef<bigint>\nexport function pow(...numbers:RefOrValue<number>[]): MinimalJSRef<number>\nexport function pow(...args:any[]) {\n    return transform([...args], (...args) => args.slice(1).reduce((a, b) => a ** b, args[0]));\n}\n\n\n// @ts-ignore\nglobalThis.transform = transform;\n// @ts-ignore\nglobalThis.transformAsync = transformAsync;\n\n// @ts-ignore\nglobalThis.and = and;\n// @ts-ignore\nglobalThis.or = or;\n// @ts-ignore\nglobalThis.not = not;"],"names":["INSERT_MARK","Pointer","ReactiveValue","logger","Datex","PointerError","IterableHandler","handleError","KnownError","always","scriptOrJSTransform","vars","options","undefined","constructor","name","_allowAsync","Error","ptr","createSmartTransform","value_initialized","waiting_for_initial_async_transform","then","collapseTransformPointer","_collapseStatic","_returnWrapper","_allowAnyType","_rebindStaticToPointers","raw","Array","datex","join","collapseStatic","alwaysReturnWrapper","collapse","isStaticTransform","allowAnyType","val","collapseValue","delete","createOrGet","asyncAlways","transform","warn","reactiveFn","fn","args","map","arg","effect","handler","weakVariables","weakVariablesProxy","k","v","Object","entries","weakRef","WeakRef","defineProperty","get","deref","is_persistent","WEAK_EFFECT_DISPOSED","originalHandler","Symbol","dispose","for","dependencies","persistent_datex_transform","createTransform","transformAsync","createTransformAsync","iterable","mapFn","mapped","isRef","outType","$","Map","iterableHandler","onEntryRemoved","onNewEntry","set","onEmpty","clear","bindDisposable","spliceArray","Set","splice","length","i","push","getByValue","isTransform","filter","array","predicate","deps","filtered","observers","removeObserver","key","observer","unobserve","handleNewEntry","observe","onSplice","start","deleteCount","items","_deps","originalRef","filteredRef","triggerValueInitEvent","toggle","value","if_true","if_false","select","equals","a","b","selectProperty","property","object","not","and","values","or","add","reduce","sub","slice","mul","div","pow","globalThis"],"mappings":"AAMA,SAAiCA,WAAW,EAAgCC,OAAO,EAAEC,aAAa,EAAkHC,MAAM,QAAQ,iBAAiB;AACnP,SAASC,KAAK,QAAQ,WAAW;AACjC,SAASC,YAAY,QAAQ,oBAAoB;AACjD,SAASC,eAAe,QAAQ,8BAA8B;AAE9D,SAASC,WAAW,QAAQ,4BAA4B;AACxD,SAASC,UAAU,QAAQ,4BAA4B;AA0BvD,OAAO,SAASC,OAAOC,mBAAoE,EAAE,GAAGC,IAAU;IAEtG,IAAI,AAA8B,cAA9B,OAAOD,qBAAmC;QAC1C,IAAME,UAA2C,AAAkB,YAAlB,OAAOD,IAAI,CAAC,EAAE,GAAeA,IAAI,CAAC,EAAE,GAAGE,KAAAA;QAExF,IAAIH,AAAwC,mBAAxCA,oBAAoBI,WAAW,CAACC,IAAI,IAAuB,CAACH,SAASI,aACrE,MAAM,AAAIC,MAAM;QAEpB,IAAMC,MAAMjB,QAAQkB,oBAAoB,CAACT,qBAAqBG,KAAAA,GAAWA,KAAAA,GAAWA,KAAAA,GAAWD;QAC/F,IAAIA,SAASI,eAAe,CAACE,IAAIE,iBAAiB,IAAIF,IAAIG,mCAAmC,EACzF,OAAOH,IAAIG,mCAAmC,CAACC,IAAI,CAAC,IAAIC,yBAAyBL,KAAKN,SAASY,iBAAiBZ,SAASa,gBAAgBb,SAASc,eAAed,SAASe;QAE9K,IAAI,AAACT,IAAIE,iBAAiB,KAAIF,IAAIG,mCAAmC,EAIjE,OAAOE,yBAAyBL,KAAKN,SAASY,iBAAiBZ,SAASa,gBAAgBb,SAASc,eAAed,SAASe;QAHzH,MAAM,IAAItB,aAAa;IAK/B;IAEK,IAAIK,oBAAoBkB,GAAG,YAAYC,OACxC,OAAO,AAAC,CAAA,UAAUN,yBAAyB,MAAMO,MAAM,CAAC,QAAQ,EAAEpB,oBAAoBkB,GAAG,CAACG,IAAI,CAAC/B,aAAa,CAAC,CAAC,EAAEW,MAAK;IAGrHJ,YAAY,IAAIC,WAAW,6FAA6F;QACpH;QACA;KACH;AAET;AAGA,SAASe,yBAAyBL,GAAY,EAAEc,iBAAiB,CAAA,CAAK,EAAEC,sBAAsB,CAAA,CAAK,EAAEP,gBAAgB,CAAA,CAAK,EAAEC,0BAA0B,CAAA,CAAK;IAEvJ,IAAMO,WAAWF,kBAAkBd,IAAIiB,iBAAiB;IAMxD,IAJIT,iBACAR,IAAIkB,YAAY,CAAC,CAAA,IAGjBH,uBAAuB,CAACC,UACxB,OAAOhB;IAGX,IAAMmB,MAAMnC,cAAcoC,aAAa,CAACpB,KAAK,CAAA,GAAOgB;WAIpD,CAFIA,YAAUhB,IAAIqB,MAAM,IAEpBZ,2BACA,AAAMU,eAAenC,gBAIVmC,MAHApC,QAAQuC,WAAW,CAACH,OAOxBA;AAEf;AAgBA,OAAO,eAAeI,YAAeC,SAAwC,EAAE9B,OAA+B;IAC1G,IAAMM,MAAMjB,QAAQkB,oBAAoB,CAACuB,WAAW7B,KAAAA,GAAWA,KAAAA,GAAWA,KAAAA,GAAWD;IAOrF,OANI,CAACM,IAAIE,iBAAiB,IAAIF,IAAIG,mCAAmC,GACjE,MAAMH,IAAIG,mCAAmC,GAG7ClB,OAAOwC,IAAI,CAAC,8FAETzC,cAAcoC,aAAa,CAACpB;AACvC;AAoBA,OAAO,SAAS0B,WAA+CC,EAAwE;IACnI,OAAO,CAAC,GAAGC,OAA8BrC,OAAO,IAErCoC,MADeC,KAAKC,GAAG,CAACC,CAAAA,MAAO9C,cAAcoC,aAAa,CAACU,KAAK,CAAA,GAAM,CAAA;AAGrF;AAkCA,OAAO,SAASC,OAAoDC,OAAgG,EAAEC,aAAiB;IAEnL,IAAIjC;IAGJ,IAAIiC,eAAe;QACf,IAAMC,qBAAqB,CAAC;QAC5B,KAAK,IAAM,CAACC,GAAGC,EAAE,IAAIC,OAAOC,OAAO,CAACL,eAAgB;YAChD,IAAMM,UAAU,IAAIC,QAAQJ;YAC5BC,OAAOI,cAAc,CAACP,oBAAoBC,GAAG;gBAACO;oBAC5C,IAAMvB,MAAMoB,QAAQI,KAAK;oBACzB,IAAKxB,KAMA,OAAOA;oBAFV,MAFAnB,IAAI4C,aAAa,GAAG,CAAA,GACpB5C,IAAIqB,MAAM,IACJtC,QAAQ8D,oBAAoB;gBAGtC;YAAC;QACL;QACA,IAAMC,kBAAkBd;QACxBA,UAAW,IAAMc,gBAAgBZ;IACrC;IAKA,OAFAlC,AADAA,CAAAA,MAAMjB,QAAQkB,oBAAoB,CAAC+B,SAAgBrC,KAAAA,GAAW,CAAA,GAAM,CAAA,EAAI,EACpEiD,aAAa,GAAG,CAAA,GAEb;QACH,CAACG,OAAOC,OAAO,IAAED,OAAOE,GAAG,CAAC,kBAAkB;YAC1CjD,IAAI4C,aAAa,GAAG,CAAA,GACpB5C,IAAIqB,MAAM;QACd;QACA2B;YACIhD,IAAI4C,aAAa,GAAG,CAAA,GACpB5C,IAAIqB,MAAM;QACd;IACJ;AACJ;AAaA,OAAO,SAASG,UAA+C0B,YAAc,EAAE1B,SAAgC,EAAE2B,0BAAkC;IAC/I,OAAOnE,cAAcoC,aAAa,CAACrC,QAAQqE,eAAe,CAACF,cAAc1B,WAAW2B;AACxF;AAWA,OAAO,eAAeE,eAAoDH,YAAc,EAAE1B,SAAqC,EAAE2B,0BAAkC;IAC/J,OAAOnE,cAAcoC,aAAa,CAAC,MAAMrC,QAAQuE,oBAAoB,CAACJ,cAAc1B,WAAW2B;AACnG;AAGA,OAAO,SAAStB,IAA6C0B,QAAqB,EAAEC,KAAyE,EAAE9D,OAAsB;QAC7K+D;IAGJ,IAAIvE,MAAMF,aAAa,CAAC0E,KAAK,CAACH;QAG1B,IAAI7D,SAASiE,WAAW,OAAO;YAC3BF,SAASG,EAAE,IAAIC;YAEf,IAAMC,kBAAkB,IAAI1E,gBAAgBmE,UAAU;gBAClD1B,KAAK,CAACO,GAAED,IACGqB,MAAMpB,GAAED,GAAEoB;gBAErBQ,gBAAgB,CAAC3B,GAAED;oBACdsB,OAAyBpC,MAAM,CAACc;gBACrC;gBACA6B,YAAY,CAAC5B,GAAED,IAAM,AAACsB,OAAyBQ,GAAG,CAAC9B,GAAEC;gBACrD8B,SAAS,IAAM,AAACT,OAAyBU,KAAK;YAClD;YAEAjF,MAAMH,OAAO,CAACqF,cAAc,CAACX,QAAQK;QACzC,OAGK;YACDL,SAASG,EAAE,EAAE;YAGb,IAAMS,cAAcd,oBAAoBe,KAElCR,kBAAkB,IAAI1E,gBAAgBmE,UAAU;gBAClD1B,KAAK,CAACO,GAAED,IACGqB,MAAMpB,GAAED,GAAEoB;gBAErBQ,gBAAgB,CAAC3B,GAAED;oBACXkC,cAAa,AAACZ,OAAec,MAAM,CAACpC,GAAG,KACtC,OAAO,AAACsB,MAAc,CAACtB,EAAE;gBAClC;gBACA6B,YAAY,CAAC5B,GAAED;oBACVsB,MAAc,CAACtB,EAAE,GAAGC;gBACzB;gBACA8B,SAAS;oBACJT,OAAee,MAAM,GAAG;gBAC7B;YACJ;YAEAtF,MAAMH,OAAO,CAACqF,cAAc,CAACX,QAAQK;QACzC;WAMA,IAAIpE,SAASiE,WAAW,OAAO;QAC3BF,SAAS,IAAII;QACb,IAAIY,IAAI;QACR,KAAK,IAAMtD,OAAOoC,SACdE,OAAOQ,GAAG,CAACQ,GAAGjB,MAAMrC,KAAKsD,KAAKlB;IAEtC,OACK;QACDE,SAAS,EAAE;QACX,IAAIgB,IAAI;QACR,KAAK,IAAMtD,OAAOoC,SACdE,OAAOiB,IAAI,CAAClB,MAAMrC,KAAKsD,KAAKlB;IAEpC;IAIJ,IAAMvD,MAAMjB,QAAQ4F,UAAU,CAAClB;IAG/B,OAFIzD,OAAKA,CAAAA,IAAI4E,WAAW,GAAG,CAAA,CAAG,GAEvBnB;AACX;AAIA,OAAO,SAASoB,OAAaC,KAAe,EAAEC,SAA2D,EAAEC,IAA8B;IAErI,KAAI9F,MAAMF,aAAa,CAAC0E,KAAK,CAACoB,QA+DzB,OAAOA,MAAMD,MAAM,CAACE;IA/Da;QAElC,IAAME,WAAgBrB,EAAE,EAAE,GAGpBsB,YAAY,IAAIrB,OAChBsB,iBAAiB,CAACC;YACpB,IAAMC,WAAWH,UAAUxC,GAAG,CAAC0C;YAC3BC,aACAC,UAAUD,QAAQ,CAAC,EAAE,EAAEA,QAAQ,CAAC,EAAE,GAElCA,QAAQ,CAAC,EAAE,CAAChE,MAAM;QAE1B,GAEMW,UAAU,IAAI5C,gBAAqB0F,OAAO;YAC5CD,QAAQ,CAACzC,GAAED;gBAEPgD,eAAehD;gBAEf,IAAM8C,WAAW1F,OAAO,IAAMwF,UAAUD,KAAK,CAAC3C,EAAE,EAACA,GAAE2C,SAC7CO,WAAW;oBACbrD,QAAQuD,cAAc,CAACT,KAAK,CAAC3C,EAAE,EAACA,GAAE8C,SAAS9D,GAAG;gBAClD;gBAGA,OAFA+D,UAAUjB,GAAG,CAAC9B,GAAG;oBAAC8C;oBAAUI;iBAAS,GACrCG,QAAQP,UAAUI,WACXJ,SAAS9D,GAAG;YACvB;YACA4C,gBAAgB,CAAC3B,GAAED;gBACE8C,SAASV,MAAM,CAACpC,GAAG;YAExC;YACA6B,YAAY,CAAC5B,GAAED;gBACX8C,QAAQ,CAAC9C,EAAE,GAAGC;YAClB;YACAqD,UAAU,CAACC,OAAOC,aAAa,GAAGC;gBAC9BX,SAASV,MAAM,CAACmB,OAAOC,gBAAgBC;YAC3C;YACA1B,SAAS;gBACLe,SAAST,MAAM,GAAG;YACtB;QACJ;QAEA,IAAIQ,MAAM;YAEN,IAAMa,QAAQjC,EAAEoB,OACVc,cAAc5G,MAAMH,OAAO,CAAC4F,UAAU,CAACG,QACvCiB,cAAc7G,MAAMH,OAAO,CAAC4F,UAAU,CAACM;YACzCa,eACAN,QAAQK,OAAO;gBAEXC,YAAYE,qBAAqB,CAAC,CAAA,IAElCD,aAAaC,sBAAsB,CAAA;YAEvC;QACR;QAEA,OAAOf;IAEX;AAIJ;AASA,OAAO,SAASgB,OAAUC,KAAsB,EAAEC,OAAS,EAAEC,WAAa,IAAS;IAC/E,OAAO5E,UAAU;QAAC0E;KAAM,EAAE9D,CAAAA,IAAGA,IAAO+D,UAAaC;AAOrD;AAMA,OAAO,MAAMC,SAASJ,OAAO;AAQ7B,OAAO,SAASK,OAAYC,CAAc,EAAEC,CAAe;IACvD,OAAOhF,UAAU;QAAC+E;QAAGC;KAAE,EAAE,CAACD,GAAEC,IAAOtH,MAAMF,aAAa,CAACoC,aAAa,CAACmF,GAAG,CAAA,GAAM,CAAA,OAAUrH,MAAMF,aAAa,CAACoC,aAAa,CAACoF,GAAG,CAAA,GAAM,CAAA;AAGvI;AASA,OAAO,SAASC,eAA2CC,QAAmB,EAAEC,MAA6B;IACzG,OAAyBnF,UAAU;QAACkF;KAAS,EAAE,CAACtE,IAASuE,MAAM,CAAIvE,EAAE;AACzE;AAQA,OAAO,SAASwE,IAAIV,KAAyB;IACzC,OAAO1E,UAAU;QAAC0E;KAAM,EAAE9D,CAAAA,IAAG,CAACA;AAClC;AAOA,OAAO,SAASyE,IAAI,GAAGC,MAA4B;IAC/C,OAAOtF,UAAUsF,QAAQ,CAAC,GAAGA;QACzB,KAAK,IAAM1E,KAAK0E,OACZ,IAAI,CAAC1E,GAAG,OAAO,CAAA;QAEnB,OAAO,CAAA;IACX;AACJ;AAOA,OAAO,SAAS2E,GAAG,GAAGD,MAA4B;IAC9C,OAAOtF,UAAUsF,QAAQ,CAAC,GAAGA;QACzB,KAAK,IAAM1E,KAAK0E,OACZ,IAAI1E,GAAG,OAAO,CAAA;QAElB,OAAO,CAAA;IACX;AACJ;AAQA,OAAO,SAAS4E,IAAI,GAAGpF,IAAU;IAC7B,OAAOJ,UAAU;WAAII;KAAK,EAAE,CAAC,GAAGA,OAASA,KAAKqF,MAAM,CAAC,CAACV,GAAGC,IAAMD,IAAIC,GAAG;AAC1E;AASA,OAAO,SAASU,IAAI,GAAGtF,IAAU;IAC7B,OAAOJ,UAAU;WAAII;KAAK,EAAE,CAAC,GAAGA,OAASA,KAAKuF,KAAK,CAAC,GAAGF,MAAM,CAAC,CAACV,GAAGC,IAAMD,IAAIC,GAAG5E,IAAI,CAAC,EAAE;AAC1F;AASA,OAAO,SAASwF,IAAI,GAAGxF,IAAU;IAC7B,OAAOJ,UAAU;WAAII;KAAK,EAAE,CAAC,GAAGA,OAASA,KAAKqF,MAAM,CAAC,CAACV,GAAGC,IAAMD,IAAIC,GAAG;AAC1E;AASA,OAAO,SAASa,IAAI,GAAGzF,IAAU;IAC7B,OAAOJ,UAAU;WAAII;KAAK,EAAE,CAAC,GAAGA,OAASA,KAAKuF,KAAK,CAAC,GAAGF,MAAM,CAAC,CAACV,GAAGC,IAAMD,IAAIC,GAAG5E,IAAI,CAAC,EAAE;AAC1F;AASA,OAAO,SAAS0F,IAAI,GAAG1F,IAAU;IAC7B,OAAOJ,UAAU;WAAII;KAAK,EAAE,CAAC,GAAGA,OAASA,KAAKuF,KAAK,CAAC,GAAGF,MAAM,CAAC,CAACV,GAAGC,IAAMD,KAAKC,GAAG5E,IAAI,CAAC,EAAE;AAC3F;AAIA2F,WAAW/F,SAAS,GAAGA,WAEvB+F,WAAWlE,cAAc,GAAGA,gBAG5BkE,WAAWV,GAAG,GAAGA,KAEjBU,WAAWR,EAAE,GAAGA,IAEhBQ,WAAWX,GAAG,GAAGA","sourceRoot":"/lib/datex-core-js-legacy-0.3.15/","file":"functions.ts"}