@itwin/grouping-mapping-widget 0.3.2 → 0.3.3

package/lib/cjs/formula/FormulaFunctionProvider.d.ts

@@ -0,0 +1,18 @@
+import type { IResult } from "./IResult";
+import type { DataType, PossibleDataType } from "./Types";
+export interface FormulaFunctionArgument {
+    dataType?: DataType;
+    canBeAny?: boolean;
+    canBeUndefined?: boolean;
+}
+export interface FormulaFunction {
+    argumentCountBounds: [number, number];
+    expectedArguments: FormulaFunctionArgument[];
+    returnType?: DataType;
+    typesMatchFromIndex?: number;
+    isreturnTypeFromTypeMatch?: boolean;
+}
+export declare function getFormulaFunctionReturnType(func: FormulaFunction, args: PossibleDataType[]): IResult<PossibleDataType>;
+export declare function getFunction(name: string): FormulaFunction | undefined;
+export declare function isFunction(name: string): boolean;
+//# sourceMappingURL=FormulaFunctionProvider.d.ts.map

package/lib/cjs/formula/FormulaFunctionProvider.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFunction = exports.getFunction = exports.getFormulaFunctionReturnType = void 0;
+const Utils_1 = require("./Utils");
+function isValidArgument(arg, argPos, expectedArg) {
+    let isValid;
+    if (arg === "undefined") {
+        isValid = !!expectedArg.canBeUndefined;
+        return { isValid, invalidReason: isValid ? undefined : `Expected ${Utils_1.formatNumericalPositionString(argPos + 1)} argument to not be null.` };
+    }
+    isValid = expectedArg.canBeAny || arg === expectedArg.dataType;
+    return { isValid, invalidReason: isValid ? undefined : `Expected ${Utils_1.formatNumericalPositionString(argPos + 1)} argument to be of type ${expectedArg.dataType}.` };
+}
+function validateArgumentsWithTypeMatching() {
+    let matchType = "undefined";
+    return (arg, argPos, expectedArg, shouldMatchType) => {
+        if (shouldMatchType && matchType === "undefined")
+            matchType = arg;
+        const validation = isValidArgument(arg, argPos, expectedArg);
+        if (!validation.isValid)
+            return validation;
+        const isValid = (matchType === "undefined" || arg === matchType || (arg === "undefined" && !!expectedArg.canBeUndefined));
+        if (matchType !== "undefined" && !isValid)
+            return {
+                isValid,
+                matchingType: matchType,
+                invalidReason: `Expected ${Utils_1.formatNumericalPositionString(argPos + 1)} argument to be of type ${matchType}.`,
+            };
+        return {
+            isValid,
+            matchingType: matchType,
+            invalidReason: isValid ? undefined : `${Utils_1.formatNumericalPositionString(argPos + 1)} argument is invalid.`,
+        };
+    };
+}
+function getFormulaFunctionReturnType(func, args) {
+    var _a, _b;
+    const hasUnlimitedArguments = func.argumentCountBounds[1] === -1;
+    if (args.length < func.argumentCountBounds[0])
+        return { errorMessage: `Too few arguments received. Expected a minimum of ${func.argumentCountBounds[0]} argument(s)` };
+    if (!hasUnlimitedArguments && args.length > func.argumentCountBounds[1])
+        return { errorMessage: `Too many arguments received. Expected a maximum of ${func.argumentCountBounds[1]} argument(s)` };
+    let returnType = (_a = func.returnType) !== null && _a !== void 0 ? _a : "undefined";
+    const validationFunc = func.typesMatchFromIndex === undefined ? isValidArgument : validateArgumentsWithTypeMatching();
+    for (let i = 0; i < args.length; i++) {
+        const shouldTypeMatch = func.typesMatchFromIndex !== undefined && i >= func.typesMatchFromIndex;
+        const expectedTypeIndex = hasUnlimitedArguments && i > func.argumentCountBounds[0] - 1 ? func.argumentCountBounds[0] - 1 : i;
+        const expectedArg = func.expectedArguments[expectedTypeIndex];
+        const validationResult = validationFunc(args[i], i, expectedArg, shouldTypeMatch);
+        if (!validationResult.isValid)
+            return { errorMessage: validationResult.invalidReason };
+        if (func.isreturnTypeFromTypeMatch && shouldTypeMatch)
+            returnType = (_b = validationResult.matchingType) !== null && _b !== void 0 ? _b : "undefined";
+    }
+    return { value: returnType };
+}
+exports.getFormulaFunctionReturnType = getFormulaFunctionReturnType;
+function getNumericalFunction(name) {
+    switch (name) {
+        case "abs": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "acos": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "acosh": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "asin": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "asinh": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "atan": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "atanh": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "atan2": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: "number" }, { dataType: "number" }], returnType: "number" };
+        case "cbrt": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "ceil": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "clz32": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "cos": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "cosh": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "exp": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "expm1": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "floor": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "fround": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "hypot": return { argumentCountBounds: [2, -1], expectedArguments: [{ dataType: "number" }, { dataType: "number" }], returnType: "number" };
+        case "imul": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: "number" }, { dataType: "number" }], returnType: "number" };
+        case "log": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "log1p": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "log10": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "log2": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "max": return { argumentCountBounds: [2, -1], expectedArguments: [{ dataType: "number" }, { dataType: "number" }], returnType: "number" };
+        case "min": return { argumentCountBounds: [2, -1], expectedArguments: [{ dataType: "number" }, { dataType: "number" }], returnType: "number" };
+        case "pow": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: "number" }, { dataType: "number" }], returnType: "number" };
+        case "random": return { argumentCountBounds: [0, 0], expectedArguments: [], returnType: "number" };
+        case "round": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "sign": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "sin": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "sinh": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "sqrt": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "tan": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "tanh": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        case "trunc": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "number" }], returnType: "number" };
+        default: return undefined;
+    }
+}
+function getStringFunction(name) {
+    switch (name) {
+        case "charat": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: "string" }, { dataType: "number" }], returnType: "string" };
+        case "concat": return { argumentCountBounds: [2, -1], expectedArguments: [{ dataType: "string" }, { dataType: "string" }], returnType: "string" };
+        case "padend": return { argumentCountBounds: [2, 3], expectedArguments: [{ dataType: "string" }, { dataType: "number" }, { dataType: "string" }], returnType: "string" };
+        case "padstart": return { argumentCountBounds: [2, 3], expectedArguments: [{ dataType: "string" }, { dataType: "number" }, { dataType: "string" }], returnType: "string" };
+        case "substring": return { argumentCountBounds: [2, 3], expectedArguments: [{ dataType: "string" }, { dataType: "number" }, { dataType: "number" }], returnType: "string" };
+        case "tolowercase": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "string" }], returnType: "string" };
+        case "touppercase": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "string" }], returnType: "string" };
+        case "trim": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "string" }], returnType: "string" };
+        case "trimend": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "string" }], returnType: "string" };
+        case "trimstart": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: "string" }], returnType: "string" };
+        default: return undefined;
+    }
+}
+function getConditionalFunction(name) {
+    switch (name) {
+        case "if": return { argumentCountBounds: [3, 3], expectedArguments: [{ dataType: "boolean" }, { canBeAny: true, canBeUndefined: true }, { canBeAny: true, canBeUndefined: true }], typesMatchFromIndex: 1, isreturnTypeFromTypeMatch: true };
+        case "ifnull": return { argumentCountBounds: [2, 2], expectedArguments: [{ canBeAny: true, canBeUndefined: true }, { canBeAny: true }], typesMatchFromIndex: 0, isreturnTypeFromTypeMatch: true };
+        case "ifnotnull": return { argumentCountBounds: [2, 2], expectedArguments: [{ canBeAny: true, canBeUndefined: true }, { canBeAny: true }], typesMatchFromIndex: 0, isreturnTypeFromTypeMatch: true };
+        case "ifempty": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: "string" }, { dataType: "string" }], returnType: "string" };
+        case "ifnotempty": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: "string" }, { dataType: "string" }], returnType: "string" };
+        case "ifnullorempty": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: "string", canBeUndefined: true }, { dataType: "string" }], returnType: "string" };
+        case "ifnotnullorempty": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: "string", canBeUndefined: true }, { dataType: "string" }], returnType: "string" };
+        case "ifnullorwhitespace": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: "string", canBeUndefined: true }, { dataType: "string" }], returnType: "string" };
+        case "ifnotnullorwhitespace": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: "string", canBeUndefined: true }, { dataType: "string" }], returnType: "string" };
+        default: return undefined;
+    }
+}
+function getFunction(name) {
+    const nameLowerCase = name.toLowerCase();
+    return getNumericalFunction(nameLowerCase) || getStringFunction(nameLowerCase) || getConditionalFunction(nameLowerCase);
+}
+exports.getFunction = getFunction;
+function isFunction(name) {
+    return !!getFunction(name);
+}
+exports.isFunction = isFunction;
+//# sourceMappingURL=FormulaFunctionProvider.js.map

