{"version":3,"file":"519.421d02aa7b15af78.module.js","mappings":"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","sources":["webpack:///./public/lib/calculations.direct.ts","webpack:///./public/lib/calculations.shared.ts"],"sourcesContent":["import { combineLatest, from, Observable } from \"rxjs\";\nimport { map, switchMap, first, tap } from \"rxjs/operators\";\nimport { parseDate, tryParseDate, DfStrictParseFloat } from \"./calculations.shared\";\nimport resolveablePromise from \"@/lib/resolvablePromise\";\nimport type { BaseControlDefBase, BaseElementDefBase } from \"../pages/elements/BaseElementDef\";\nimport { CalculationSetting } from \"@cs-ts/calculation-setting\";\nimport { Operation } from \"@cs-ts/operation\";\nimport { Value } from \"@cs-ts/value\";\nimport { Constant } from \"@cs-ts/constant\";\nimport { BuiltinFunction } from \"@cs-ts/builtin-function\";\nimport { GroupListV2 } from \"@cs-ts/group-list-v2\";\nimport { Cast } from \"@cs-ts/cast\";\nimport type { CalculationContext } from \"../pages/elements/__CalculationContextInterface\";\nimport type FormDef from \"../pages/elements/FormDef\";\nimport { ICalculationSettingWithTerms } from \"@/cs-ts-bridge/ts/i-calculation-setting-with-terms\";\n//import generateGuid from \"@/lib/generateGuid\";\nimport type Moment from \"moment\";\n\nlet debug = false;\nexport function setDebug(i: boolean) {\n    debug = i;\n}\nexport function getDebug() {\n    return debug;\n}\nconst breakpoint = (context: InnerCalculationContext) => {\n    return debug || context.debug;\n};\n\nlet _momentPromise: Promise<typeof Moment>; // TODO - replace with Luxon?\nfunction fetchMoment() {\n    if (_momentPromise == null) {\n        _momentPromise = Promise.all([import(/* webpackChunkName: \"Moment\", webpackPrefetch: true */ \"moment\"), import(/* webpackChunkName: \"Moment\", webpackPrefetch: true */ \"moment-timezone\")] as const).then(result => result[0].default);\n    }\n    return _momentPromise;\n}\n\ntype ScalarCalculationResult = string | number | boolean | null | undefined;\ntype ListCalculationResult = ScalarCalculationResult[];\ntype CalculationResult = ScalarCalculationResult | ListCalculationResult;\n\n/** @returns {Promise<boolean>} */\nexport function resolveCalculationPromiseBool(calculation: CalculationSetting[], contextNode: BaseElementDefBase, debug?: boolean) {\n    const result = resolveCalculation(calculation, contextNode, debug, Type.List)();\n    return result\n        .pipe(\n            //@ts-ignore\n            map(value => (value as string[]).reduce((a, i) => a || parseBool(i) === 1, false)),\n            //@ts-ignore\n            first(),\n        )\n        .toPromise();\n}\n\ntype ValueOf<T> = T[keyof T];\ntype TypeValue = ValueOf<typeof Type>;\n/** @returns {Promise<string[]>} */\nexport function resolveCalculationPromise(calculation: CalculationSetting[], contextNode: BaseElementDefBase, debug?: boolean, type?: TypeValue) {\n    //@ts-ignore -- TODO\n    return resolveCalculation(calculation, contextNode, debug, type)().pipe(first()).toPromise();\n}\n\ntype InnerCalculationContext = CalculationContext & {\n    node: BaseElementDefBase;\n    rootCalc: CalculationSetting;\n    debug: boolean;\n    currentListRunningResult?: Observable<CalculationResult>[];\n    currentListIndex?: number[];\n    currentListItem?: CalculationResult[];\n};\n\n/** @returns {() => Observable<string[]>} */\nexport function resolveCalculation(calculationList: CalculationSetting[], contextNode: BaseElementDefBase, debug?: boolean, type?: TypeValue) {\n    //throw new Error(JSON.stringify(i));\n    const type2 = type != null ? type : Type.StringList;\n    if (calculationList == null || calculationList.length == 0) {\n        return () => from([[]]);\n    }\n    //const a = generateGuid();\n    return () => _resolveCalculation(calculationList[0], { node: contextNode, rootCalc: calculationList[0], ...contextNode.calculationContext, debug: debug || false }, type2) /*.pipe(tap((i) => {\n        console.log(`${a} - Trigger calc for ${contextNode.definition?.id} - ${calculationList[0].id}`);\n    }))*/;\n    //.pipe(\n    //    map(i => {\n    //        if (i == null) {\n    //            return i;\n    //        }\n    //        //debugger;\n    //        return i != null ? i.flat() : i;\n    //    }),\n    //);\n}\nexport default resolveCalculation;\n\nfunction _resolveCalculation(calculation: CalculationSetting, context: InnerCalculationContext, type: TypeValue): Observable<CalculationResult> {\n    const result = _resolveCalculationRaw(calculation, context, type);\n    //if (result.type) {\n    //    result.result = result.result.pipe(tap(i => { let a = calculation; debugger; }));\n    //} else {\n    //    result = result.pipe(tap(i => { let a = calculation; debugger; }));\n    //}\n    if (result == null) throw new Error(\"AZ\");\n    return isCalculationInnerResult(result)\n        ? convert(result, type, context).result\n        : result.pipe(\n              //switchMap(r => r),\n              switchMap(r => {\n                  const a = convert(r, type, context).result;\n                  //debugger;\n                  return a;\n              }),\n          );\n}\nfunction isCalculationInnerResult(i: CalculationInnerResult | CalculationPendingResult): i is CalculationInnerResult {\n    //@ts-expect-error\n    return !!i.type;\n}\nexport function _resolveCalculationRaw(calculation: CalculationSetting, context: InnerCalculationContext, type?: TypeValue): CalculationInnerResult | CalculationPendingResult {\n    const operatorFunc = operators[calculation.$type as keyof typeof operators];\n    const result = operatorFunc != null ? operatorFunc(calculation, context) : { result: from([\"TODO\"]), type: Type.StringList, calculation: calculation as CalculationSetting };\n    return result;\n}\nfunction _resolveCalculationTyped(calculation: CalculationSetting, context: InnerCalculationContext, type?: TypeValue): Observable<CalculationInnerResult> {\n    const result = _resolveCalculationRaw(calculation, context, type);\n    return isCalculationInnerResult(result)\n        ? result.result.pipe(\n              map(r => {\n                  if (result == null) throw new Error(\"C\");\n                  return { result: from([r]), type: result.type, calculation } as CalculationInnerResult;\n              }),\n          )\n        : result.pipe(\n              //switchMap(r => r),\n              map(r => {\n                  return { result: r.result, type: r.type, calculation } as CalculationInnerResult;\n              }),\n          );\n}\nfunction convert(result: CalculationInnerResult, toType: TypeValue, context: InnerCalculationContext) {\n    let convertItem: null | ((a: ScalarCalculationResult) => ScalarCalculationResult) = null;\n    if (result.type == null) throw new Error(\"Z:\" + JSON.stringify(result));\n    if (toType != null && toType[0] != null && result.type[0] != toType[0]) {\n        if (toType[0] == TypeType.String) {\n            convertItem = i => (i == null ? null : i.toString());\n        } else if (toType[0] == TypeType.Boolean) {\n            convertItem = i => (i == null ? null : parseBool(i));\n        } else if (toType[0] == TypeType.Decimal) {\n            if (result.type[0] == TypeType.Boolean) {\n                convertItem = i => (i == null ? null : i ? 1 : 0);\n            } else if (result.type[0] == TypeType.String) {\n                convertItem = i => (i == null ? null : DfParseFloatWithoutNan(i));\n            } else if (result.type[0] == null) {\n                convertItem = i => (i == null ? null : i === true ? 1 : i == false ? 0 : DfParseFloatWithoutNan(i));\n            } else {\n                throw new Error(`RT: ${result.type}`);\n            }\n        }\n    }\n    let convert = (i: CalculationResult) => i;\n    if (toType != null && toType[1] != null && result.type[1] != toType[1]) {\n        if (convertItem == null) {\n            convertItem = i => i;\n        }\n        if (toType[1] == TypeStructure.List) {\n            //@ts-ignore\n            convert = i => [convertItem(i)];\n        } else if (toType[1] == TypeStructure.Scalar) {\n            //@ts-ignore\n            convert = i => convertItem(i != null && i.length > 0 ? i[0] : null);\n        }\n    } else if (convertItem != null) {\n        if (result.type[1] == TypeStructure.List) {\n            //@ts-ignore\n            convert = i => i.map(convertItem);\n        } else if (result.type[1] == TypeStructure.Scalar) {\n            //@ts-ignore\n            convert = convertItem;\n        }\n    }\n    //if (result.calculation.function) {\n    //    throw new Error(JSON.stringify({ result, type: output}));\n    //}\n    //if (convert != null) {\n    //    convert.calculation = result.calculation;\n    //}\n    if (convertItem != null) {\n        //@ts-ignore\n        convertItem.calculation = result.calculation;\n    }\n    return {\n        type: toType,\n        result: result.result.pipe(\n            map(convert),\n            //map(i => [i, convert(i)]),\n            //tap(([b, a]) => {\n            //    if (context.debug) {\n            //        throw new Error(JSON.stringify(b) + \" > \" + JSON.stringify(a) + \" `` \" + JSON.stringify(result.type) + \" > \" + JSON.stringify(toType));\n            //    }\n            //}),\n            //map(([b, a]) => a),\n        ),\n        calculation: result.calculation,\n    };\n}\nconst valueOperator = \"MI.Common.DynamicForms.Controls.Settings.Value, DynamicForms\";\nconst operators: Record<string, (calculation: CalculationSetting, context: InnerCalculationContext) => CalculationInnerResult | CalculationPendingResult> = {\n    \"MI.Common.DynamicForms.Controls.Settings.CurrentListRunningResult, DynamicForms\"(calculation: CalculationSetting, context: InnerCalculationContext) {\n        const stack = context.currentListRunningResult || [];\n        const result = stack[stack.length - 1];\n        if (breakpoint(context)) debugger;\n        const calcResult: CalculationInnerResult = {\n            type: Type.Scalar,\n            result: result, // from([result]),\n            calculation,\n        };\n        return calcResult;\n    },\n    \"MI.Common.DynamicForms.Controls.Settings.CurrentListIndex, DynamicForms\"(calculation: CalculationSetting, context: InnerCalculationContext) {\n        const stack = context.currentListIndex || [];\n        const result = stack[stack.length - 1];\n        if (breakpoint(context)) debugger;\n        const calcResult: CalculationInnerResult = {\n            type: Type.DecimalScalar,\n            result: from([result]),\n            calculation,\n        };\n        return calcResult;\n    },\n    \"MI.Common.DynamicForms.Controls.Settings.CurrentListItem, DynamicForms\"(calculation: CalculationSetting, context: InnerCalculationContext) {\n        const stack = context.currentListItem || [];\n        const result = stack[stack.length - 1];\n        if (breakpoint(context)) debugger;\n        const calcResult: CalculationInnerResult = {\n            type: Type.Scalar,\n            result: from([result]),\n            calculation,\n        };\n        return calcResult;\n    },\n    \"MI.Common.DynamicForms.Controls.Settings.Operation, DynamicForms\"(calculation: Operation, context: InnerCalculationContext) {\n        if (breakpoint(context)) debugger;\n        switch (calculation.operator) {\n            case \"lcincludes\": //cspell:ignore lcincludes\n                return builtinFunc[\"IsListCasedIncludes\"](calculation, context);\n            case \"lincludes\": //cspell:ignore lincludes\n                return builtinFunc[\"IsListBasicIncludes\"](calculation, context);\n            case \"luincludes\": //cspell:ignore luincludes\n                return builtinFunc[\"IsListUncasedIncludes\"](calculation, context);\n            case \"lnincludes\": //cspell:ignore lnincludes\n                return builtinFunc[\"IsListNumericIncludes\"](calculation, context);\n            case \"ldincludes\": //cspell:ignore ldincludes\n                return builtinFunc[\"IsListDateIncludes\"](calculation, context);\n        }\n        return operation[calculation.operator!](calculation, context);\n    },\n    \"MI.Common.DynamicForms.Controls.Settings.BuiltinFunction, DynamicForms\"(calculation: BuiltinFunction, context: InnerCalculationContext) {\n        if (breakpoint(context)) debugger;\n        return builtinFunc[calculation.function as keyof typeof builtinFunc](calculation, context);\n    },\n    \"MI.Common.DynamicForms.Controls.Settings.Constant, DynamicForms\"(calculation: Constant, context: InnerCalculationContext) {\n        if (breakpoint(context)) debugger;\n        const calcResult: CalculationInnerResult = {\n            type: Type.StringScalar,\n            result: from([calculation.value]),\n            calculation,\n        };\n        return calcResult;\n    },\n    ////\"MI.Common.DynamicForms.Controls.Settings.NullConstant, DynamicForms\"(calculation: CalculationSetting, context: InnerCalculationContext) {\n    ////    if (breakpoint(context)) debugger;\n    ////    return {\n    ////        type: Type.StringScalar,\n    ////        result: from([null]),\n    ////        calculation,\n    ////    };\n    ////},\n    \"MI.Common.DynamicForms.Controls.Settings.Value, DynamicForms\"(calculation: Value, context: InnerCalculationContext) {\n        const id = calculation.id!;\n        const rootElement = context.node.calculationContext.rootElement!;\n        //if (calculation.extraDataKey && calculation.extraDataKey != \"null\") {\n        //    return makeBackendFunc(null)(calculation, context, null, calculation.id);\n        //}\n        function getValue(otherElements: BaseElementDefBase[]) {\n            return otherElements.map(i => (calculation.extraDataKey && calculation.extraDataKey != \"null\" ? getExtraData(i) : (i as BaseControlDefBase).effectiveValueList$()));\n        }\n        function getExtraData(i: BaseElementDefBase) {\n            const fallback = (extraCacheKey$?: Observable<string>) => combineLatest([from(context.getOrCreateFormId()), extraCacheKey$ ?? from([\"\"])]).pipe(switchMap(([formId, extraCacheKey]) => (makeBackendFunc(null)(calculation, context, null, formId + calculation.id + calculation.extraDataKey + extraCacheKey) as CalculationInnerResult).result.pipe(map(i => i as string[]))));\n            return i.effectiveExtraData$(calculation.extraDataKey!, fallback);\n        }\n        const result = rootElement.getElementsById$(id, context.node.vmId).pipe(\n            switchMap(otherElements =>\n                otherElements.length == 0\n                    ? from([[]])\n                    : combineLatest(getValue(otherElements)).pipe(\n                          tap(i => {\n                              if (breakpoint(context)) debugger;\n                          }),\n                          map(arraysOfOtherValues => Array.prototype.concat.apply([], arraysOfOtherValues)),\n                          tap(i => {\n                              if (breakpoint(context)) debugger;\n                          }),\n                      ),\n            ),\n        );\n        if (breakpoint(context)) debugger;\n        const calcResult: CalculationInnerResult = {\n            type: Type.StringList,\n            result,\n            calculation,\n        };\n        return calcResult;\n    },\n    \"MI.Common.DynamicForms.Controls.Settings.ExternalData, DynamicForms\"(calculation: CalculationSetting, context: InnerCalculationContext) {\n        const id = calculation.id!;\n        const rootElement = context.node.calculationContext.rootElement as FormDef;\n        const value = rootElement.externalData[id] ?? [];\n        if (breakpoint(context)) debugger;\n        const calcResult: CalculationInnerResult = {\n            type: Type.StringList,\n            result: from([value]),\n            calculation,\n        };\n        return calcResult;\n    },\n    \"MI.Common.DynamicForms.Controls.Settings.GroupListV2, DynamicForms\"(calculation: GroupListV2, context: InnerCalculationContext) {\n        const groupValue = calculation.group;\n        let group = null;\n        if (groupValue != null && groupValue.includes(\"`\")) {\n            group = groupValue.split(\"`\")[1];\n        }\n        const calcResult: CalculationInnerResult = {\n            type: Type.String,\n            result: from([group]),\n            calculation,\n        };\n        return calcResult;\n    },\n    \"MI.Common.DynamicForms.Controls.Settings.Cast, DynamicForms\"(calculation: Cast, context: InnerCalculationContext) {\n        const calc = calculation.input!;\n        const type = getTypeFromStr(calculation.dataType!, calculation.structureType!);\n        const calcResult: CalculationInnerResult = {\n            result: _resolveCalculation(calc, context, type),\n            type: type,\n            calculation,\n        };\n        return calcResult;\n    },\n};\nexport interface CalculationInnerResult {\n    result: Observable<CalculationResult>;\n    type: TypeValue;\n    calculation: CalculationSetting;\n}\nexport type CalculationPendingResult = Observable<CalculationInnerResult>;\n\nconst TypeType = {\n    String: 0,\n    Decimal: 1,\n    Boolean: 2,\n};\nconst TypeStructure = {\n    Scalar: 0,\n    List: 1,\n};\nconst Type = {\n    Undefined: [null, null],\n    Scalar: [null, TypeStructure.Scalar],\n    List: [null, TypeStructure.List],\n    String: [TypeType.String, null],\n    StringScalar: [TypeType.String, TypeStructure.Scalar],\n    StringList: [TypeType.String, TypeStructure.List],\n    Boolean: [TypeType.Boolean, null],\n    BooleanScalar: [TypeType.Boolean, TypeStructure.Scalar],\n    BooleanList: [TypeType.Boolean, TypeStructure.List],\n    Decimal: [TypeType.Decimal, null],\n    DecimalScalar: [TypeType.Decimal, TypeStructure.Scalar],\n    DecimalList: [TypeType.Decimal, TypeStructure.List],\n};\nconst getTypeFromStr = (dataType: string, structureType: string) => {\n    let typeType = null;\n    if (dataType == \"String\") {\n        typeType = TypeType.String;\n    } else if (dataType == \"Decimal\") {\n        typeType = TypeType.Decimal;\n    } else if (dataType == \"Boolean\") {\n        typeType = TypeType.Boolean;\n    }\n    let typeStructure = null;\n    if (structureType == \"List\") {\n        typeStructure = TypeStructure.List;\n    } else if (structureType == \"Scalar\") {\n        typeStructure = TypeStructure.Scalar;\n    }\n    return [typeType, typeStructure];\n};\nconst operation: Record<string, (c: ICalculationSettingWithTerms, c2: InnerCalculationContext) => CalculationInnerResult | CalculationPendingResult> = {\n    \"?:\"(calculation: ICalculationSettingWithTerms, context: InnerCalculationContext) {\n        const operandTerm = getTerm(calculation, context)(0, Type.BooleanScalar);\n        const branchTerms = [1, 2].map(i => getTypedTerm(calculation, context)(i, Type.Undefined)); // can't be lazy evaluated since that wouldn't get correct current-list-XX data\n        const result = operandTerm.pipe(\n            switchMap(resolvedTerm => {\n                const operand = parseBool(resolvedTerm as string);\n                const result = branchTerms[operand ? 0 : 1];\n                if (breakpoint(context)) debugger;\n                return result;\n            }),\n        );\n        //@ts-expect-error TODO?\n        result.calculation = calculation;\n        return result;\n    },\n    \"!\"(calculation: ICalculationSettingWithTerms, context: InnerCalculationContext) {\n        const result = getTerm(calculation, context)(0, Type.BooleanScalar).pipe(\n            map(resolvedTerm => {\n                const operand = parseBool(resolvedTerm as string);\n                if (breakpoint(context)) debugger;\n                return !operand;\n            }),\n        );\n        const calcResult: CalculationInnerResult = { result, type: Type.BooleanScalar, calculation: calculation as CalculationSetting };\n        return calcResult;\n    },\n};\nconst operationInners = {\n    STRING_STRING: {\n        config: {\n            input: Type.StringScalar,\n            output: Type.StringScalar,\n            multipleTerms: true,\n            _convert: (v: string | null) => (v == null ? \"\" : v),\n        },\n        \".\": (a: string | null, b: string | null) => operationInners.STRING_STRING.config._convert(a) + operationInners.STRING_STRING.config._convert(b),\n    },\n    STRING_LIST_BOOL: {\n        config: {\n            input: Type.StringList,\n            output: Type.BooleanScalar,\n            multipleTerms: false,\n            _func(c: boolean, s: (a: string, b: string) => number, f: (a: string | null, b: string | null) => boolean | null, a: (string | null)[], b: (string | null)[]) {\n                if (a == null || b == null) {\n                    return null;\n                }\n                if (a.length != b.length) {\n                    return !c;\n                }\n                a = a.sort(operationInners.STRING_LIST_BOOL.config._sort(s));\n                b = b.sort(operationInners.STRING_LIST_BOOL.config._sort(s));\n                for (let i = 0; i < a.length; i++) {\n                    const r = f(a[i], b[i]);\n                    if (r != c || r == null) {\n                        return r;\n                    }\n                }\n                return c;\n            },\n            _sort(f: (a: string, b: string) => number) {\n                return (a: string | null, b: string | null) => {\n                    return a == null ? (b == null ? 0 : -1) : b == null ? 1 : f(a, b);\n                };\n            },\n        },\n        eq: (a: (string | null)[], b: (string | null)[]) =>\n            operationInners.STRING_LIST_BOOL.config._func(\n                true,\n                (a, b) => (a == b ? 0 : a < b ? 1 : -1),\n                (a, b) => a == b,\n                a,\n                b,\n            ),\n        ne: (a: (string | null)[], b: (string | null)[]) =>\n            operationInners.STRING_LIST_BOOL.config._func(\n                false,\n                (a, b) => (a == b ? 0 : a < b ? 1 : -1),\n                (a, b) => a != b,\n                a,\n                b,\n            ),\n        ueq: (a: (string | null)[], b: (string | null)[]) =>\n            operationInners.STRING_LIST_BOOL.config._func(\n                true,\n                (a, b) => (a.toUpperCase() == b.toUpperCase() ? 0 : a.toUpperCase() < b.toUpperCase() ? 1 : -1),\n                (a, b) => a?.toUpperCase() == b?.toUpperCase(),\n                a,\n                b,\n            ),\n        une: (a: (string | null)[], b: (string | null)[]) =>\n            operationInners.STRING_LIST_BOOL.config._func(\n                false,\n                (a, b) => (a.toUpperCase() == b.toUpperCase() ? 0 : a.toUpperCase() < b.toUpperCase() ? 1 : -1),\n                (a, b) => a?.toUpperCase() != b?.toUpperCase(),\n                a,\n                b,\n            ),\n        deq: (a: (string | null)[], b: (string | null)[]) =>\n            operationInners.STRING_LIST_BOOL.config._func(\n                true,\n                // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain\n                (a, b) => (tryParseDate(a)?.getTime() == tryParseDate(b)?.getTime() ? 0 : tryParseDate(a)?.getTime()! < tryParseDate(b)?.getTime()! ? 1 : -1),\n                (a, b) => {\n                    const aD = tryParseDate(a);\n                    const bD = tryParseDate(b);\n                    return aD != null && bD != null ? aD.getTime() == bD.getTime() : null;\n                },\n                a,\n                b,\n            ),\n        dne: (a: (string | null)[], b: (string | null)[]) =>\n            operationInners.STRING_LIST_BOOL.config._func(\n                false,\n                // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain\n                (a, b) => (tryParseDate(a)?.getTime() == tryParseDate(b)?.getTime() ? 0 : tryParseDate(a)?.getTime()! < tryParseDate(b)?.getTime()! ? 1 : -1),\n                (a, b) => {\n                    const aD = tryParseDate(a);\n                    const bD = tryParseDate(b);\n                    return aD != null && bD != null ? aD.getTime() != bD.getTime() : null;\n                },\n                a,\n                b,\n            ),\n    },\n    STRING_BOOL: {\n        config: {\n            input: Type.StringScalar,\n            output: Type.BooleanScalar,\n            multipleTerms: false,\n            _func(f: (a: string, b: string) => boolean | null | undefined, a: string | null, b: string | null) {\n                if (a == null || b == null) {\n                    return null;\n                }\n                return f(a, b);\n            },\n        },\n        includes: (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => a.includes(b), a, b),\n        cincludes: (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => a.includes(b), a, b), //cspell:ignore cincludes\n        uincludes: (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => a.toUpperCase().includes(b.toUpperCase()), a, b), //cspell:ignore uincludes\n        \"=~\": (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => DfNewRegExpWithoutError(b)?.test(a), a, b),\n        \"=~c\": (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => DfNewRegExpWithoutError(b)?.test(a), a, b),\n        \"=~u\": (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => DfNewRegExpWithoutError(b, \"i\")?.test(a), a, b),\n        \"c<\": (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => a < b, a, b),\n        \"c<=\": (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => a <= b, a, b),\n        \"c>\": (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => a > b, a, b),\n        \"c>=\": (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => a >= b, a, b),\n        \"u<\": (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => a.toUpperCase() < b.toUpperCase(), a, b),\n        \"u<=\": (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => a.toUpperCase() <= b.toUpperCase(), a, b),\n        \"u>\": (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => a.toUpperCase() > b.toUpperCase(), a, b),\n        \"u>=\": (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => a.toUpperCase() >= b.toUpperCase(), a, b),\n\n        dincludes: (a: string | null, b: string | null) => operationInners.STRING_BOOL.config._func((a, b) => (tryParseDate(a)?.toString() || \"\").includes(tryParseDate(b)?.toString() || \"\"), a, b), //cspell:ignore dincludes\n        \"d<\": (a: string | null, b: string | null) =>\n            operationInners.STRING_BOOL.config._func(\n                (a: string | null, b: string | null) => {\n                    const ad = tryParseDate(a);\n                    const bd = tryParseDate(b);\n                    return ad == null || bd == null ? null : ad < bd;\n                },\n                a,\n                b,\n            ),\n        \"d<=\": (a: string | null, b: string | null) =>\n            operationInners.STRING_BOOL.config._func(\n                (a: string | null, b: string | null) => {\n                    const ad = tryParseDate(a);\n                    const bd = tryParseDate(b);\n                    return ad == null || bd == null ? null : ad <= bd;\n                },\n                a,\n                b,\n            ),\n        \"d>\": (a: string | null, b: string | null) =>\n            operationInners.STRING_BOOL.config._func(\n                (a: string | null, b: string | null) => {\n                    const ad = tryParseDate(a);\n                    const bd = tryParseDate(b);\n                    return ad == null || bd == null ? null : ad > bd;\n                },\n                a,\n                b,\n            ),\n        \"d>=\": (a: string | null, b: string | null) =>\n            operationInners.STRING_BOOL.config._func(\n                (a: string | null, b: string | null) => {\n                    const ad = tryParseDate(a);\n                    const bd = tryParseDate(b);\n                    return ad == null || bd == null ? null : ad >= bd;\n                },\n                a,\n                b,\n            ),\n        // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain\n        \"=~d\": (a: string | null, b: string | null) => DfNewRegExpWithoutError(tryParseDate(b)?.toString()!)?.test(tryParseDate(a)?.toString()!),\n    },\n    LIST_BOOL: {\n        config: {\n            input: Type.List,\n            output: Type.BooleanScalar,\n            multipleTerms: false,\n            _func(c: boolean, f: (a: ScalarCalculationResult, b: ScalarCalculationResult) => boolean | null, a: ListCalculationResult, b: ListCalculationResult) {\n                if (a.length != b.length) {\n                    return !c;\n                }\n                a = a.sort(operationInners.LIST_BOOL.config._sort);\n                b = b.sort(operationInners.LIST_BOOL.config._sort);\n                for (let i = 0; i < a.length; i++) {\n                    const aF = DfStrictParseFloat(a[i]);\n                    const bF = DfStrictParseFloat(b[i]);\n                    if (!isNaN(aF) && !isNaN(bF)) {\n                        if (f(aF, bF) != c) {\n                            return !c;\n                        }\n                    } else {\n                        const aD = tryParseDate(a[i]);\n                        const bD = tryParseDate(b[i]);\n                        if (aD != null && bD != null) {\n                            if (f(aD.getTime(), bD.getTime()) != c) {\n                                return !c;\n                            }\n                        } else {\n                            if (f(a[i]?.toString().toUpperCase().trim(), b[i]?.toString().toUpperCase().trim()) != c) {\n                                return !c;\n                            }\n                        }\n                    }\n                }\n                return c;\n            },\n            _sort(a: ScalarCalculationResult, b: ScalarCalculationResult) {\n                if (a == null || b == null) {\n                    return a == null ? (b == null ? 0 : -1) : 1;\n                }\n                const aF = DfStrictParseFloat(a);\n                const bF = DfStrictParseFloat(b);\n                if (isNaN(aF) || isNaN(bF)) {\n                    if (isNaN(aF) && isNaN(bF)) {\n                        const aD = tryParseDate(a);\n                        const bD = tryParseDate(b);\n                        if (aD != null && bD != null) {\n                            return aD < bD ? -1 : aD > bD ? 1 : 0;\n                        } else if (aD != null) {\n                            return 1;\n                        } else if (bD != null) {\n                            return -1;\n                        } else {\n                            const aU = a.toString().toUpperCase().trim();\n                            const bU = b.toString().toUpperCase().trim();\n                            return aU == bU ? 0 : aU < bU ? 1 : -1;\n                        }\n                    } else if (isNaN(aF)) {\n                        return -1;\n                    } else {\n                        return 1;\n                    }\n                } else {\n                    return aF - bF;\n                }\n            },\n        },\n        \"=\": (a: ListCalculationResult, b: ListCalculationResult) => operationInners.LIST_BOOL.config._func(true, (a, b) => a == b, a, b),\n        \"<>\": (a: ListCalculationResult, b: ListCalculationResult) => operationInners.LIST_BOOL.config._func(false, (a, b) => a != b, a, b),\n    },\n    SCALAR_BOOL: {\n        config: {\n            input: Type.Scalar,\n            output: Type.BooleanScalar,\n            multipleTerms: false,\n            _func(f: (a: NonNullable<ScalarCalculationResult | Date>, b: NonNullable<ScalarCalculationResult | Date>) => boolean | null, a: ScalarCalculationResult, b: ScalarCalculationResult) {\n                if (a == null || b == null || Number.isNaN(a) || Number.isNaN(b) || /^\\\\s*$/.test(a.toString()) || /^\\\\s*$/.test(b.toString())) {\n                    return null;\n                }\n                const aF = DfStrictParseFloat(a);\n                const bF = DfStrictParseFloat(b);\n                if (!isNaN(aF) && !isNaN(bF)) {\n                    return f(aF, bF);\n                }\n                const aD = tryParseDate(a);\n                const bD = tryParseDate(b);\n                if (aD != null && bD != null) {\n                    return f(aD, bD);\n                }\n                return f(a.toString().toUpperCase().trim(), b.toString().toUpperCase().trim());\n            },\n        },\n        \"<\": (a: ScalarCalculationResult, b: ScalarCalculationResult) => operationInners.SCALAR_BOOL.config._func((a, b) => a < b, a, b),\n        \"<=\": (a: ScalarCalculationResult, b: ScalarCalculationResult) => operationInners.SCALAR_BOOL.config._func((a, b) => a <= b, a, b),\n        \">\": (a: ScalarCalculationResult, b: ScalarCalculationResult) => operationInners.SCALAR_BOOL.config._func((a, b) => a > b, a, b),\n        \">=\": (a: ScalarCalculationResult, b: ScalarCalculationResult) => operationInners.SCALAR_BOOL.config._func((a, b) => a >= b, a, b),\n    },\n    DECIMAL_DECIMAL: {\n        config: {\n            input: Type.DecimalScalar,\n            output: Type.DecimalScalar,\n            multipleTerms: true,\n        },\n        \"/\": (a: number, b: number) => a / b,\n        \"*\": (a: number, b: number) => a * b,\n        \"+\": (a: number, b: number) => a + b,\n        \"-\": (a: number, b: number) => a - b,\n        \"%\": (a: number, b: number) => a % b,\n    },\n    DECIMAL_LIST_BOOL: {\n        config: {\n            input: Type.DecimalList,\n            output: Type.BooleanScalar,\n            multipleTerms: false,\n            _func(c: boolean, f: (a: number, b: number) => boolean | null, a: number[] | null, b: number[] | null) {\n                if (a == null || b == null || /^\\\\s*$/.test(a as unknown as string) || /^\\\\s*$/.test(b as unknown as string)) {\n                    return null;\n                }\n                if (a.length != b.length) {\n                    return !c;\n                }\n                a = a.sort(operationInners.DECIMAL_LIST_BOOL.config._sort);\n                b = b.sort(operationInners.DECIMAL_LIST_BOOL.config._sort);\n                for (let i = 0; i < a.length; i++) {\n                    if (f(a[i], b[i]) != c) {\n                        return !c;\n                    }\n                }\n                return c;\n            },\n            _sort(a: number | null, b: number | null) {\n                if (a == null || b == null) {\n                    return a == null ? (b == null ? 0 : -1) : 1;\n                }\n                return a == b ? 0 : a < b ? 1 : -1;\n            },\n        },\n        \"==\": (a: number[] | null, b: number[] | null) => operationInners.DECIMAL_LIST_BOOL.config._func(true, (a, b) => a == b, a, b),\n        \"!=\": (a: number[] | null, b: number[] | null) => operationInners.DECIMAL_LIST_BOOL.config._func(false, (a, b) => a != b, a, b),\n    },\n    DECIMAL_BOOL: {\n        config: {\n            input: Type.DecimalScalar,\n            output: Type.BooleanScalar,\n            multipleTerms: false,\n        },\n        \"n<\": (a: number, b: number) => a < b,\n        \"n<=\": (a: number, b: number) => a <= b,\n        \"n>\": (a: number, b: number) => a > b,\n        \"n>=\": (a: number, b: number) => a >= b,\n        nincludes: (a: number, b: number) => a?.toString().includes(b?.toString()), //cspell:ignore nincludes\n        \"=~n\": (a: number, b: number) => DfNewRegExpWithoutError(b?.toString())?.test(a?.toString()),\n    },\n    BOOL_BOOL: {\n        config: {\n            input: Type.BooleanScalar,\n            output: Type.BooleanScalar,\n            multipleTerms: true,\n        },\n        \"&&\": (a: boolean, b: boolean) => a && b,\n        \"||\": (a: boolean, b: boolean) => a || b,\n    },\n} as const;\nfor (const typeType of Object.keys(operationInners) as (keyof typeof operationInners)[]) {\n    const { input, output, multipleTerms } = operationInners[typeType].config;\n    for (const key of Object.keys(operationInners[typeType]).filter(i => i != \"config\")) {\n        operation[key] = (calculation, context) => {\n            const terms = getAllTerms(calculation, context, input);\n            const a = terms.length > 0 ? combineLatest(terms) : from([[] as ListCalculationResult]);\n            const result = a.pipe(\n                map(resolvedTerms => {\n                    //throw new Error(JSON.stringify(resolvedTerms) + ' -- '+ JSON.stringify(input)+' -- '+JSON.stringify(terms));\n                    if (multipleTerms ? resolvedTerms.length >= 2 : resolvedTerms.length == 2) {\n                        //@ts-ignore -- TODO\n                        const r = resolvedTerms.reduce(operationInners[typeType][key]);\n                        if (breakpoint(context)) debugger;\n                        return r;\n                    } else {\n                        if (breakpoint(context)) debugger;\n                        return typeType == \"BOOL_BOOL\" ? false : null;\n                    }\n                }),\n            );\n            const calcResult: CalculationInnerResult = { result, type: output, calculation: calculation as CalculationSetting };\n            return calcResult;\n        };\n    }\n}\nconst makeListBuiltinFunc = <InputType extends CalculationResult, OutputType extends CalculationResult>(inputType: TypeValue, outputType: TypeValue, func: (resolvedTerms: InputType[], context: InnerCalculationContext, calculation: CalculationSetting) => OutputType) => makeListBuiltinAsyncFunc<InputType, OutputType>(inputType, outputType, (a, b, c) => Promise.resolve(func(a, b, c)));\nconst makeListBuiltinAsyncFunc =\n    <InputType extends CalculationResult, OutputType extends CalculationResult>(inputType: TypeValue, outputType: TypeValue, func: (resolvedTerms: InputType[], context: InnerCalculationContext, calculation: CalculationSetting) => Promise<OutputType>) =>\n    (calculation: CalculationSetting, context: InnerCalculationContext): CalculationInnerResult => {\n        const termedCal = calculation as ICalculationSettingWithTerms;\n        const a = (termedCal.terms ?? []).length == 0 ? from([[] as CalculationResult[]]) : combineLatest(...getAllTerms(termedCal, context, inputType));\n        const result = a.pipe(\n            tap(i => {\n                if (breakpoint(context)) debugger;\n            }),\n            switchMap(resolvedTerms => {\n                return func(resolvedTerms as InputType[], context, calculation);\n            }),\n            tap(i => {\n                if (breakpoint(context)) debugger;\n            }),\n        );\n        return { result, type: outputType, calculation: calculation };\n    };\nconst makeArgsBuiltinFunc = <InputTypes extends CalculationResult[], OutputType extends CalculationResult>(inputTypes: TypeValue[], outputType: TypeValue, func: (resolvedTerms: InputTypes, context: InnerCalculationContext, calculation: CalculationSetting) => OutputType) => makeArgsBuiltinAsyncFunc<InputTypes, OutputType>(inputTypes, outputType, (a, b, c) => Promise.resolve(func(a, b, c)));\nconst makeArgsBuiltinAsyncFunc =\n    <InputTypes extends CalculationResult[], OutputType extends CalculationResult>(inputTypes: TypeValue[], outputType: TypeValue, func: (resolvedTerms: InputTypes, context: InnerCalculationContext, calculation: CalculationSetting) => Promise<OutputType> | Observable<OutputType>) =>\n    (calculation: CalculationSetting, context: InnerCalculationContext): CalculationInnerResult => {\n        const termedCal = calculation as ICalculationSettingWithTerms;\n        const result = (inputTypes.length == 0 ? from([[]]) : combineLatest(getTerms(termedCal, context, ...inputTypes))).pipe(\n            tap(i => {\n                if (breakpoint(context)) debugger;\n            }),\n            switchMap(resolvedTerms => {\n                return func(resolvedTerms as InputTypes, context, calculation);\n            }),\n            tap(i => {\n                if (breakpoint(context)) debugger;\n            }),\n        );\n        return { result, type: outputType, calculation: calculation as CalculationSetting };\n    };\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst cache: Record<string, [any, number]> = {};\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst backendQueue: [any, any, string][] = [];\nlet backendQueueTimerId: null | ReturnType<typeof setTimeout> = null;\nexport function DFClearBackendCache() {\n    for (const key in cache) {\n        delete cache[key];\n    }\n    backendQueue.splice(0, backendQueue.length);\n    backendQueueTimerId = null;\n}\n//@ts-expect-error\nfunction isTermedCal(i: CalculationSetting): i is ICalculationSettingWithTerms {\n    return !!(i as ICalculationSettingWithTerms).terms;\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ExtendedBackendResult = Omit<CalculationInnerResult, \"result\"> & { result: Observable<{ result: any; otherData: any; outerResult: any; resp: any }> };\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const makeBackendFunc =\n    (type: string | null, cachePerOperation?: boolean) =>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (calculation: CalculationSetting, context: InnerCalculationContext, otherData: Observable<Record<string, any>> | null | undefined, cacheKey: any | null): ExtendedBackendResult | CalculationInnerResult => {\n        const elementId = context.node.id;\n        const elementPath = context.node.getElementPathIndexFromRoot();\n        // TODO better implementation\n        const rootCalc = context.rootCalc;\n        const elementCalcs = context.node.definition.settings.calculations;\n        const calculationId = Object.keys(elementCalcs).find(i => elementCalcs[i][0] == rootCalc);\n        const operationId = (calculation as Value).operationId ?? calculation.id;\n        function walk(el: CalculationSetting): number[] | null {\n            if (el == calculation) {\n                return [];\n            } else if (isTermedCal(el) && (el.terms?.length ?? 0) >= 0) {\n                for (let i = 0; i < el.terms!.length; i++) {\n                    const wR = walk(el.terms![i]);\n                    if (wR != null) {\n                        wR.unshift(i);\n                        return wR;\n                    }\n                }\n                return null;\n            } else {\n                return null;\n            }\n        }\n        const operationPath = walk(rootCalc);\n        const loopContextO = JSON.parse(\n            JSON.stringify({\n                __currentListIndex: (context.currentListIndex || []).map(i => i?.toString()),\n                __currentListItem: (context.currentListItem || []).map(i => JSON.stringify(i)),\n            }),\n        );\n        const operationCacheKey = cachePerOperation ? { elementId, elementPath, calculationId, operationPath, operationId } : {};\n        const operationDependencies = ((calculation as BuiltinFunction).dependencies ?? []).map(dependency => _resolveCalculation({ $type: valueOperator, id: dependency.id, operationId: dependency.operationId, extraDataKey: dependency.extraDataKey } as Value /* TODO refactor? */, context, Type.StringList).pipe(map(value => ({ ...dependency, value }))));\n        const otherDataO = otherData ?? from([{}]);\n        const operationDependenciesO = operationDependencies.length == 0 ? from([[]]) : combineLatest(operationDependencies);\n        const currentListRunningResultO = context.currentListRunningResult == null || context.currentListRunningResult.length == 0 ? from([[]]) : context.currentListRunningResult.length == 1 ? context.currentListRunningResult[0] : combineLatest(context.currentListRunningResult);\n        const result = combineLatest([otherDataO, operationDependenciesO, currentListRunningResultO]).pipe(\n            switchMap(async ([otherData, extraValues, currentListRunningResult]) => {\n                const loopContext = {\n                    ...loopContextO,\n                    __currentListRunningResult: [JSON.stringify(currentListRunningResult)],\n                };\n                let resp = null;\n                const innerCacheKey = cacheKey ? JSON.stringify({ cacheKey, otherData, extraValues, loopContext, ...operationCacheKey }) : null!;\n                //if (innerCacheKey == null) debugger;\n                if (cacheKey && innerCacheKey in cache && cache[innerCacheKey][1] > Date.now() - 5 * 60 * 1000) {\n                    resp = cache[innerCacheKey][0];\n                } else {\n                    const formNode = context.node.getRoot() as FormDef;\n                    const extraData = { ...loopContext };\n                    for (const extraValue of extraValues) {\n                        if (extraValue.extraDataKey == null || extraValue.extraDataKey == \"\" || extraValue.extraDataKey == \"null\") {\n                            extraData[extraValue.id] = extraValue.value;\n                        }\n                    }\n                    const operationData = {\n                        CalculationId: calculationId,\n                        OperationId: operationId,\n                        OperationPath: operationPath,\n                        ExtraData: extraData,\n                        ...otherData,\n                    };\n                    const data = {\n                        formName: formNode.formName,\n                        formVersion: formNode.formVersion,\n                        formHash: formNode.formHash,\n                        segment: null,\n                        skipForm: true,\n                        noWrite: true,\n                        asAdmin: context.adminReview || false, // TODO\n                        inPreview: context.adminPreview || false, // TODO\n                        testMode: context.testMode || false, // TODO\n                        target: elementId,\n                        targetPathArray: elementPath,\n                        type: type || \"resolveCalculation\", // TODO magic string\n                        data: JSON.stringify(operationData),\n                    };\n                    // TODO - this fails for preview since it fetches the last published\n                    try {\n                        if (context.bulkInvoke) {\n                            resp = resolveablePromise();\n                            backendQueue.push([data, resp, innerCacheKey]);\n                            if (backendQueueTimerId == null) {\n                                backendQueueTimerId = setTimeout(() => resolveBackendQueue(context), 0);\n                            }\n                        } else {\n                            // It is important that nothing awaits prior to this for caching to work\n                            resp = context\n                                .urlFetcher(\"invokeDraft\", { formId: formNode.formId! })\n                                .then(url =>\n                                    context.fetchXrsf(url, {\n                                        method: \"POST\",\n                                        headers: {\n                                            \"Content-Type\": \"application/json\",\n                                        },\n                                        body: JSON.stringify(data),\n                                    }),\n                                )\n                                .then(async resp => {\n                                    const outerResult = await (await resp).json();\n                                    const result = JSON.parse(outerResult.Result);\n                                    //console.log(\"R: \"+outerResult.Result);\n                                    return { outerResult, result };\n                                });\n                        }\n                        if (cacheKey) {\n                            cache[innerCacheKey] = [resp, Date.now()];\n                        }\n                    } catch (e) {\n                        console.log(e);\n                        if (breakpoint(context)) {\n                            debugger;\n                            throw e;\n                        }\n                    }\n                }\n                let result = null;\n                let outerResult = null;\n                try {\n                    ({ result, outerResult } = await resp); // Yes, these () are required...\n                } catch (e) {\n                    console.log(e);\n                    if (breakpoint(context)) {\n                        debugger;\n                        throw e;\n                    }\n                }\n                if (breakpoint(context)) debugger;\n                //console.log(\"FR: \"+JSON.stringify(result));\n                if (type != null) {\n                    result = {\n                        result,\n                        otherData,\n                        outerResult,\n                        resp,\n                    };\n                } else if (result == null || result.length == null) {\n                    return [];\n                }\n                return result;\n            }),\n        );\n        return { result, type: Type.List, calculation: calculation as CalculationSetting };\n    };\n\nasync function resolveBackendQueue(context: InnerCalculationContext) {\n    backendQueueTimerId = null;\n    const formNode = context.node.getRoot() as FormDef;\n    const currentQueue = [...backendQueue];\n    backendQueue.splice(0, backendQueue.length);\n    type QueueKey = { formName: string; formVersion: string; formHash: string; skipForm: boolean; noWrite: boolean; asAdmin: boolean; inPreview: boolean; testMode: boolean };\n    const groupedQueue = currentQueue.reduce(\n        (a, c) => {\n            const item = c[0];\n            const key = {\n                formName: item.formName,\n                formVersion: item.formVersion,\n                formHash: item.formHash,\n                skipForm: item.skipForm,\n                noWrite: item.noWrite,\n                asAdmin: item.asAdmin,\n                inPreview: item.inPreview,\n                testMode: item.testMode,\n            };\n            const keyS = JSON.stringify(key);\n            if (!(keyS in a)) {\n                a[keyS] = {\n                    ...key,\n                    invokes: [],\n                };\n            }\n            a[keyS].invokes.push(c);\n            return a;\n        },\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- TODO\n        {} as Record<string, QueueKey & { invokes: any[] }>,\n    );\n    for (const group of Object.values(groupedQueue)) {\n        // eslint-disable-next-line prefer-const\n        let groupSize = 200;\n        for (let invokeIndexStart = 0; invokeIndexStart < group.invokes.length; invokeIndexStart += groupSize) {\n            const request = {\n                ...group,\n                invokes: group.invokes.slice(invokeIndexStart, invokeIndexStart + groupSize).map(i => ({\n                    segment: i[0].segment,\n                    target: i[0].target,\n                    targetPathArray: i[0].targetPathArray,\n                    type: i[0].type,\n                    data: i[0].data,\n                })),\n            };\n            const thisInvokeIndexStart = invokeIndexStart;\n            context\n                .urlFetcher(\"invokeDraftBulk\", { formId: formNode.formId! })\n                .then(url => {\n                    return context.fetchXrsf(url, {\n                        method: \"POST\",\n                        headers: {\n                            \"Content-Type\": \"application/json\",\n                        },\n                        body: JSON.stringify(request),\n                    });\n                })\n                .then(async resp => {\n                    const outerResults = await (await resp).json();\n                    if (outerResults == null || outerResults.Result == null) {\n                        throw new Error(JSON.stringify(outerResults));\n                    }\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    return outerResults.Result.map((outerResult: any) => {\n                        const result = JSON.parse(outerResult);\n                        return { outerResult, result };\n                    });\n                })\n                .then(result => {\n                    for (let i = 0; i < result.length; i++) {\n                        group.invokes[thisInvokeIndexStart + i][1].resolve(result[i]);\n                    }\n                });\n        }\n    }\n}\n\nconst makeSortFunc =\n    (reverse: boolean) =>\n    (calculation: CalculationSetting, context: InnerCalculationContext): CalculationInnerResult => {\n        const termedCal = calculation as ICalculationSettingWithTerms;\n        const r = (termedCal.terms ?? []).map(t => _resolveCalculationRaw(t, context, Type.List) as CalculationInnerResult);\n        const rTypes = r.map(i => i.type);\n        const rType =\n            rTypes.some(i => i[0] == TypeType.String) || rTypes.every(i => i[0] == null)\n                ? Type.StringList\n                : rTypes.some(i => i[0] == TypeType.Decimal)\n                  ? Type.DecimalList\n                  : rTypes.some(i => i[0] == TypeType.Boolean)\n                    ? Type.BooleanList\n                    : (() => {\n                          throw new Error(JSON.stringify(rTypes));\n                      })();\n        //throw new Error(JSON.stringify(rTypes)+\" => \"+JSON.stringify(rType));\n        const result = (r.length == 0 ? from([[]]) : combineLatest(r.map(i => i.result))).pipe(\n            tap(i => {\n                if (breakpoint(context)) debugger;\n            }),\n            map(resolvedTerms => {\n                let result = resolvedTerms.flat();\n                if (breakpoint(context)) debugger;\n                if (rType[0] == TypeType.String || rType[0] == null) {\n                    const possibleDecimalResult = result.map(i => [DfStrictParseFloat(i as string), i] as const);\n                    if (possibleDecimalResult.every(i => !isNaN(i[0]))) {\n                        result = possibleDecimalResult.sort((a, b) => (a[0] == b[0] ? 0 : a[0] < b[0] ? -1 : 1)).map(i => i[1]);\n                    } else {\n                        const possibleBooleanResult = result.map(i => [parseBool(i as string), i] as const);\n                        if (possibleBooleanResult.every(i => i[0] != null)) {\n                            result = possibleBooleanResult.sort((a, b) => (a[0] == b[0] ? 0 : a[0]! < b[0]! ? -1 : 1)).map(i => i[1]);\n                        } else {\n                            const possibleDateResult = result.map(i => [tryParseDate(i as string), i] as const);\n                            if (possibleDateResult.every(i => i[0] != null)) {\n                                result = possibleDateResult.sort((a, b) => (a[0]!.getTime() == b[0]!.getTime() ? 0 : a[0]! < b[0]! ? -1 : 1)).map(i => i[1]);\n                            } else {\n                                result.sort();\n                            }\n                        }\n                    }\n                } else if (rType[0] == TypeType.Decimal) {\n                    result = result\n                        .map(i => [DfParseFloatWithoutNan(i as string), i] as const)\n                        .sort((a, b) => a[0] - b[0])\n                        .map(i => i[1]);\n                } else if (rType[0] == TypeType.Boolean) {\n                    result.sort();\n                }\n                if (reverse) {\n                    result.reverse();\n                }\n                return result;\n            }),\n            tap(i => {\n                if (breakpoint(context)) debugger;\n            }),\n        );\n        return { result, type: rType, calculation: calculation as CalculationSetting };\n    };\n\nconst makeListIncludesFunc = (isBasic: boolean, isNumeric: boolean, isCaseSensitive: boolean, isDate: boolean) =>\n    makeListBuiltinFunc<ListCalculationResult, boolean | null>(Type.List, Type.BooleanScalar, (resolvedTerms, context) => {\n        if (breakpoint(context)) debugger;\n        if (resolvedTerms.length < 2) {\n            return null!;\n        }\n        const set = resolvedTerms.shift()!;\n        const firstListIsNumeric = set.map(i => DfStrictParseFloat(i)).every(ii => !isNaN(ii));\n        const secondListIsNumeric = resolvedTerms\n            .flat()\n            .map(j => DfStrictParseFloat(j))\n            .every(jj => !isNaN(jj));\n\n        const firstListIsDate = set.map(i => tryParseDate(i)).every(ii => ii != null);\n        const secondListIsDate = resolvedTerms\n            .flat()\n            .map(j => tryParseDate(j))\n            .every(jj => jj != null);\n\n        if (firstListIsNumeric && secondListIsNumeric && (isBasic || isNumeric)) {\n            return resolvedTerms.reduce((v, p) => v && p.every(i => set.map(i => DfStrictParseFloat(i)).includes(DfStrictParseFloat(i))), true);\n        } else if (firstListIsDate && secondListIsDate && (isBasic || isDate)) {\n            return resolvedTerms.reduce((v, p) => v && p.every(i => set.map(i => tryParseDate(i)?.getTime()).includes(tryParseDate(i)?.getTime())), true);\n        } else if (isBasic) {\n            return resolvedTerms.reduce((v, p) => v && p.every(i => set.map(i => i?.toString().toUpperCase().trim()).includes(i?.toString().toUpperCase().trim())), true);\n        } else if (!isNumeric && !isDate) {\n            if (isCaseSensitive) {\n                return resolvedTerms.reduce((v, p) => v && p.every(i => set.includes(i)), true);\n            } else {\n                return resolvedTerms.reduce((v, p) => v && p.every(i => set.map(i => i?.toString().toUpperCase()).includes(i?.toString().toUpperCase())), true);\n            }\n        }\n        return null;\n    });\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst builtinFunc: Record<string, (calculation: CalculationSetting, context: InnerCalculationContext, otherData?: Observable<Record<string, any>>) => CalculationInnerResult> = {\n    Sum: makeListBuiltinFunc<number[], number>(Type.DecimalList, Type.DecimalScalar, (resolvedTerms, context) => {\n        const flattenTerms = resolvedTerms.flat();\n        if (breakpoint(context)) debugger;\n        return flattenTerms.length == 0 ? 0 : flattenTerms.reduce((a, b) => a + b);\n    }),\n    Concat: makeListBuiltinFunc<string[], string>(Type.StringList, Type.StringScalar, (resolvedTerms, context) => {\n        const flattenTerms = resolvedTerms.flat();\n        if (breakpoint(context)) debugger;\n        return flattenTerms.length == 0 ? \"\" : flattenTerms.map(v => (v == null ? \"\" : v)).reduce((a, b) => a + b);\n    }),\n    StringLength: makeArgsBuiltinFunc<[string], number>([Type.StringScalar], Type.DecimalScalar, ([input], context) => {\n        if (breakpoint(context)) debugger;\n        return input?.length;\n    }),\n    Substring: makeArgsBuiltinFunc<[string | null, number | null, string | null], string | null>([Type.StringScalar, Type.DecimalScalar, Type.StringScalar], Type.StringScalar, ([input, index, lengthS], context) => {\n        //console.log(`I: ${input}, I: ${index}, L: ${lengthS}`);\n        if (breakpoint(context)) debugger;\n        if (input == null) return null;\n        let length = lengthS == null ? null : DfParseFloat(lengthS); // to avoid null being converted to 0\n        index = index == null || isNaN(index) ? 0 : Math.round(index);\n        length = length == null || isNaN(length) ? null : Math.round(length);\n        if (length != null && length < 0) {\n            return null;\n        }\n        if (index > 0) index--; // one indexed\n        if (index < 0) index = input.length + index;\n        //console.log(`I: ${input}, I: ${index}, L: ${length}`);\n        if (index >= input.length || index < 0) {\n            //console.log(\"Z2\");\n            return null;\n        }\n        let result;\n        if (length == null) {\n            result = input.substring(index);\n        } else {\n            result = input.substring(index, index + length);\n        }\n        //console.log(`I: ${input}, I: ${index}, L: ${length} => R: ${result}`);\n        return result;\n    }),\n    StringIndexOf: makeArgsBuiltinFunc<[string | null, string | null], number | null>([Type.StringScalar, Type.StringScalar], Type.DecimalScalar, ([input, searchTerm], context) => {\n        if (breakpoint(context)) debugger;\n        if (input == null || searchTerm == null) return null;\n        let result = input.indexOf(searchTerm);\n        if (result >= 0) result++;\n        return result;\n    }),\n    StringStartsWith: makeArgsBuiltinFunc<[string | null, string | null], boolean | null>([Type.StringScalar, Type.StringScalar], Type.BooleanScalar, ([input, searchTerm], context) => {\n        if (breakpoint(context)) debugger;\n        if (input == null || searchTerm == null) return null;\n        return input.startsWith(searchTerm);\n    }),\n    StringEndsWith: makeArgsBuiltinFunc<[string | null, string | null], boolean | null>([Type.StringScalar, Type.StringScalar], Type.BooleanScalar, ([input, searchTerm], context) => {\n        if (breakpoint(context)) debugger;\n        if (input == null || searchTerm == null) return null;\n        return input.endsWith(searchTerm);\n    }),\n    StringReplace: makeArgsBuiltinFunc<[string | null, string | null, string | null], string | null>([Type.StringScalar, Type.StringScalar, Type.StringScalar], Type.StringScalar, ([input, search, replacement], context) => {\n        if (breakpoint(context)) debugger;\n        if (input == null || search == null) return null;\n        if (search.length == 0) return input;\n        //@ts-expect-error\n        return input.replaceAll(new DFReplace(search, true, true), replacement ?? \"\");\n    }),\n    ExtendedStringReplace: makeArgsBuiltinFunc<[string | null, string | null, string | null, string | null, boolean | null, boolean | null], string | null>([Type.StringScalar, Type.StringScalar, Type.StringScalar, Type.StringScalar, Type.BooleanScalar, Type.BooleanScalar], Type.StringScalar, ([input, search, replacement, searchType, ignoreCase, replaceAll], context) => {\n        if (breakpoint(context)) debugger;\n        if (input == null || search == null) return null;\n        if (search.length == 0) return input;\n        if (searchType?.toUpperCase() == \"REGEX\") {\n            const searchRegex = DfNewRegExpWithoutError(search, (replaceAll ? \"g\" : \"\") + (ignoreCase ? \"i\" : \"\"));\n            return searchRegex == null ? null : input[replaceAll ? \"replaceAll\" : \"replace\"](searchRegex, replacement ?? \"\");\n        } else {\n            return input.replace(new DFReplace(search, ignoreCase ?? false, replaceAll ?? false), replacement ?? \"\");\n        }\n    }),\n    ToCase: makeArgsBuiltinFunc<[string | null | undefined, string | null | undefined], string | null | undefined>([Type.StringScalar, Type.StringScalar], Type.StringScalar, ([input, type], context) => {\n        if (breakpoint(context)) debugger;\n        if (type?.toUpperCase() == \"UPPERCASE\" || type?.toUpperCase() == \"UPPER\") {\n            return input?.toUpperCase();\n        } else if (type?.toUpperCase() == \"LOWERCASE\" || type?.toUpperCase() == \"LOWER\") {\n            return input?.toLowerCase();\n        } else if (type?.toUpperCase() == \"TITLECASE\" || type?.toUpperCase() == \"TITLE\") {\n            return input?.replace(/\\b\\w+\\b/g, t => (t.length < 2 ? t.toUpperCase() : /^[A-Z]+$/.test(t) ? t : t.slice(0, 1).toUpperCase() + t.slice(1, t.length).toLowerCase()));\n        } else {\n            return input;\n        }\n    }),\n    StringSplit: makeArgsBuiltinFunc<[string | null | undefined, string | null | undefined], string[] | null | undefined>([Type.StringScalar, Type.StringScalar], Type.StringList, ([input, splitter], context) => {\n        if (breakpoint(context)) debugger;\n        if (input == null || splitter == null) return null!;\n        if (splitter.length == 0) return [input];\n        //console.log(`I: ${input}, S: ${splitter}`);\n        const result = DFStringSplitLikeBackend(input, splitter, null, null);\n        //console.log(`I: ${input}, S: ${splitter} => R: ${result}`);\n        return result;\n    }),\n    ExtendedStringSplit: makeArgsBuiltinFunc<[string | null, string | null, string | null, string | null], string[] | null>([Type.StringScalar, Type.StringScalar, Type.StringScalar, Type.StringScalar], Type.StringList, ([input, splitter, splitterType, countS], context) => {\n        //console.log(`I: ${input}, S: ${splitter}, C: ${countS}, T: ${splitterType}`);\n        if (breakpoint(context)) debugger;\n        if (input == null || splitter == null) return null;\n        let count = countS == null ? null : DfParseFloat(countS); // to avoid null being converted to 0\n        count = count == null || isNaN(count) ? null : Math.round(count);\n        if (count == 0) return [];\n        if (splitter.length == 0) return [input];\n        const result = DFStringSplitLikeBackend(input, splitter, splitterType, count);\n        //console.log(`I: ${input}, S: ${splitter}, C: ${count}, T: ${splitterType} => R: ${result}`);\n        return result;\n    }),\n    StringEscape: makeArgsBuiltinFunc<[string | null, string | null], string | null>([Type.StringScalar, Type.StringScalar], Type.StringScalar, ([input, type], context) => {\n        if (breakpoint(context)) debugger;\n        if (input == null || type == null) return null;\n        if (type.toUpperCase() == \"HTML\") {\n            // TODO should this be different?\n            return input.replaceAll(\"&\", \"&amp;\").replaceAll(\"<\", \"&lt;\").replaceAll(\">\", \"&gt;\").replaceAll('\"', \"&quot;\").replaceAll(\"'\", \"&#039;\");\n        } else if (type.toUpperCase() == \"HTML-DECODE\") {\n            const txt = document.createElement(\"textarea\");\n            txt.innerHTML = input;\n            return txt.value;\n        } else if (type.toUpperCase() == \"HTML-ATTRIBUTE\") {\n            return input.replaceAll(\"&\", \"&amp;\").replaceAll(\"<\", \"&lt;\").replaceAll(\">\", \"&gt;\").replaceAll('\"', \"&quot;\").replaceAll(\"'\", \"&#039;\");\n        } else if (type.toUpperCase() == \"URL\") {\n            return encodeURIComponent(input);\n        } else if (type.toUpperCase() == \"URL-DECODE\") {\n            return decodeURIComponent(input);\n            //} else if (type.toUpperCase() == \"URL-COMPONENT\") {\n            //    return encodeURIComponent(input);\n        } else if (type.toUpperCase() == \"JS\") {\n            return null; // TODO?\n        } else if (type.toUpperCase() == \"CSV\") {\n            if (/[,\"\\n\\r]/.test(input)) {\n                return '\"' + input.replaceAll('\"', '\"\"') + '\"';\n            } else {\n                return input;\n            }\n        } else if (type.toUpperCase() == \"CSV-DECODE\") {\n            if (input.startsWith('\"') && input.endsWith('\"')) {\n                return input.substring(1, input.length - 1).replaceAll('\"\"', '\"');\n            } else {\n                return input;\n            }\n        } else {\n            return null;\n        }\n    }),\n    Product: makeListBuiltinFunc<number[] | null, number | null>(Type.DecimalList, Type.DecimalScalar, (resolvedTerms, context) => {\n        const flattenTerms = resolvedTerms.flat();\n        if (breakpoint(context)) debugger;\n        return flattenTerms.length == 0 ? 0 : flattenTerms.reduce((a, b) => (a ?? 0) * (b ?? 0));\n    }),\n    CombineLists: makeListBuiltinFunc<ListCalculationResult, ListCalculationResult>(Type.List, Type.List, (resolvedTerms, context) => {\n        if (breakpoint(context)) debugger;\n        return resolvedTerms.flat();\n    }),\n    Union: makeListBuiltinFunc<ListCalculationResult, ListCalculationResult>(Type.List, Type.List, (resolvedTerms, context) => {\n        if (breakpoint(context)) debugger;\n        return DFUnion(resolvedTerms);\n    }),\n    Except: makeListBuiltinFunc<ListCalculationResult, ListCalculationResult>(Type.List, Type.List, (resolvedTerms, context) => {\n        if (breakpoint(context)) debugger;\n        return DFExcept(resolvedTerms);\n    }),\n    Intersect: makeListBuiltinFunc<ListCalculationResult, ListCalculationResult>(Type.List, Type.List, (resolvedTerms, context) => {\n        if (breakpoint(context)) debugger;\n        return DFIntersect(resolvedTerms);\n    }),\n    Distinct: makeListBuiltinFunc<ListCalculationResult, ListCalculationResult>(Type.List, Type.List, (resolvedTerms, context) => {\n        if (breakpoint(context)) debugger;\n        resolvedTerms.unshift([]);\n        return DFUnion(resolvedTerms);\n    }),\n    IsSubSet: makeListBuiltinFunc<ListCalculationResult, boolean | null>(Type.List, Type.BooleanScalar, (resolvedTerms, context) => {\n        if (breakpoint(context)) debugger;\n        if (resolvedTerms.length < 2) {\n            return null;\n        }\n        const set = resolvedTerms.shift()!;\n        return resolvedTerms.reduce((v, p) => v && p.every(i => set.includes(i)), true);\n    }),\n    IsListBasicIncludes: makeListIncludesFunc(true, false, false, false),\n    IsListCasedIncludes: makeListIncludesFunc(false, false, true, false),\n    IsListUncasedIncludes: makeListIncludesFunc(false, false, false, false),\n    IsListNumericIncludes: makeListIncludesFunc(false, true, false, false),\n    IsListDateIncludes: makeListIncludesFunc(false, false, false, true),\n    Count: makeListBuiltinFunc<ListCalculationResult, number>(Type.List, Type.DecimalScalar, (resolvedTerms, context) => {\n        if (breakpoint(context)) debugger;\n        return resolvedTerms.flat().length;\n    }),\n    IsEmpty: makeListBuiltinFunc<string[] | null, boolean>(Type.StringList, Type.BooleanScalar, (resolvedTerms, context) => {\n        if (breakpoint(context)) debugger;\n        return !resolvedTerms.flat().some(i => i != null && !/^\\s*$/.test(i));\n    }),\n    IsEmptyList: makeListBuiltinFunc<ListCalculationResult, boolean>(Type.StringList, Type.BooleanScalar, (resolvedTerms, context) => {\n        if (breakpoint(context)) debugger;\n        return resolvedTerms.reduce((v, p) => v && p.length == 0, true);\n    }),\n    EmptyList: makeArgsBuiltinFunc([], Type.List, (resolvedTerms, context) => {\n        if (breakpoint(context)) debugger;\n        return [];\n    }),\n    Sort: makeSortFunc(false),\n    ReverseSort: makeSortFunc(true),\n    FormatFixedNumber: makeArgsBuiltinFunc<[number | null, number | null], string | null>([Type.DecimalScalar, Type.DecimalScalar], Type.StringScalar, ([number, precision], context) => {\n        if (breakpoint(context)) debugger;\n        return number == null || precision == null || isNaN(number) || isNaN(precision) ? number?.toString() ?? null : number.toFixed(precision);\n    }),\n    FormatNumber: makeArgsBuiltinFunc<[number | null, string | null], string | null>([Type.DecimalScalar, Type.StringScalar], Type.StringScalar, ([number, format], context) => {\n        format = (format || \"\").toLowerCase();\n        if (number == null || isNaN(number)) {\n            return number as unknown as string;\n        } else if (format == \"number\") {\n            return Intl.NumberFormat(\"en-US\", { style: \"decimal\", signDisplay: \"exceptZero\" }).format(number).replace(\"+\", \"\");\n        } else if (format == \"currency\") {\n            return Intl.NumberFormat(\"en-US\", { style: \"currency\", currency: \"USD\", currencyDisplay: \"narrowSymbol\", signDisplay: \"exceptZero\" }).format(number).replace(\"+\", \"\");\n        } else if (format == \"currency (rounded)\") {\n            return Intl.NumberFormat(\"en-US\", { style: \"currency\", currency: \"USD\", currencyDisplay: \"narrowSymbol\", minimumFractionDigits: 0, maximumFractionDigits: 0, signDisplay: \"exceptZero\" }).format(number).replace(\"+\", \"\");\n        } else if (format == \"percent\") {\n            return Intl.NumberFormat(\"en-US\", { style: \"percent\", maximumFractionDigits: 2, signDisplay: \"exceptZero\" }).format(number).replace(\"+\", \"\");\n        } else {\n            return number.toString();\n        }\n    }),\n    GetUniqueId: (calculation: CalculationSetting, contextO: InnerCalculationContext): CalculationInnerResult => {\n        const stack = [...(contextO.currentListIndex ?? [])];\n        return makeArgsBuiltinAsyncFunc([], Type.StringScalar, (_, context) => {\n            if (breakpoint(context)) debugger;\n            const virtualContext$ = context.node?.getVirtualContext$();\n            return virtualContext$.pipe(\n                switchMap(async virtualContext => {\n                    const formId = await context.getOrCreateFormId();\n                    const operationId = calculation.id;\n                    const uniqueIdBasis = `F/${formId}/O/${operationId}/R/${(virtualContext ?? []).join(\"/\")}/M/${(stack ?? []).join(\"/\")}`;\n                    const hashArray = Array.from(new Uint8Array(await crypto.subtle.digest(\"SHA-512\", new TextEncoder().encode(uniqueIdBasis))));\n                    const hashHex = hashArray\n                        .map(b => b.toString(16).padStart(2, \"0\"))\n                        .join(\"\")\n                        .toUpperCase();\n                    //return uniqueIdBasis; // + \" `` \" + hashHex + \" `` \" + btoa(hashArray);\n                    //return btoa(hashArray).substring(100, 110);\n                    //return uniqueIdBasis + \" -- \" +hashHex.substring(0, 10).toUpperCase();\n                    return hashHex.substring(0, 10);\n                }),\n            );\n        })(calculation, contextO);\n    },\n    Now: makeArgsBuiltinAsyncFunc<[string | null], string | null>([Type.StringScalar], Type.StringScalar, ([type], context) => {\n        return new Observable(function subscribe(subscriber) {\n            let timerId: ReturnType<typeof setTimeout> | null = null;\n            fetchMoment().then(moment => {\n                const generate = () => {\n                    if (breakpoint(context)) debugger;\n                    let date = moment(context.now()).tz(context.timeZone); // TODO - submitted case\n                    if (date == null || !date.isValid() || type == null || (type.toUpperCase() != \"DATE\" && type.toUpperCase() != \"DATETIME\")) {\n                        return [null, null];\n                    }\n                    if (type.toUpperCase() == \"DATE\") {\n                        date = date.startOf(\"day\");\n                    }\n                    return [date, date.format(\"M/D/YYYY h:mm:ss A\")] as const;\n                };\n                if (type?.toUpperCase() == \"DATE\") {\n                    // TODO - or submitted case\n                    subscriber.next(generate()[1]);\n                    subscriber.complete(); // Ignoring the case that the date changes while the calculation is running...\n                } else {\n                    const tickOp = () => {\n                        const [date, result] = generate();\n                        subscriber.next(result);\n                        if (date != null) {\n                            timerId = setTimeout(tickOp, 1000 - date.milliseconds());\n                        }\n                    };\n                    tickOp();\n                }\n            });\n            return function unsubscribe() {\n                clearTimeout(timerId!);\n            };\n        });\n    }),\n    DateAdd: makeArgsBuiltinAsyncFunc<[string | null, number | null, string | null], string | null>([Type.StringScalar, Type.DecimalScalar, Type.StringScalar], Type.StringScalar, async ([typeStr, operandStr, dateStr], context) => {\n        const type = DfParseDateType(typeStr);\n        const operand = parseFloat(operandStr as unknown as string); // TODO?\n        const date = await DfParseDate(dateStr, context);\n        if (breakpoint(context)) debugger;\n        if (isNaN(operand) || date == null || !date.isValid() || type == null) {\n            return null;\n        }\n        return date.add(operand, type).format(\"M/D/YYYY h:mm:ss A\");\n    }),\n    DateFormat: makeArgsBuiltinAsyncFunc<[string | null, string | null], string | null>([Type.StringScalar, Type.StringScalar], Type.StringScalar, async ([dateStr, formatStr], context) => {\n        let date = await DfParseDate(dateStr, context);\n        const format = DfParseDateFormat(formatStr);\n        if (breakpoint(context)) debugger;\n        if (date == null || !date.isValid() || format == null) {\n            return null;\n        }\n        if (format.endsWith(\"[Z]\")) {\n            date = date.utc();\n        }\n        return date.format(format);\n    }),\n    DateDifference: makeArgsBuiltinAsyncFunc<[string | null, string | null, string | null], number | null>([Type.StringScalar, Type.StringScalar, Type.StringScalar], Type.DecimalScalar, async ([typeStr, dateAStr, dateBStr], context) => {\n        const type = DfParseDateType(typeStr);\n        const dateA = await DfParseDate(dateAStr, context);\n        const dateB = await DfParseDate(dateBStr, context);\n        if (breakpoint(context)) debugger;\n        if (dateA == null || !dateA.isValid() || dateB == null || !dateB.isValid() || type == null) {\n            return null;\n        }\n        return dateA.diff(dateB, type);\n    }),\n    GetDaysInMonth: makeArgsBuiltinAsyncFunc<[string | null], number | null>([Type.StringScalar], Type.DecimalScalar, async ([dateStr], context) => {\n        const date = await DfParseDate(dateStr, context);\n        if (breakpoint(context)) debugger;\n        if (date == null || !date.isValid()) {\n            return null;\n        }\n        return date.daysInMonth();\n    }),\n    GetDatePart: makeArgsBuiltinAsyncFunc<[string | null, string | null], number | null>([Type.StringScalar, Type.StringScalar], Type.DecimalScalar, async ([type, dateStr], context) => {\n        const date = await DfParseDate(dateStr, context);\n        if (breakpoint(context)) debugger;\n        if (date == null || !date.isValid() || type == null) {\n            return null;\n        }\n        return DfGetDatePart(date, type);\n    }),\n    DateCompare: makeArgsBuiltinAsyncFunc<[string | null, string | null], 1 | 0 | -1 | null>([Type.StringScalar, Type.StringScalar], Type.DecimalScalar, async ([dateAStr, dateBStr], context) => {\n        const dateA = await DfParseDate(dateAStr, context);\n        const dateB = await DfParseDate(dateBStr, context);\n        if (breakpoint(context)) debugger;\n        if (dateA == null || !dateA.isValid() || dateB == null || !dateB.isValid()) {\n            return null;\n        }\n        return dateA.isBefore(dateB) ? -1 : dateA.isSame(dateB) ? 0 : 1;\n    }),\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ValueMapperV2: (calculation: CalculationSetting, context: InnerCalculationContext, otherData?: Observable<Record<string, any>>): CalculationInnerResult => {\n        const cacheKey = calculation.id != null ? { type: \"ValueMapperV2\" } : null;\n        return makeBackendFunc(null, true)(calculation, context, otherData, cacheKey) as CalculationInnerResult;\n    },\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ValueListV2: (calculation: CalculationSetting, context: InnerCalculationContext, otherData?: Observable<Record<string, any>>): CalculationInnerResult => {\n        const cacheKey = calculation.id != null ? { type: \"ValueListV2\" } : null;\n        return makeBackendFunc(null, true)(calculation, context, otherData, cacheKey) as CalculationInnerResult;\n    },\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ValueMapper: (calculation: CalculationSetting, context: InnerCalculationContext, otherData?: Observable<Record<string, any>>): CalculationInnerResult => {\n        const termedCal = calculation as ICalculationSettingWithTerms;\n        const cacheKey = { ...calculation, terms: [...(termedCal.terms ?? [])], otherData };\n        delete cacheKey.terms[3];\n        delete cacheKey.id;\n        const result = makeBackendFunc(\"resolveDatasourceLookup\")(calculation, context, otherData, cacheKey) as ExtendedBackendResult;\n        const columnResult = getTypedTerm(termedCal, context)(3, Type.StringScalar);\n        return {\n            ...result,\n            result: combineLatest(result.result, columnResult.pipe(switchMap(i => i.result))).pipe(\n                map(([lookupResult, columnResult]) => {\n                    //console.log(\"ZZ: \"+JSON.stringify([lookupResult, columnResult]));\n                    //eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    return lookupResult.result.pagedRows.map((r: any) => r[columnResult as string]);\n                }),\n            ),\n        };\n    },\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ValueList: (calculation: CalculationSetting, context: InnerCalculationContext, otherData?: Observable<Record<string, any>>): CalculationInnerResult => {\n        const termedCal = calculation as ICalculationSettingWithTerms;\n        const cacheKey = { ...calculation, terms: [...(termedCal.terms ?? [])], otherData };\n        delete cacheKey.terms[1];\n        delete cacheKey.id;\n        const result = makeBackendFunc(\"resolveDatasourceLookup\")(calculation, context, otherData, cacheKey) as ExtendedBackendResult;\n        const columnResult = getTypedTerm(termedCal, context)(1, Type.StringScalar);\n        return {\n            ...result,\n            result: combineLatest(result.result, columnResult.pipe(switchMap(i => i.result))).pipe(\n                map(([lookupResult, columnResult]) => {\n                    //console.log(\"ZZ: \"+JSON.stringify([lookupResult, columnResult]));\n                    //eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    return lookupResult.result.pagedRows.map((r: any) => r[columnResult as string]);\n                }),\n            ),\n        };\n    },\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ComplexValueMapper: (calculation: CalculationSetting, context: InnerCalculationContext, otherData?: Observable<Record<string, any>>): CalculationInnerResult => {\n        const cacheKey = calculation.id != null ? { type: \"ComplexValueMapper\" } : null;\n        return makeBackendFunc(null, true)(calculation, context, otherData, cacheKey) as CalculationInnerResult;\n    },\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    BackendComputation: (calculation: CalculationSetting, context: InnerCalculationContext, otherData?: Observable<Record<string, any>>): CalculationInnerResult => {\n        const cacheKey = calculation.id != null ? { type: \"BackendComputation\" } : null;\n        return makeBackendFunc(null, true)(calculation, context, otherData, cacheKey) as CalculationInnerResult;\n    },\n    GroupListV2: makeArgsBuiltinAsyncFunc<[string | null], string | null>([Type.StringScalar], Type.StringScalar, async ([group]) => {\n        if (group != null && group.includes(\"`\")) {\n            return group.split(\"`\")[1];\n        }\n        return group;\n    }),\n    Sequence: makeArgsBuiltinFunc<[number | null, number | null, number | null], number[] | null>([Type.DecimalScalar, Type.DecimalScalar, Type.DecimalScalar], Type.DecimalList, ([start, end, step], context) => {\n        if (breakpoint(context)) debugger;\n        //context = { ...context, debug: true }\n        start = start == null ? 0 : start;\n        end = end == null ? 0 : end;\n        step = step == null ? 1 : step;\n        if (end > start != step > 0) {\n            step = -1 * step;\n        }\n        const result = [];\n        let current = start;\n        while (step > 0 ? end - current > -0.00000000001 : end - current < 0.00000000001) {\n            result.push(current);\n            current += step;\n        }\n        return result;\n    }),\n    Map(calculation: CalculationSetting, context: InnerCalculationContext): CalculationInnerResult {\n        const termedCal = calculation as ICalculationSettingWithTerms;\n        const result = combineLatest(getAllTerms(termedCal, context, Type.Undefined, 1)).pipe(\n            switchMap(async resolvedTerms => {\n                if (breakpoint(context)) debugger;\n                const flattenTerms = resolvedTerms.flat();\n                context.currentListItem = context.currentListItem || [];\n                const stackIndex = context.currentListItem.length;\n                context.currentListItem.push(null);\n                context.currentListIndex = context.currentListIndex || [];\n                context.currentListIndex.push(null!);\n                if (context.currentListItem.length != context.currentListIndex.length) {\n                    throw new Error(`${context.currentListItem.length} != ${context.currentListIndex.length}`);\n                }\n                const result = [];\n                for (let index = 0; index < flattenTerms.length; index++) {\n                    context.currentListIndex[stackIndex] = index + 1;\n                    context.currentListItem[stackIndex] = flattenTerms[index];\n                    result.push(_resolveCalculation(termedCal.terms![0], context, Type.List));\n                }\n                context.currentListIndex.pop();\n                context.currentListItem.pop();\n                return combineLatest(result).pipe(map(i => i.flat()));\n            }),\n            switchMap(i => i),\n        );\n        return { result, type: Type.List, calculation };\n    },\n    Filter(calculation: CalculationSetting, context: InnerCalculationContext): CalculationInnerResult {\n        //const result = from([[]]);\n        const termedCal = calculation as ICalculationSettingWithTerms;\n        const result = combineLatest(getAllTerms(termedCal, context, Type.Undefined, 1)).pipe(\n            switchMap(async resolvedTerms => {\n                if (breakpoint(context)) debugger;\n                const flattenTerms = resolvedTerms.flat();\n                context.currentListItem = context.currentListItem || [];\n                const stackIndex = context.currentListItem.length;\n                context.currentListItem.push(null);\n                context.currentListIndex = context.currentListIndex || [];\n                context.currentListIndex.push(null!);\n                if (context.currentListItem.length != context.currentListIndex.length) {\n                    throw new Error(`${context.currentListItem.length} != ${context.currentListIndex.length}`);\n                }\n                const result = [];\n                for (let index = 0; index < flattenTerms.length; index++) {\n                    const item = flattenTerms[index];\n                    context.currentListIndex[stackIndex] = index + 1;\n                    context.currentListItem[stackIndex] = item;\n                    result.push(_resolveCalculation(termedCal.terms![0], context, Type.BooleanScalar).pipe(map(i => [item, i])));\n                }\n                context.currentListIndex.pop();\n                context.currentListItem.pop();\n                return combineLatest(result).pipe(\n                    map(i =>\n                        i\n                            .filter(i => i[1])\n                            .map(i => i[0])\n                            .flat(),\n                    ),\n                );\n            }),\n            switchMap(i => i),\n        );\n        return { result, type: Type.List, calculation };\n    },\n    Fold(calculation: CalculationSetting, context: InnerCalculationContext): CalculationInnerResult {\n        const termedCal = calculation as ICalculationSettingWithTerms;\n        //const result = from([[\"FOLD\"]]);\n        const result = combineLatest(getAllTerms(termedCal, context, Type.Undefined, 1)).pipe(\n            switchMap(async resolvedTerms => {\n                if (breakpoint(context)) debugger;\n                //context = { ...context, debug: true }\n                const flattenTerms = resolvedTerms.flat();\n                if (flattenTerms.length == 0) {\n                    return from([[]]);\n                }\n                context.currentListItem = context.currentListItem || [];\n                const stackIndex = context.currentListItem.length;\n                context.currentListItem.push(null);\n                context.currentListIndex = context.currentListIndex || [];\n                context.currentListIndex.push(null!);\n                context.currentListRunningResult = context.currentListRunningResult || [];\n                context.currentListRunningResult.push(null!);\n                if (context.currentListItem.length != context.currentListIndex.length) {\n                    throw new Error(`${context.currentListItem.length} != ${context.currentListIndex.length}`);\n                }\n                //if (context.currentListItem.length != context.currentListRunningResult.length) {\n                //    throw new Error(`${context.currentListItem.length} != ${context.currentListRunningResult.length}`);\n                //}\n                let result: Observable<CalculationResult> = (context.currentListRunningResult[stackIndex] = from([flattenTerms[0]]));\n                for (let index = 1; index < flattenTerms.length; index++) {\n                    const item = flattenTerms[index];\n                    context.currentListIndex[stackIndex] = index + 1;\n                    context.currentListItem[stackIndex] = item;\n                    result = context.currentListRunningResult[stackIndex] = _resolveCalculation(termedCal.terms![0], context, Type.Scalar);\n                }\n                context.currentListIndex.pop();\n                context.currentListItem.pop();\n                context.currentListRunningResult.pop();\n                return result;\n            }),\n            switchMap(i => i),\n        );\n        return { result, type: Type.Scalar, calculation };\n    },\n};\n\nfunction getTerms(calculation: ICalculationSettingWithTerms, context: InnerCalculationContext, ...types: TypeValue[]) {\n    const f = getTerm(calculation, context);\n    return types.map((type, index) => f(index, type));\n}\nfunction getAllTerms(calculation: ICalculationSettingWithTerms, context: InnerCalculationContext, type: TypeValue, skip?: number) {\n    const f = getTerm(calculation, context);\n    const r = calculation.terms!.map((_, index) => (skip != null && skip > index ? null! : f(index, type)));\n    return skip != null ? r.filter((v, i) => i >= skip) : r;\n}\n\nfunction getTerm(calculation: ICalculationSettingWithTerms, context: InnerCalculationContext) {\n    return (key: number, type: TypeValue) => {\n        if (calculation.terms!.length > key) {\n            return _resolveCalculation(calculation.terms![key], context, type);\n        } else {\n            return from([null! as CalculationResult]);\n        }\n    };\n}\nfunction getTypedTerm(calculation: ICalculationSettingWithTerms, context: InnerCalculationContext) {\n    return (key: number, type: TypeValue): Observable<CalculationInnerResult> => {\n        if (calculation.terms!.length > key) {\n            return _resolveCalculationTyped(calculation.terms![key], context, type);\n        } else {\n            return from([{ result: null, type: Type.Undefined } as unknown as CalculationInnerResult]);\n        }\n    };\n}\n\nfunction DFUnion(listOfLists: ListCalculationResult[]) {\n    if (listOfLists.length == 1) {\n        return listOfLists[0];\n    }\n    // TODO use Map instead?\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const hash = {} as Record<any, true>,\n        union = [] as ListCalculationResult;\n    listOfLists.forEach(function (l) {\n        l.forEach(function (item) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            if (!hash[item as any]) {\n                union.push(item);\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                hash[item as any] = true;\n            }\n        });\n    });\n    return union;\n}\n\nfunction DFExcept(listOfLists: ListCalculationResult[]) {\n    if (listOfLists.length == 0) {\n        return [];\n    }\n    if (listOfLists.length == 1) {\n        return listOfLists[0];\n    }\n    // TODO use Map instead?\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const hash = {} as Record<any, true>;\n    listOfLists[0].forEach(function (item) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        hash[item as any] = true;\n    });\n    listOfLists.slice(1).forEach(function (list) {\n        list.forEach(function (item) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            if (hash[item as any]) {\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                delete hash[item as any];\n            }\n        });\n    });\n    return listOfLists[0].filter(function (item) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        if (hash[item as any]) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            delete hash[item as any];\n            return 1;\n        } else {\n            return 0;\n        }\n    });\n}\n\nfunction DFIntersect(listOfLists: ListCalculationResult[]) {\n    if (listOfLists.length == 0) {\n        return [];\n    }\n    if (listOfLists.length == 1) {\n        return listOfLists[0];\n    }\n    // TODO use Map instead?\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const hash = {} as Record<any, number>;\n    listOfLists.slice(1).forEach(function (l) {\n        l.forEach(function (item) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            if (hash[item as any]) {\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                hash[item as any] += 1;\n            } else {\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                hash[item as any] = 1;\n            }\n        });\n    });\n    return listOfLists[0].filter(function (item) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        if (hash[item as any]) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            const result = hash[item as any] === listOfLists.length - 1;\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            delete hash[item as any];\n            return result;\n        } else {\n            return 0;\n        }\n    });\n}\n\nfunction DFStringSplitLikeBackend(input: string, splitter: string, splitterType: string | null, count: number | null) {\n    //const logP = `I: ${input}, S: ${splitter}, ST: ${splitterType}, C: ${count}`;\n    //console.log(logP);\n    if (count == 1) return [input];\n    const result = [];\n    const isRegex = splitterType?.toUpperCase() == \"REGEX\";\n    const isCounting = count != null && count >= 0;\n    const matchRegex = isRegex ? DfNewRegExpWithoutError(splitter, \"g\") : null;\n    if (isRegex && matchRegex == null) return null;\n    let foundCount = 0;\n    let pos = 0;\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        let nextPos;\n        let splitLen;\n        if (isRegex) {\n            const matchResultArray = matchRegex!.exec(input);\n            if (matchResultArray == null) {\n                nextPos = -1;\n                splitLen = 0;\n            } else {\n                splitLen = matchResultArray[0].length;\n                nextPos = matchRegex!.lastIndex - splitLen;\n                result.push(input.substring(pos, nextPos));\n                for (let i = 1; i < matchResultArray.length; i++) {\n                    result.push(matchResultArray[i]);\n                }\n            }\n        } else {\n            nextPos = input.indexOf(splitter, pos);\n            splitLen = splitter.length;\n            if (nextPos != -1) {\n                result.push(input.substring(pos, nextPos));\n            }\n        }\n        //console.log(`${logP} => P: ${pos}, NP: ${nextPos}, SL: ${splitLen}`);\n        if (nextPos == -1) {\n            //console.log(`${logP} => Not Found Term at ${pos}`);\n            result.push(input.substring(pos));\n            break;\n        }\n        pos = nextPos + splitLen;\n        foundCount++;\n        if (foundCount > 1000) throw new Error(\"Infinite loop?\");\n        if (isCounting) {\n            if (foundCount + 1 >= count) {\n                //console.log(`${logP} => Count Term at ${pos}`);\n                result.push(input.substring(pos));\n                break;\n            }\n        }\n    }\n    return result;\n\n    //let result;\n    //if (splitterType?.toUpperCase() == \"REGEX\") {\n    //    let splitterRegex = DfNewRegExpWithoutError(splitter);\n    //    if (splitterRegex == null) return null;\n    //    if (count != null && count >= 0) {\n    //        result = input.split(splitterRegex, count);\n    //    } else {\n    //        result = input.split(splitterRegex);\n    //    }\n    //} else {\n    //    if (count != null && count >= 0) {\n    //        result = input.split(splitter, count);\n    //    } else {\n    //        result = input.split(splitter);\n    //    }\n    //}\n}\n\nclass DFReplace {\n    ignoreCase: boolean;\n    replaceAll: boolean;\n    match: string;\n    constructor(match: string, ignoreCase: boolean, replaceAll: boolean) {\n        this.match = match;\n        this.ignoreCase = ignoreCase;\n        this.replaceAll = replaceAll;\n    }\n    [Symbol.replace](input: string, replacement: string) {\n        if (this.ignoreCase) {\n            // Based on https://stackoverflow.com/a/49460599\n            const strLower = input.toUpperCase();\n            const findLower = String(this.match).toUpperCase();\n            let strTemp = input.toString();\n\n            if (this.replaceAll) {\n                let count = 0;\n                let pos = strLower.length;\n                while ((pos = strLower.lastIndexOf(findLower, pos)) != -1) {\n                    strTemp = strTemp.substr(0, pos) + replacement + strTemp.substr(pos + findLower.length);\n                    if (pos == 0) break;\n                    pos--;\n                    if (count++ > 1000) throw new Error(\"Infinite loop?\");\n                }\n            } else {\n                const pos = strLower.indexOf(findLower);\n                if (pos != -1) {\n                    strTemp = strTemp.substr(0, pos) + replacement + strTemp.substr(pos + findLower.length);\n                }\n            }\n            return strTemp;\n        } else {\n            if (this.replaceAll) {\n                return input.replaceAll(this.match, replacement);\n            } else {\n                return input.replace(this.match, replacement);\n            }\n        }\n    }\n}\n\n////export function DfGetAllTableValues(fetchXrsfFunc, urlFetcher, tableName, testMode, resultKey) {\n////    return DfGetAllAreaTableValues(fetchXrsfFunc, urlFetcher, null, tableName, testMode, resultKey);\n////}\n////const tableCaches = {};\n////export function DFClearTableCache() {\n////    for (let key in tableCaches) {\n////        delete tableCaches[key];\n////    }\n////}\n////export function DfGetAllAreaTableValues(fetchXrsfFunc, urlFetcher, areaCode, tableName, testMode, resultKey) {\n////    const tableCache = _DFResolveGetTableCache(areaCode, tableName, testMode);\n////    //@ts-ignore\n////    let allPromise = tableCache[null];\n////    if (allPromise == null) {\n////        //@ts-ignore\n////        tableCache[null] = allPromise = (async () => {\n////            const url = await urlFetcher(\"datasourceFetchData\", { tenantCode: areaCode, tableKey: tableName, testMode: testMode });\n////            const tableData = await fetch(url).then(r => r.json());\n////            return tableData;\n////        })();\n////    }\n////    return _DFResolveTableLookup([allPromise], resultKey);\n////}\n////function DfGetTableValue(fetchXrsfFunc, urlFetcher, tableName, testMode, resultKey, keyKey, keyValues) {\n////    return DfGetAreaTableValue(fetchXrsfFunc, urlFetcher, null, tableName, testMode, resultKey, keyKey, keyValues);\n////}\n////function DfGetAreaTableValue(fetchXrsfFunc, urlFetcher, areaCode, tableName, testMode, resultKey, keyKey, keyValues) {\n////    if (\n////        keyValues.filter(function (v) {\n////            return v != null && !/^\\s*$/.test(v);\n////        }).length == 0\n////    ) {\n////        return Promise.resolve([]);\n////    }\n////    const tableCache = _DFResolveGetTableCache(areaCode, tableName, testMode);\n////    let tableKeyCache = tableCache[keyKey];\n////    if (tableKeyCache == null) {\n////        tableKeyCache = tableCache[keyKey] = {};\n////    }\n////    const keyCacheStr = JSON.stringify(keyValues);\n////    let promise = tableKeyCache[keyCacheStr];\n////    if (promise == null) {\n////        promise = tableKeyCache[keyCacheStr] = (async function () {\n////            const url = await urlFetcher(\"datasourceFetchRows\", { tenantCode: areaCode });\n////            const data = {\n////                tableKey: tableName,\n////                testMode: testMode,\n////                rowKey: keyKey,\n////                rowMatches: keyValues,\n////            };\n////            const rows = await fetchXrsfFunc(url, {\n////                method: \"POST\",\n////                headers: {\n////                    \"Content-Type\": \"application/json\",\n////                },\n////                body: JSON.stringify(data),\n////            }).then(r => r.json());\n////\n////            return rows;\n////        })();\n////    }\n////    return _DFResolveTableLookup([promise], resultKey);\n////}\n////function _DFResolveGetTableCache(areaCode, tableName, testMode) {\n////    let areaCache = tableCaches[areaCode];\n////    if (areaCache == null) {\n////        areaCache = tableCaches[areaCode] = {};\n////    }\n////    let tableCache = areaCache[tableName];\n////    if (tableCache == null) {\n////        tableCache = areaCache[tableName] = {};\n////    }\n////    let modeCache = tableCache[testMode];\n////    if (modeCache == null) {\n////        modeCache = tableCache[testMode] = {};\n////    }\n////    return modeCache;\n////}\n////function _DFResolveTableLookup(promiseLists, resultKey) {\n////    return Promise.all(promiseLists).then(function (input) {\n////        //throw new Error(resultKey+\" => \"+JSON.stringify(input));\n////        return [].concat.apply(\n////            [],\n////            input.map(i => i.map(v => v[resultKey])),\n////        );\n////    });\n////}\n\nfunction DfParseDateType(value: string | null | undefined) {\n    if (value == null) {\n        return null;\n    }\n    value = value.toUpperCase();\n    return value == \"YEAR\" || value == \"YEARS\" ? \"years\" : value == \"MONTH\" || value == \"MONTHS\" ? \"months\" : value == \"DAY\" || value == \"DAYS\" ? \"days\" : value == \"HOUR\" || value == \"HOURS\" ? \"hours\" : value == \"MINUTE\" || value == \"MINUTES\" ? \"minutes\" : value == \"SECOND\" || value == \"SECONDS\" ? \"seconds\" : null;\n}\n\nconst formatMap = {\n    \"M-d-yyyy\": \"MM-DD-YYYY\",\n    \"M/d/yyyy\": \"M/D/YYYY\",\n    \"M/d/yyyy h:mm:ss tt\": \"M/D/YYYY h:mm:ss A\",\n    \"M/d/yyyy h:mm:ss tt zzzz\": \"M/D/YYYY h:mm:ss A zz\",\n    \"MMMM d, yyyy\": \"MMMM D, YYYY\",\n    \"dddd, MMMM d, yyyy\": \"dddd, MMMM D, YYYY\",\n    \"h:mm:ss tt\": \"h:mm:ss A\",\n    \"h:mm tt\": \"h:mm A\",\n    \"h:mm:ss tt zzzz\": \"h:mm:ss A zz\",\n    \"M/d/yyyy H:mm:ss\": \"M/D/YYYY H:mm:ss\",\n    \"H:mm:ss\": \"H:mm:ss\",\n    \"yyyy-MM-dd\": \"YYYY-MM-DD\",\n    'yyyy-MM-dd\"T\"HH:mm:ss': \"YYYY-MM-DD[T]HH:mm:ss\",\n    'yyyy-MM-dd\"T\"HH:mm:ss\"Z\"': \"YYYY-MM-DD[T]HH:mm:ss[Z]\",\n};\nfunction DfParseDateFormat(format: string | null) {\n    if (format! in formatMap) {\n        return formatMap[format as keyof typeof formatMap];\n    }\n    return null;\n}\n\nasync function DfParseDate(value: string | null | undefined, context: CalculationContext) {\n    if (value == null) {\n        return null;\n    }\n    return (await fetchMoment())(parseDate(value, context.schemaVersion)).tz(context.timeZone, true);\n}\n\nexport function parseBool(value: string | null | undefined | boolean | number) {\n    if (value == null) {\n        return null;\n    }\n    if (typeof value == \"number\") {\n        return value != 0;\n    }\n    const valueStr = value.toString().toLowerCase();\n    return valueStr == \"1\" || valueStr == \"true\" ? 1 : valueStr == \"0\" || valueStr == \"false\" ? 0 : null;\n}\n\nexport function DfParseFloat(value: string | null | undefined | number | boolean) {\n    // Remove spaces, dollar sign, commas, etc before parsing\n    value = value == null ? null : value.toString().replace(/[^+0-9.-]+/g, \"\");\n    return parseFloat(value!);\n}\n\nexport function DfParseFloatWithoutNan(value: string | null | undefined | number | boolean) {\n    const result = DfParseFloat(value);\n    return isNaN(result) ? 0 : result;\n}\n\n//export function DfStrictParseFloatWithoutNan(value) {\n//    const result = DfStrictParseFloat(value);\n//    return isNaN(result) ? 0 : result;\n//}\n\nfunction DfGetDatePart(value: Moment.Moment, typeI: string | null | undefined) {\n    if (value == null || typeI == null) {\n        return null;\n    }\n    typeI = typeI.toUpperCase();\n    const type =\n        typeI == \"YEAR\" || typeI == \"YEARS\"\n            ? \"year\"\n            : typeI == \"MONTH\" || typeI == \"MONTHS\"\n              ? \"month\"\n              : typeI == \"DAY\" || typeI == \"DAYS\"\n                ? \"date\" // Not day - that's day of week\n                : typeI == \"HOUR\" || typeI == \"HOURS\"\n                  ? \"hour\"\n                  : typeI == \"MINUTE\" || typeI == \"MINUTES\"\n                    ? \"minute\"\n                    : typeI == \"SECOND\" || typeI == \"SECONDS\"\n                      ? \"second\"\n                      : null;\n    let result = value[type!]() as number;\n    // JS is 0-indexed, backend is 1-indexed - standardize on 1-indexed\n    if (type == \"month\") {\n        result++;\n    }\n    return result;\n}\n\nfunction DfNewRegExpWithoutError(input: string, flags?: string) {\n    try {\n        return new RegExp(input, flags);\n    } catch (e) {\n        if (e instanceof SyntaxError) {\n            return null;\n        } else {\n            throw e;\n        }\n    }\n}\n","export const DATE_REGEX = /^\\s*(?:(?:(?<month>\\d\\d?)\\s*[-\\\\/]?\\s*(?<day>\\d\\d?)(?:\\s*[-\\\\/]?\\s*(?<year>\\d{2}(?:\\d{2})?)))|(?:(?<year2>\\d{4})\\s*[-\\\\/]?\\s*(?<month2>\\d\\d?)\\s*[-\\\\/]?\\s*(?<day2>\\d\\d?)))(?:(?:T|\\s*)(?<hour>\\d\\d?)[: ]?(?<minute>\\d\\d)(?:[: ](?:(?<second>\\d\\d)(?:[.](?<millisecond>\\d{1,3}))?))?(?:\\s*(?<divider>(?:A[.]?M[.]?|P[.]?M[.]?)))?(?<timezone>Z|\\s*?[+-]\\d\\d?(?::\\d\\d?)?)?)?\\s*$/i;\n\nexport function parseDate(value: string | number | boolean | null | undefined, schemaVersion: number) {\n    const result = tryParseDate(value);\n    if (result != null) {\n        return result;\n    } else if (schemaVersion < 8 && value != null && !/^\\s*$/.test(value.toString())) {\n        // See FormDefinitionSchemaVersion\n        return new Date(value.toString());\n    } else {\n        return null;\n    }\n}\n\nexport function tryParseDate(value: string | number | boolean | null | undefined) {\n    if (value == null || /^\\s*$/.test(value.toString())) {\n        return null;\n    }\n    const match = DATE_REGEX.exec(value.toString());\n    if (match != null && match.groups != null) {\n        //eslint-disable-next-line prefer-const\n        let [year, month, day, hour, minute] = [\"year\", \"month\", \"day\", \"hour\", \"minute\"].map(i => match.groups![i] || match.groups![i + \"2\"]).map(i => (i == null ? null : parseInt(i))) as [number, number, number, number | null, number | null];\n        hour = hour || 0;\n        minute = minute || 0;\n        if (year < 50) year += 2000;\n        if (year < 100) year += 1900;\n        let second;\n        if (match.groups.millisecond) {\n            second = parseFloat(match.groups.second + \".\" + match.groups.millisecond);\n        } else if (match.groups.second) {\n            second = parseFloat(match.groups.second);\n        } else {\n            second = 0;\n        }\n        const divider = match.groups.divider ? match.groups.divider.toLowerCase() : null;\n        if (divider != null) {\n            const pm =\n                divider == \"pm\" || divider == \"p.m.\" || divider == \"p.m\" || divider == \"pm.\"\n                    ? true\n                    : divider == \"am\" || divider == \"a.m.\" || divider == \"a.m\" || divider == \"am.\"\n                      ? false\n                      : (() => {\n                            throw new Error(\"Regex shouldn't return this divider: \" + divider);\n                        })();\n            if (hour == 12) {\n                if (!pm) {\n                    // 12:30am = 0:30\n                    hour = 0;\n                } else {\n                    // 12:30pm = 12:30\n                }\n            } else if (pm) {\n                hour += 12;\n            }\n        }\n        const timezone = match.groups.timezone;\n        if (timezone != null) {\n            // TODO?\n        }\n        if (month <= 0 || month > 12 || day < 1 || day > 31 || hour < 0 || hour > 23 || minute < 0 || minute > 59 || second < 0 || second > 60) {\n            //console.log({year, month, day, hour, minute, second});\n            return null;\n        }\n        const result = new Date(year, month - 1, day, hour, minute, second);\n        if (result.getDate() != day) {\n            //console.log({year, month, day, hour, minute, second});\n            // For example, Fed 30\n            return null;\n        }\n        return result;\n    } else {\n        //console.log({value});\n        return null;\n    }\n}\nexport function DfStrictParseFloat(value: string | null | undefined | number | boolean) {\n    value = value == null || !/^\\s*([+-]?[$]?|[+-]?[$]?)?([0-9,]+([.][0-9]+)?|[.][0-9]*)\\s*$/.test(value.toString()) ? null : value.toString().replace(/([$,]|\\s)+/g, \"\");\n    return parseFloat(value!);\n}\n"],"names":["debug","setDebug","i","getDebug","breakpoint","context","_momentPromise","fetchMoment","Promise","all","then","result","default","resolveCalculationPromiseBool","calculation","contextNode","resolveCalculation","Type","List","pipe","map","value","reduce","a","parseBool","first","toPromise","resolveCalculationPromise","type","calculationList","type2","StringList","length","from","_resolveCalculation","node","rootCalc","calculationContext","_resolveCalculationRaw","Error","isCalculationInnerResult","convert","switchMap","r","operatorFunc","operators","$type","toType","convertItem","JSON","stringify","TypeType","String","toString","Boolean","Decimal","DfParseFloatWithoutNan","TypeStructure","Scalar","stack","currentListRunningResult","currentListIndex","DecimalScalar","currentListItem","operator","builtinFunc","operation","MI.Common.DynamicForms.Controls.Settings.BuiltinFunction, DynamicForms","function","MI.Common.DynamicForms.Controls.Settings.Constant, DynamicForms","StringScalar","id","rootElement","getElementsById$","vmId","otherElements","combineLatest","extraDataKey","effectiveExtraData$","extraCacheKey$","getOrCreateFormId","formId","extraCacheKey","makeBackendFunc","getExtraData","effectiveValueList$","getValue","tap","arraysOfOtherValues","Array","prototype","concat","apply","externalData","groupValue","group","includes","split","calc","input","getTypeFromStr","dataType","structureType","Undefined","BooleanScalar","BooleanList","DecimalList","typeType","typeStructure","operandTerm","getTerm","branchTerms","getTypedTerm","resolvedTerm","operand","!","operationInners","STRING_STRING","config","output","multipleTerms","_convert","v",".","b","STRING_LIST_BOOL","_func","c","s","f","sort","_sort","eq","ne","ueq","toUpperCase","une","deq","tryParseDate","getTime","aD","bD","dne","STRING_BOOL","cincludes","uincludes","=~","DfNewRegExpWithoutError","test","=~c","=~u","c<","c<=","c>","c>=","u<","u<=","u>","u>=","dincludes","d<","ad","bd","d<=","d>","d>=","=~d","LIST_BOOL","aF","DfStrictParseFloat","bF","isNaN","trim","aU","bU","=","<>","SCALAR_BOOL","Number","<","<=",">",">=","DECIMAL_DECIMAL","/","*","+","-","%","DECIMAL_LIST_BOOL","==","!=","DECIMAL_BOOL","n<","n<=","n>","n>=","nincludes","=~n","BOOL_BOOL","&&","||","Object","keys","key","filter","terms","getAllTerms","resolvedTerms","makeListBuiltinFunc","inputType","outputType","func","makeListBuiltinAsyncFunc","resolve","termedCal","makeArgsBuiltinFunc","inputTypes","makeArgsBuiltinAsyncFunc","types","index","getTerms","cache","backendQueue","backendQueueTimerId","DFClearBackendCache","splice","cachePerOperation","otherData","cacheKey","elementId","elementPath","getElementPathIndexFromRoot","elementCalcs","definition","settings","calculations","calculationId","find","operationId","operationPath","walk","el","wR","unshift","loopContextO","parse","__currentListIndex","__currentListItem","operationCacheKey","operationDependencies","dependencies","dependency","otherDataO","operationDependenciesO","currentListRunningResultO","async","extraValues","loopContext","__currentListRunningResult","resp","innerCacheKey","Date","now","formNode","getRoot","extraData","extraValue","operationData","CalculationId","OperationId","OperationPath","ExtraData","data","formName","formVersion","formHash","segment","skipForm","noWrite","asAdmin","adminReview","inPreview","adminPreview","testMode","target","targetPathArray","bulkInvoke","resolveablePromise","push","setTimeout","currentQueue","groupedQueue","item","keyS","invokes","values","groupSize","invokeIndexStart","request","slice","thisInvokeIndexStart","urlFetcher","url","fetchXrsf","method","headers","body","outerResults","json","Result","outerResult","resolveBackendQueue","e","console","log","makeSortFunc","reverse","t","rTypes","rType","some","every","flat","possibleDecimalResult","possibleBooleanResult","possibleDateResult","makeListIncludesFunc","isBasic","isNumeric","isCaseSensitive","isDate","set","shift","firstListIsNumeric","ii","secondListIsNumeric","j","jj","firstListIsDate","secondListIsDate","p","Sum","flattenTerms","Concat","StringLength","Substring","lengthS","DfParseFloat","Math","round","substring","StringIndexOf","searchTerm","indexOf","StringStartsWith","startsWith","StringEndsWith","endsWith","StringReplace","search","replacement","replaceAll","DFReplace","ExtendedStringReplace","searchType","ignoreCase","searchRegex","replace","ToCase","toLowerCase","StringSplit","splitter","DFStringSplitLikeBackend","ExtendedStringSplit","splitterType","countS","count","StringEscape","txt","document","createElement","innerHTML","encodeURIComponent","decodeURIComponent","Product","CombineLists","Union","DFUnion","Except","listOfLists","hash","forEach","list","DFExcept","Intersect","l","DFIntersect","Distinct","IsSubSet","IsListBasicIncludes","IsListCasedIncludes","IsListUncasedIncludes","IsListNumericIncludes","IsListDateIncludes","Count","IsEmpty","IsEmptyList","EmptyList","Sort","ReverseSort","FormatFixedNumber","number","precision","toFixed","FormatNumber","format","Intl","NumberFormat","style","signDisplay","currency","currencyDisplay","minimumFractionDigits","maximumFractionDigits","GetUniqueId","contextO","_","virtualContext$","getVirtualContext$","uniqueIdBasis","virtualContext","join","Uint8Array","crypto","subtle","digest","TextEncoder","encode","padStart","Now","Observable","subscriber","timerId","moment","generate","date","tz","timeZone","isValid","startOf","next","complete","tickOp","milliseconds","clearTimeout","DateAdd","typeStr","operandStr","dateStr","DfParseDateType","parseFloat","DfParseDate","add","DateFormat","formatStr","formatMap","DfParseDateFormat","utc","DateDifference","dateAStr","dateBStr","dateA","dateB","diff","GetDaysInMonth","daysInMonth","GetDatePart","typeI","DfGetDatePart","DateCompare","isBefore","isSame","ValueMapperV2","ValueListV2","ValueMapper","columnResult","lookupResult","pagedRows","ValueList","ComplexValueMapper","BackendComputation","GroupListV2","Sequence","start","end","step","current","Map","stackIndex","pop","Filter","Fold","skip","_resolveCalculationTyped","union","isRegex","isCounting","matchRegex","foundCount","pos","nextPos","splitLen","matchResultArray","exec","lastIndex","match","constructor","this","Symbol","strLower","findLower","strTemp","lastIndexOf","substr","parseDate","schemaVersion","valueStr","flags","RegExp","SyntaxError","DATE_REGEX","groups","second","year","month","day","hour","minute","parseInt","millisecond","divider","pm","timezone","getDate"],"sourceRoot":""}