package/lib/cjs/formula/FormulaFunctionProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaFunctionProvider.js","sourceRoot":"","sources":["../../../src/formula/FormulaFunctionProvider.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\nimport type { IResult } from \"./IResult\";\nimport type { DataType, PossibleDataType } from \"./Types\";\nimport { formatNumericalPositionString } from \"./Utils\";\n\nexport interface FormulaFunctionArgument {\n  dataType?: DataType;\n  canBeAny?: boolean;\n  canBeUndefined?: boolean;\n}\n\nexport interface FormulaFunction {\n  argumentCountBounds: [number, number];\n  expectedArguments: FormulaFunctionArgument[];\n  returnType?: DataType;\n  typesMatchFromIndex?: number;\n  isreturnTypeFromTypeMatch?: boolean;\n}\n\ninterface ArgumentValidationResult {\n  isValid: boolean;\n  matchingType?: PossibleDataType;\n  invalidReason?: string;\n}\n\nfunction isValidArgument(arg: PossibleDataType, argPos: number, expectedArg: FormulaFunctionArgument): ArgumentValidationResult {\n  let isValid: boolean;\n  if (arg === \"undefined\") {\n    isValid = !!expectedArg.canBeUndefined;\n    return { isValid, invalidReason: isValid ? undefined : `Expected ${formatNumericalPositionString(argPos + 1)} argument to not be null.` };\n  }\n\n  isValid = expectedArg.canBeAny || arg === expectedArg.dataType;\n  return { isValid, invalidReason: isValid ? undefined : `Expected ${formatNumericalPositionString(argPos + 1)} argument to be of type ${expectedArg.dataType}.` };\n}\n\nfunction validateArgumentsWithTypeMatching(): (arg: PossibleDataType, argPos: number, expectedArg: FormulaFunctionArgument, shouldTypeMatch: boolean) => ArgumentValidationResult {\n  let matchType: PossibleDataType = \"undefined\";\n  return (arg: PossibleDataType, argPos: number, expectedArg: FormulaFunctionArgument, shouldMatchType: boolean) => {\n    if (shouldMatchType && matchType === \"undefined\")\n      matchType = arg;\n\n    const validation = isValidArgument(arg, argPos, expectedArg);\n    if (!validation.isValid)\n      return validation;\n\n    const isValid = (matchType === \"undefined\" || arg === matchType || (arg === \"undefined\" && !!expectedArg.canBeUndefined));\n    if (matchType !== \"undefined\" && !isValid)\n      return {\n        isValid,\n        matchingType: matchType,\n        invalidReason: `Expected ${formatNumericalPositionString(argPos + 1)} argument to be of type ${matchType}.`,\n      };\n\n    return {\n      isValid,\n      matchingType: matchType,\n      invalidReason: isValid ? undefined : `${formatNumericalPositionString(argPos + 1)} argument is invalid.`,\n    };\n  };\n}\n\nexport function getFormulaFunctionReturnType(func: FormulaFunction, args: PossibleDataType[]): IResult<PossibleDataType> {\n  const hasUnlimitedArguments = func.argumentCountBounds[1] === -1;\n  if (args.length < func.argumentCountBounds[0])\n    return { errorMessage: `Too few arguments received. Expected a minimum of ${func.argumentCountBounds[0]} argument(s)` };\n  if (!hasUnlimitedArguments && args.length > func.argumentCountBounds[1])\n    return { errorMessage: `Too many arguments received. Expected a maximum of ${func.argumentCountBounds[1]} argument(s)` };\n\n  let returnType: PossibleDataType = func.returnType ?? \"undefined\";\n  const validationFunc = func.typesMatchFromIndex === undefined ? isValidArgument : validateArgumentsWithTypeMatching();\n\n  for (let i = 0; i < args.length; i++) {\n    const shouldTypeMatch = func.typesMatchFromIndex !== undefined && i >= func.typesMatchFromIndex;\n    const expectedTypeIndex = hasUnlimitedArguments && i > func.argumentCountBounds[0] - 1 ? func.argumentCountBounds[0] - 1 : i;\n    const expectedArg = func.expectedArguments[expectedTypeIndex];\n    const validationResult = validationFunc(args[i], i, expectedArg, shouldTypeMatch);\n    if (!validationResult.isValid)\n      return { errorMessage: validationResult.invalidReason };\n\n    if (func.isreturnTypeFromTypeMatch && shouldTypeMatch)\n      returnType = validationResult.matchingType ?? \"undefined\";\n  }\n\n  return { value: returnType };\n}\n\nfunction getNumericalFunction(name: string): FormulaFunction | undefined {\n  switch (name) {\n    case \"abs\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"acos\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"acosh\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"asin\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"asinh\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"atan\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"atanh\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"atan2\": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: \"number\" }, { dataType: \"number\" }], returnType: \"number\" };\n    case \"cbrt\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"ceil\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"clz32\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"cos\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"cosh\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"exp\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"expm1\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"floor\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"fround\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"hypot\": return { argumentCountBounds: [2, -1], expectedArguments: [{ dataType: \"number\" }, { dataType: \"number\" }], returnType: \"number\" };\n    case \"imul\": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: \"number\" }, { dataType: \"number\" }], returnType: \"number\" };\n    case \"log\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"log1p\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"log10\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"log2\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"max\": return { argumentCountBounds: [2, -1], expectedArguments: [{ dataType: \"number\" }, { dataType: \"number\" }], returnType: \"number\" };\n    case \"min\": return { argumentCountBounds: [2, -1], expectedArguments: [{ dataType: \"number\" }, { dataType: \"number\" }], returnType: \"number\" };\n    case \"pow\": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: \"number\" }, { dataType: \"number\" }], returnType: \"number\" };\n    case \"random\": return { argumentCountBounds: [0, 0], expectedArguments: [], returnType: \"number\" };\n    case \"round\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"sign\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"sin\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"sinh\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"sqrt\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"tan\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"tanh\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    case \"trunc\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"number\" }], returnType: \"number\" };\n    default: return undefined;\n  }\n}\n\nfunction getStringFunction(name: string): FormulaFunction | undefined {\n  switch (name) {\n    case \"charat\": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: \"string\" }, { dataType: \"number\" }], returnType: \"string\" };\n    case \"concat\": return { argumentCountBounds: [2, -1], expectedArguments: [{ dataType: \"string\" }, { dataType: \"string\" }], returnType: \"string\" };\n    case \"padend\": return { argumentCountBounds: [2, 3], expectedArguments: [{ dataType: \"string\" }, { dataType: \"number\" }, { dataType: \"string\" }], returnType: \"string\" };\n    case \"padstart\": return { argumentCountBounds: [2, 3], expectedArguments: [{ dataType: \"string\" }, { dataType: \"number\" }, { dataType: \"string\" }], returnType: \"string\" };\n    case \"substring\": return { argumentCountBounds: [2, 3], expectedArguments: [{ dataType: \"string\" }, { dataType: \"number\" }, { dataType: \"number\" }], returnType: \"string\" };\n    case \"tolowercase\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"string\" }], returnType: \"string\" };\n    case \"touppercase\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"string\" }], returnType: \"string\" };\n    case \"trim\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"string\" }], returnType: \"string\" };\n    case \"trimend\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"string\" }], returnType: \"string\" };\n    case \"trimstart\": return { argumentCountBounds: [1, 1], expectedArguments: [{ dataType: \"string\" }], returnType: \"string\" };\n    default: return undefined;\n  }\n}\n\nfunction getConditionalFunction(name: string): FormulaFunction | undefined {\n  switch (name) {\n    case \"if\": return { argumentCountBounds: [3, 3], expectedArguments: [{ dataType: \"boolean\" }, { canBeAny: true, canBeUndefined: true }, { canBeAny: true, canBeUndefined: true }], typesMatchFromIndex: 1, isreturnTypeFromTypeMatch: true };\n    case \"ifnull\": return { argumentCountBounds: [2, 2], expectedArguments: [{ canBeAny: true, canBeUndefined: true }, { canBeAny: true }], typesMatchFromIndex: 0, isreturnTypeFromTypeMatch: true };\n    case \"ifnotnull\": return { argumentCountBounds: [2, 2], expectedArguments: [{ canBeAny: true, canBeUndefined: true }, { canBeAny: true }], typesMatchFromIndex: 0, isreturnTypeFromTypeMatch: true };\n    case \"ifempty\": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: \"string\" }, { dataType: \"string\" }], returnType: \"string\" };\n    case \"ifnotempty\": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: \"string\" }, { dataType: \"string\" }], returnType: \"string\" };\n    case \"ifnullorempty\": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: \"string\", canBeUndefined: true }, { dataType: \"string\" }], returnType: \"string\" };\n    case \"ifnotnullorempty\": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: \"string\", canBeUndefined: true }, { dataType: \"string\" }], returnType: \"string\" };\n    case \"ifnullorwhitespace\": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: \"string\", canBeUndefined: true }, { dataType: \"string\" }], returnType: \"string\" };\n    case \"ifnotnullorwhitespace\": return { argumentCountBounds: [2, 2], expectedArguments: [{ dataType: \"string\", canBeUndefined: true }, { dataType: \"string\" }], returnType: \"string\" };\n    default: return undefined;\n  }\n}\n\nexport function getFunction(name: string): FormulaFunction | undefined {\n  const nameLowerCase = name.toLowerCase();\n  return getNumericalFunction(nameLowerCase) || getStringFunction(nameLowerCase) || getConditionalFunction(nameLowerCase);\n}\n\nexport function isFunction(name: string): boolean {\n  return !!getFunction(name);\n}\n"]}

package/lib/cjs/formula/FormulaOperatorsProvider.d.ts

@@ -0,0 +1,34 @@
+import type { IResult } from "./IResult";
+import type { DataType, PossibleDataType } from "./Types";
+export declare enum OperatorType {
+    UnaryPlus = 0,
+    UnaryNegation = 1,
+    Exponentiation = 2,
+    Multiplication = 3,
+    Division = 4,
+    Remainder = 5,
+    Addition = 6,
+    Subtraction = 7,
+    LogicalNot = 8,
+    LessThan = 9,
+    LessThanOrEqual = 10,
+    GreaterThan = 11,
+    GreaterThanOrEqual = 12,
+    Equality = 13,
+    Inequality = 14,
+    LogicalAnd = 15,
+    LogicalOr = 16
+}
+export declare enum OperatorAssociativity {
+    Left = 0,
+    Right = 1
+}
+export declare function isOperator(token: string): boolean;
+export declare function getBinaryOperator(token: string): OperatorType | undefined;
+export declare function getUnaryOperator(token: string): OperatorType | undefined;
+export declare function getOperatorPrecedence(op: OperatorType | undefined): number;
+export declare function getOperatorAssociativity(op: OperatorType | undefined): number;
+export declare function isSupportedOperator(token: string): boolean;
+export declare function getOperatorArgumentCountBounds(token: string): [number, number] | undefined;
+export declare function getOperatorReturnType(token: string, arg1: PossibleDataType, arg2?: PossibleDataType): IResult<DataType>;
+//# sourceMappingURL=FormulaOperatorsProvider.d.ts.map

package/lib/cjs/formula/FormulaOperatorsProvider.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperatorReturnType = exports.getOperatorArgumentCountBounds = exports.isSupportedOperator = exports.getOperatorAssociativity = exports.getOperatorPrecedence = exports.getUnaryOperator = exports.getBinaryOperator = exports.isOperator = exports.OperatorAssociativity = exports.OperatorType = void 0;
+const allOperators = ["+", "-", "*", "%", "**", "/", "`", "~", "!", "@", "#", "$", "^", "&", "=", "[", "]", "{", "}", "\\", "|", ";", ":", "'", "\"", "<", ">", "?", "+=", "-=", "*=", "/=", "%=", "&=", "^=", "|=", "?=", "==", "!=", ">=", "<=", "++", "--", "<<", ">>", "&&", "||", "??", "?.", "**=", "<<=", ">>=", "&&=", "||=", "??=", "===", "!==", ">>>", ">>>="];
+var OperatorType;
+(function (OperatorType) {
+    OperatorType[OperatorType["UnaryPlus"] = 0] = "UnaryPlus";
+    OperatorType[OperatorType["UnaryNegation"] = 1] = "UnaryNegation";
+    OperatorType[OperatorType["Exponentiation"] = 2] = "Exponentiation";
+    OperatorType[OperatorType["Multiplication"] = 3] = "Multiplication";
+    OperatorType[OperatorType["Division"] = 4] = "Division";
+    OperatorType[OperatorType["Remainder"] = 5] = "Remainder";
+    OperatorType[OperatorType["Addition"] = 6] = "Addition";
+    OperatorType[OperatorType["Subtraction"] = 7] = "Subtraction";
+    OperatorType[OperatorType["LogicalNot"] = 8] = "LogicalNot";
+    OperatorType[OperatorType["LessThan"] = 9] = "LessThan";
+    OperatorType[OperatorType["LessThanOrEqual"] = 10] = "LessThanOrEqual";
+    OperatorType[OperatorType["GreaterThan"] = 11] = "GreaterThan";
+    OperatorType[OperatorType["GreaterThanOrEqual"] = 12] = "GreaterThanOrEqual";
+    OperatorType[OperatorType["Equality"] = 13] = "Equality";
+    OperatorType[OperatorType["Inequality"] = 14] = "Inequality";
+    OperatorType[OperatorType["LogicalAnd"] = 15] = "LogicalAnd";
+    OperatorType[OperatorType["LogicalOr"] = 16] = "LogicalOr";
+})(OperatorType = exports.OperatorType || (exports.OperatorType = {}));
+var OperatorAssociativity;
+(function (OperatorAssociativity) {
+    OperatorAssociativity[OperatorAssociativity["Left"] = 0] = "Left";
+    OperatorAssociativity[OperatorAssociativity["Right"] = 1] = "Right";
+})(OperatorAssociativity = exports.OperatorAssociativity || (exports.OperatorAssociativity = {}));
+function isOperator(token) {
+    return allOperators.includes(token);
+}
+exports.isOperator = isOperator;
+function getBinaryOperator(token) {
+    switch (token) {
+        case "**": return OperatorType.Exponentiation;
+        case "*": return OperatorType.Multiplication;
+        case "/": return OperatorType.Division;
+        case "%": return OperatorType.Remainder;
+        case "+": return OperatorType.Addition;
+        case "-": return OperatorType.Subtraction;
+        case "<": return OperatorType.LessThan;
+        case "<=": return OperatorType.LessThanOrEqual;
+        case ">": return OperatorType.GreaterThan;
+        case ">=": return OperatorType.GreaterThanOrEqual;
+        case "==": return OperatorType.Equality;
+        case "!=": return OperatorType.Inequality;
+        case "&&": return OperatorType.LogicalAnd;
+        case "||": return OperatorType.LogicalOr;
+        default: return undefined;
+    }
+}
+exports.getBinaryOperator = getBinaryOperator;
+function getUnaryOperator(token) {
+    switch (token) {
+        case "+": return OperatorType.UnaryPlus;
+        case "-": return OperatorType.UnaryNegation;
+        case "!": return OperatorType.LogicalNot;
+        default: return undefined;
+    }
+}
+exports.getUnaryOperator = getUnaryOperator;
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence
+function getOperatorPrecedence(op) {
+    switch (op) {
+        case OperatorType.UnaryPlus:
+        case OperatorType.UnaryNegation:
+        case OperatorType.LogicalNot:
+            return 15;
+        case OperatorType.Exponentiation:
+            return 14;
+        case OperatorType.Multiplication:
+        case OperatorType.Division:
+        case OperatorType.Remainder:
+            return 13;
+        case OperatorType.Subtraction:
+        case OperatorType.Addition:
+            return 12;
+        case OperatorType.LessThan:
+        case OperatorType.LessThanOrEqual:
+        case OperatorType.GreaterThan:
+        case OperatorType.GreaterThanOrEqual:
+            return 10;
+        case OperatorType.Equality:
+        case OperatorType.Inequality:
+            return 9;
+        case OperatorType.LogicalAnd:
+            return 5;
+        case OperatorType.LogicalOr:
+            return 4;
+        default: return 1;
+    }
+}
+exports.getOperatorPrecedence = getOperatorPrecedence;
+function getOperatorAssociativity(op) {
+    switch (op) {
+        case OperatorType.UnaryPlus:
+        case OperatorType.UnaryNegation:
+        case OperatorType.Exponentiation:
+        case OperatorType.LogicalNot:
+            return OperatorAssociativity.Right;
+        case OperatorType.Multiplication:
+        case OperatorType.Division:
+        case OperatorType.Remainder:
+        case OperatorType.Addition:
+        case OperatorType.Subtraction:
+        case OperatorType.LessThan:
+        case OperatorType.LessThanOrEqual:
+        case OperatorType.GreaterThan:
+        case OperatorType.GreaterThanOrEqual:
+        case OperatorType.Equality:
+        case OperatorType.Inequality:
+        case OperatorType.LogicalAnd:
+        case OperatorType.LogicalOr:
+            return OperatorAssociativity.Left;
+        default:
+            return OperatorAssociativity.Left;
+    }
+}
+exports.getOperatorAssociativity = getOperatorAssociativity;
+function isSupportedOperator(token) {
+    return undefined !== getUnaryOperator(token) || undefined !== getBinaryOperator(token);
+}
+exports.isSupportedOperator = isSupportedOperator;
+function getOperatorArgumentCountBounds(token) {
+    switch (token) {
+        case "**": return [2, 2];
+        case "*": return [2, 2];
+        case "/": return [2, 2];
+        case "%": return [2, 2];
+        case "+": return [1, 2];
+        case "-": return [1, 2];
+        case "!": return [1, 1];
+        case "<": return [2, 2];
+        case "<=": return [2, 2];
+        case ">": return [2, 2];
+        case ">=": return [2, 2];
+        case "==": return [2, 2];
+        case "!=": return [2, 2];
+        case "&&": return [2, 2];
+        case "||": return [2, 2];
+        default: return undefined;
+    }
+}
+exports.getOperatorArgumentCountBounds = getOperatorArgumentCountBounds;
+function getOperatorReturnType(token, arg1, arg2) {
+    if (!arg2 && !getUnaryOperator(token))
+        return { errorMessage: `Unary operator "${token}" is not supported.` };
+    if (arg2 && !getBinaryOperator(token))
+        return { errorMessage: `Binary operator "${token}" is not supported.` };
+    if ((arg1 === "undefined" || arg2 === "undefined") && (token !== "==" && token !== "!="))
+        return { errorMessage: `${!arg2 ? "Unary" : "Binary"} operator "${token}" does not support null operands.` };
+    switch (token) {
+        case "**":
+        case "*":
+        case "/":
+        case "%":
+            return arg1 === "string" || arg2 === "string" ?
+                { errorMessage: `Binary operator "${token}" does not support string operands.` } :
+                { value: "number" };
+        case "-":
+            return arg1 === "string" || arg2 === "string" ?
+                { errorMessage: `${!arg2 ? "Unary" : "Binary"} operator "${token}" does not support string operands.` } :
+                { value: "number" };
+        case "+":
+            if (!arg2)
+                return { value: arg1 };
+            else
+                return arg1 === "string" || arg2 === "string" ? { value: "string" } : { value: "number" };
+        case "!":
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+        case "==":
+        case "!=":
+        case "&&":
+        case "||":
+            return { value: "boolean" };
+        default:
+            return { errorMessage: `Operator "${token}" is not supported.` };
+    }
+}
+exports.getOperatorReturnType = getOperatorReturnType;
+//# sourceMappingURL=FormulaOperatorsProvider.js.map

package/lib/cjs/formula/FormulaOperatorsProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaOperatorsProvider.js","sourceRoot":"","sources":["../../../src/formula/FormulaOperatorsProvider.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\nimport type { IResult } from \"./IResult\";\nimport type { DataType, PossibleDataType } from \"./Types\";\n\nconst allOperators = [\"+\", \"-\", \"*\", \"%\", \"**\", \"/\", \"`\", \"~\", \"!\", \"@\", \"#\", \"$\", \"^\", \"&\", \"=\", \"[\", \"]\", \"{\", \"}\", \"\\\\\", \"|\", \";\", \":\", \"'\", \"\\\"\", \"<\", \">\", \"?\", \"+=\", \"-=\", \"*=\", \"/=\", \"%=\", \"&=\", \"^=\", \"|=\", \"?=\", \"==\", \"!=\", \">=\", \"<=\", \"++\", \"--\", \"<<\", \">>\", \"&&\", \"||\", \"??\", \"?.\", \"**=\", \"<<=\", \">>=\", \"&&=\", \"||=\", \"??=\", \"===\", \"!==\", \">>>\", \">>>=\"];\n\nexport enum OperatorType {\n  UnaryPlus,\n  UnaryNegation,\n  Exponentiation,\n  Multiplication,\n  Division,\n  Remainder,\n  Addition,\n  Subtraction,\n  LogicalNot,\n  LessThan,\n  LessThanOrEqual,\n  GreaterThan,\n  GreaterThanOrEqual,\n  Equality,\n  Inequality,\n  LogicalAnd,\n  LogicalOr,\n}\n\nexport enum OperatorAssociativity {\n  Left,\n  Right,\n}\n\nexport function isOperator(token: string): boolean {\n  return allOperators.includes(token);\n}\n\nexport function getBinaryOperator(token: string): OperatorType | undefined {\n  switch (token) {\n    case \"**\": return OperatorType.Exponentiation;\n    case \"*\": return OperatorType.Multiplication;\n    case \"/\": return OperatorType.Division;\n    case \"%\": return OperatorType.Remainder;\n    case \"+\": return OperatorType.Addition;\n    case \"-\": return OperatorType.Subtraction;\n    case \"<\": return OperatorType.LessThan;\n    case \"<=\": return OperatorType.LessThanOrEqual;\n    case \">\": return OperatorType.GreaterThan;\n    case \">=\": return OperatorType.GreaterThanOrEqual;\n    case \"==\": return OperatorType.Equality;\n    case \"!=\": return OperatorType.Inequality;\n    case \"&&\": return OperatorType.LogicalAnd;\n    case \"||\": return OperatorType.LogicalOr;\n    default: return undefined;\n  }\n}\n\nexport function getUnaryOperator(token: string): OperatorType | undefined {\n  switch (token) {\n    case \"+\": return OperatorType.UnaryPlus;\n    case \"-\": return OperatorType.UnaryNegation;\n    case \"!\": return OperatorType.LogicalNot;\n    default: return undefined;\n  }\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence\nexport function getOperatorPrecedence(op: OperatorType | undefined): number {\n  switch (op) {\n    case OperatorType.UnaryPlus:\n    case OperatorType.UnaryNegation:\n    case OperatorType.LogicalNot:\n      return 15;\n    case OperatorType.Exponentiation:\n      return 14;\n    case OperatorType.Multiplication:\n    case OperatorType.Division:\n    case OperatorType.Remainder:\n      return 13;\n    case OperatorType.Subtraction:\n    case OperatorType.Addition:\n      return 12;\n    case OperatorType.LessThan:\n    case OperatorType.LessThanOrEqual:\n    case OperatorType.GreaterThan:\n    case OperatorType.GreaterThanOrEqual:\n      return 10;\n    case OperatorType.Equality:\n    case OperatorType.Inequality:\n      return 9;\n    case OperatorType.LogicalAnd:\n      return 5;\n    case OperatorType.LogicalOr:\n      return 4;\n    default: return 1;\n  }\n}\n\nexport function getOperatorAssociativity(op: OperatorType | undefined): number {\n  switch (op) {\n    case OperatorType.UnaryPlus:\n    case OperatorType.UnaryNegation:\n    case OperatorType.Exponentiation:\n    case OperatorType.LogicalNot:\n      return OperatorAssociativity.Right;\n    case OperatorType.Multiplication:\n    case OperatorType.Division:\n    case OperatorType.Remainder:\n    case OperatorType.Addition:\n    case OperatorType.Subtraction:\n    case OperatorType.LessThan:\n    case OperatorType.LessThanOrEqual:\n    case OperatorType.GreaterThan:\n    case OperatorType.GreaterThanOrEqual:\n    case OperatorType.Equality:\n    case OperatorType.Inequality:\n    case OperatorType.LogicalAnd:\n    case OperatorType.LogicalOr:\n      return OperatorAssociativity.Left;\n    default:\n      return OperatorAssociativity.Left;\n  }\n}\n\nexport function isSupportedOperator(token: string): boolean {\n  return undefined !== getUnaryOperator(token) || undefined !== getBinaryOperator(token);\n}\n\nexport function getOperatorArgumentCountBounds(token: string): [number, number] | undefined {\n  switch (token) {\n    case \"**\": return [2, 2];\n    case \"*\": return [2, 2];\n    case \"/\": return [2, 2];\n    case \"%\": return [2, 2];\n    case \"+\": return [1, 2];\n    case \"-\": return [1, 2];\n    case \"!\": return [1, 1];\n    case \"<\": return [2, 2];\n    case \"<=\": return [2, 2];\n    case \">\": return [2, 2];\n    case \">=\": return [2, 2];\n    case \"==\": return [2, 2];\n    case \"!=\": return [2, 2];\n    case \"&&\": return [2, 2];\n    case \"||\": return [2, 2];\n    default: return undefined;\n  }\n}\n\nexport function getOperatorReturnType(token: string, arg1: PossibleDataType, arg2?: PossibleDataType): IResult<DataType> {\n  if (!arg2 && !getUnaryOperator(token))\n    return { errorMessage: `Unary operator \"${token}\" is not supported.` };\n\n  if (arg2 && !getBinaryOperator(token))\n    return { errorMessage: `Binary operator \"${token}\" is not supported.` };\n\n  if ((arg1 === \"undefined\" || arg2 === \"undefined\") && (token !== \"==\" && token !== \"!=\"))\n    return { errorMessage: `${!arg2 ? \"Unary\" : \"Binary\"} operator \"${token}\" does not support null operands.` };\n\n  switch (token) {\n    case \"**\":\n    case \"*\":\n    case \"/\":\n    case \"%\":\n      return arg1 === \"string\" || arg2 === \"string\" ?\n        { errorMessage: `Binary operator \"${token}\" does not support string operands.` } :\n        { value: \"number\" };\n    case \"-\":\n      return arg1 === \"string\" || arg2 === \"string\" ?\n        { errorMessage: `${!arg2 ? \"Unary\" : \"Binary\"} operator \"${token}\" does not support string operands.` } :\n        { value: \"number\" };\n    case \"+\":\n      if (!arg2)\n        return { value: arg1 as DataType };\n      else\n        return arg1 === \"string\" || arg2 === \"string\" ? { value: \"string\" } : { value: \"number\" };\n    case \"!\":\n    case \"<\":\n    case \"<=\":\n    case \">\":\n    case \">=\":\n    case \"==\":\n    case \"!=\":\n    case \"&&\":\n    case \"||\":\n      return { value: \"boolean\" };\n    default:\n      return { errorMessage: `Operator \"${token}\" is not supported.` };\n  }\n}\n"]}

package/lib/cjs/formula/FormulaSplitter.d.ts

@@ -0,0 +1,2 @@
+export declare function splitFormula(formula: string): string[];
+//# sourceMappingURL=FormulaSplitter.d.ts.map

package/lib/cjs/formula/FormulaSplitter.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitFormula = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+const InputStream_1 = require("./InputStream");
+const StringBuilder_1 = require("./StringBuilder");
+const Utils_1 = require("./Utils");
+const fourSymbolCombinations = [">>>="];
+const threeSymbolCombinations = ["**=", "<<=", ">>=", "&&=", "||=", "??=", "===", "!==", ">>>"];
+const twoSymbolCombinations = ["+=", "-=", "*=", "/=", "%=", "&=", "^=", "|=", "?=", "==", "!=", ">=", "<=", "++", "--", "**", "<<", ">>", "&&", "||", "??", "?."];
+const oneSymbolCombinations = ["~", "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "=", "+", "[", "]", "{", "}", "\\", "|", ";", ":", ",", ".", "<", ">", "/", "?"];
+const symbolCombinations = [
+    fourSymbolCombinations,
+    threeSymbolCombinations,
+    twoSymbolCombinations,
+    oneSymbolCombinations,
+];
+function parseScientificNotation(stream) {
+    const notationBuilder = new StringBuilder_1.StringBuilder();
+    const nextChar = stream.next;
+    const afterEChar = stream.peek;
+    if (Utils_1.isDigit(afterEChar) || afterEChar === "+" || afterEChar === "-") {
+        notationBuilder.push(nextChar);
+        notationBuilder.push(stream.next);
+        while (Utils_1.isDigit(stream.peek)) {
+            notationBuilder.push(stream.next);
+        }
+        if (Utils_1.isDecimalSeparator(stream.peek)) {
+            throw new Error("The exponent in scientific notation must be an integer.");
+        }
+    }
+    else {
+        stream.undo;
+    }
+    return notationBuilder.value;
+}
+function parseNumber(stream) {
+    const numberBuilder = new StringBuilder_1.StringBuilder(stream.current);
+    let hasSeparator = Utils_1.isDecimalSeparator(stream.current);
+    while (true) {
+        const peekedChar = stream.peek;
+        if (peekedChar.toLowerCase() === "e") {
+            numberBuilder.push(parseScientificNotation(stream));
+            break;
+        }
+        if (Utils_1.isDecimalSeparator(peekedChar)) {
+            if (hasSeparator) {
+                throw new Error("A number cannot have multiple decimal separators.");
+            }
+            hasSeparator = true;
+            numberBuilder.push(stream.next);
+            continue;
+        }
+        if (Utils_1.isDigit(peekedChar)) {
+            numberBuilder.push(stream.next);
+        }
+        else {
+            break;
+        }
+    }
+    return numberBuilder.value;
+}
+function unescape(char) {
+    switch (char) {
+        case "n": return "\n";
+        case "t": return "\t";
+        default: return char;
+    }
+}
+function parseStringLiteral(stream) {
+    const stringBuilder = new StringBuilder_1.StringBuilder(stream.current);
+    const delimiter = stream.current;
+    while (stream.next !== delimiter) {
+        if (stream.isEOF) {
+            throw new Error(`Missing closing string delimiter (${delimiter}).`);
+        }
+        stringBuilder.push(stream.current === "\\" ? unescape(stream.next) : stream.current);
+    }
+    stringBuilder.push(stream.current);
+    return stringBuilder.value;
+}
+function parseVariable(stream) {
+    const variableBuilder = new StringBuilder_1.StringBuilder(stream.current);
+    while (Utils_1.isLetterOrUnderscore(stream.peek) || Utils_1.isDigit(stream.peek)) {
+        variableBuilder.push(stream.next);
+    }
+    if (Utils_1.isDecimalSeparator(stream.peek)) {
+        throw new Error("Decimal separator in variable.");
+    }
+    return variableBuilder.value;
+}
+function parseSymbolCombination(stream) {
+    const symbolComboBuilder = new StringBuilder_1.StringBuilder(stream.current);
+    while (symbolComboBuilder.length < symbolCombinations.length && oneSymbolCombinations.includes(stream.peek)) {
+        symbolComboBuilder.push(stream.next);
+    }
+    for (let i = symbolCombinations.length - symbolComboBuilder.length; i < symbolCombinations.length - 1; i++) {
+        const symbolCombo = symbolComboBuilder.value;
+        if (symbolCombinations[i].includes(symbolCombo)) {
+            return symbolCombo;
+        }
+        symbolComboBuilder.pop();
+        stream.undo;
+    }
+    return symbolComboBuilder.value;
+}
+function parseFormula(formula) {
+    const tokens = [];
+    const stream = new InputStream_1.InputStream(formula);
+    while (!stream.isEOF) {
+        const char = stream.next;
+        if (Utils_1.isWhitespace(char)) {
+            continue;
+        }
+        if (Utils_1.isDigit(char) || Utils_1.isDecimalSeparator(char)) {
+            tokens.push(parseNumber(stream));
+        }
+        else if (Utils_1.isLetterOrUnderscore(char)) {
+            tokens.push(parseVariable(stream));
+        }
+        else if (Utils_1.isStringDelimiter(char)) {
+            tokens.push(parseStringLiteral(stream));
+        }
+        else if (oneSymbolCombinations.includes(char)) {
+            tokens.push(parseSymbolCombination(stream));
+        }
+        else {
+            throw new Error(`Unknown symbol received "${char}".`);
+        }
+    }
+    return tokens;
+}
+function splitFormula(formula) {
+    return parseFormula(formula);
+}
+exports.splitFormula = splitFormula;
+//# sourceMappingURL=FormulaSplitter.js.map