@itwin/grouping-mapping-widget 0.3.2 → 0.3.3

package/lib/esm/formula/FormulaTokensValidator.js

@@ -0,0 +1,131 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { getFormulaFunctionReturnType, getFunction } from "./FormulaFunctionProvider";
+import { getOperatorArgumentCountBounds, getOperatorReturnType, isOperator } from "./FormulaOperatorsProvider";
+import { TokenType } from "./InfixToPostfixConverter";
+import { Stack } from "./Stack";
+function isNumericalConstant(name) {
+    return [
+        "e",
+        "ln2",
+        "ln10",
+        "log2e",
+        "log10e",
+        "pi",
+        "sqrt1_2",
+        "sqrt2",
+    ].includes(name.toLowerCase());
+}
+export function validateTokens(tokens, properties) {
+    if (tokens.length === 0)
+        return "Formula cannot be empty.";
+    const argStack = new Stack();
+    while (tokens.length > 0) {
+        const token = tokens.dequeue();
+        switch (token.type) {
+            case TokenType.Number:
+                argStack.push("number");
+                break;
+            case TokenType.String:
+                argStack.push("string");
+                break;
+            case TokenType.Boolean:
+                argStack.push("boolean");
+                break;
+            case TokenType.Null:
+                argStack.push("undefined");
+                break;
+            case TokenType.Variable:
+                const isConstant = isNumericalConstant(token.value);
+                if (isConstant) {
+                    argStack.push("number");
+                }
+                else {
+                    const prop = properties[token.value];
+                    if (!prop)
+                        return `Variable "${token.value}" is not available.`;
+                    argStack.push(prop);
+                }
+                break;
+            case TokenType.Operator:
+                if (!isOperator(token.value))
+                    return `Operator "${token.value}" is not supported.`;
+                const operatorBounds = getOperatorArgumentCountBounds(token.value);
+                if (!operatorBounds)
+                    return `Operator "${token.value}" is not supported.`;
+                if (operatorBounds[0] === 2 && token.argCount === 1)
+                    return `Unary operator "${token.value}" is not supported.`;
+                if (argStack.length < token.argCount) {
+                    return `Too few arguments given for ${token.argCount === 1 ? "unary" : "binary"} operator "${token.value}".`;
+                }
+                const opArgs = argStack.popN(token.argCount).reverse();
+                let operationResult;
+                if (opArgs.length === 1)
+                    operationResult = getOperatorReturnType(token.value, opArgs[0]);
+                else if (opArgs.length === 2)
+                    operationResult = getOperatorReturnType(token.value, opArgs[0], opArgs[1]);
+                else
+                    return `Operator "${token.value}" does not support ${token.argCount} operands.`;
+                if (operationResult.errorMessage)
+                    return operationResult.errorMessage;
+                else
+                    argStack.push(operationResult.value);
+                break;
+            case TokenType.Function:
+                const fnArg = getFunction(token.value);
+                if (!fnArg)
+                    return `Function "${token.value}" is not supported.`;
+                const fnArgBounds = fnArg.argumentCountBounds;
+                if (fnArgBounds[0] === 0 && fnArgBounds[1] === 0 && token.argCount > 0) {
+                    return `Function "${token.value}" does not accept any arguments.`;
+                }
+                else if (fnArgBounds[1] === -1 && token.argCount < fnArgBounds[0]) {
+                    if (fnArgBounds[0] === 1) {
+                        return `Function "${token.value}" requires at least 1 argument.`;
+                    }
+                    else {
+                        if (token.argCount === 1) {
+                            return `Function "${token.value}" requires at least ${fnArgBounds[0]} arguments, but only 1 argument was given.`;
+                        }
+                        else {
+                            return `Function "${token.value}" requires at least ${fnArgBounds[0]} arguments, but only ${token.argCount} arguments were given.`;
+                        }
+                    }
+                }
+                else if (fnArgBounds[0] === fnArgBounds[1] && token.argCount !== fnArgBounds[0]) {
+                    if (fnArgBounds[0] === 1) {
+                        return `Function "${token.value}" requires exactly 1 argument, but ${token.argCount} arguments were given.`;
+                    }
+                    else {
+                        if (token.argCount === 1) {
+                            return `Function "${token.value}" requires exactly ${fnArgBounds[0]} arguments, but 1 argument was given.`;
+                        }
+                        else {
+                            return `Function "${token.value}" requires exactly ${fnArgBounds[0]} arguments, but ${token.argCount} arguments were given.`;
+                        }
+                    }
+                }
+                const fArgs = argStack.popN(token.argCount).reverse();
+                if (fArgs.length < token.argCount) {
+                    return `Too few arguments given for function "${token.value}".`;
+                }
+                const functionResult = getFormulaFunctionReturnType(fnArg, fArgs);
+                if (functionResult.errorMessage)
+                    return `Function "${token.value}" is invalid. ${functionResult.errorMessage}`;
+                else
+                    argStack.push(functionResult.value);
+                break;
+        }
+    }
+    if (argStack.length !== 1) {
+        return "Formula is invalid.";
+    }
+    const resultType = argStack.pop();
+    if (!resultType || resultType === "undefined") {
+        return "Formula cannot always return null.";
+    }
+    return "";
+}
+//# sourceMappingURL=FormulaTokensValidator.js.map

package/lib/esm/formula/FormulaTokensValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaTokensValidator.js","sourceRoot":"","sources":["../../../src/formula/FormulaTokensValidator.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 { getFormulaFunctionReturnType, getFunction } from \"./FormulaFunctionProvider\";\nimport { getOperatorArgumentCountBounds, getOperatorReturnType, isOperator } from \"./FormulaOperatorsProvider\";\nimport type { Token } from \"./InfixToPostfixConverter\";\nimport { TokenType } from \"./InfixToPostfixConverter\";\nimport type { Queue } from \"./Queue\";\nimport { Stack } from \"./Stack\";\nimport type { PossibleDataType, PropertyMap } from \"./Types\";\n\nfunction isNumericalConstant(name: string): boolean {\n  return [\n    \"e\",\n    \"ln2\",\n    \"ln10\",\n    \"log2e\",\n    \"log10e\",\n    \"pi\",\n    \"sqrt1_2\",\n    \"sqrt2\",\n  ].includes(name.toLowerCase());\n}\n\nexport function validateTokens(tokens: Queue<Token>, properties: PropertyMap): string {\n  if (tokens.length === 0)\n    return \"Formula cannot be empty.\";\n\n  const argStack = new Stack<PossibleDataType>();\n\n  while (tokens.length > 0) {\n    const token = tokens.dequeue()!;\n\n    switch (token.type) {\n      case TokenType.Number:\n        argStack.push(\"number\");\n        break;\n      case TokenType.String:\n        argStack.push(\"string\");\n        break;\n      case TokenType.Boolean:\n        argStack.push(\"boolean\");\n        break;\n      case TokenType.Null:\n        argStack.push(\"undefined\");\n        break;\n      case TokenType.Variable:\n        const isConstant = isNumericalConstant(token.value);\n        if (isConstant) {\n          argStack.push(\"number\");\n        } else {\n          const prop = properties[token.value];\n          if (!prop)\n            return `Variable \"${token.value}\" is not available.`;\n          argStack.push(prop);\n        }\n        break;\n      case TokenType.Operator:\n        if (!isOperator(token.value))\n          return `Operator \"${token.value}\" is not supported.`;\n\n        const operatorBounds = getOperatorArgumentCountBounds(token.value);\n        if (!operatorBounds)\n          return `Operator \"${token.value}\" is not supported.`;\n\n        if (operatorBounds[0] === 2 && token.argCount === 1)\n          return `Unary operator \"${token.value}\" is not supported.`;\n\n        if (argStack.length < token.argCount) {\n          return `Too few arguments given for ${token.argCount === 1 ? \"unary\" : \"binary\"} operator \"${token.value}\".`;\n        }\n        const opArgs = argStack.popN(token.argCount).reverse();\n        let operationResult;\n        if (opArgs.length === 1)\n          operationResult = getOperatorReturnType(token.value, opArgs[0]);\n        else if (opArgs.length === 2)\n          operationResult = getOperatorReturnType(token.value, opArgs[0], opArgs[1]);\n        else\n          return `Operator \"${token.value}\" does not support ${token.argCount} operands.`;\n\n        if (operationResult.errorMessage)\n          return operationResult.errorMessage;\n        else\n          argStack.push(operationResult.value!);\n\n        break;\n      case TokenType.Function:\n        const fnArg = getFunction(token.value);\n        if (!fnArg)\n          return `Function \"${token.value}\" is not supported.`;\n\n        const fnArgBounds = fnArg.argumentCountBounds;\n        if (fnArgBounds[0] === 0 && fnArgBounds[1] === 0 && token.argCount > 0) {\n          return `Function \"${token.value}\" does not accept any arguments.`;\n        } else if (fnArgBounds[1] === -1 && token.argCount < fnArgBounds[0]) {\n          if (fnArgBounds[0] === 1) {\n            return `Function \"${token.value}\" requires at least 1 argument.`;\n          } else {\n            if (token.argCount === 1) {\n              return `Function \"${token.value}\" requires at least ${fnArgBounds[0]} arguments, but only 1 argument was given.`;\n            } else {\n              return `Function \"${token.value}\" requires at least ${fnArgBounds[0]} arguments, but only ${token.argCount} arguments were given.`;\n            }\n          }\n        } else if (fnArgBounds[0] === fnArgBounds[1] && token.argCount !== fnArgBounds[0]) {\n          if (fnArgBounds[0] === 1) {\n            return `Function \"${token.value}\" requires exactly 1 argument, but ${token.argCount} arguments were given.`;\n          } else {\n            if (token.argCount === 1) {\n              return `Function \"${token.value}\" requires exactly ${fnArgBounds[0]} arguments, but 1 argument was given.`;\n            } else {\n              return `Function \"${token.value}\" requires exactly ${fnArgBounds[0]} arguments, but ${token.argCount} arguments were given.`;\n            }\n          }\n        }\n\n        const fArgs = argStack.popN(token.argCount).reverse();\n        if (fArgs.length < token.argCount) {\n          return `Too few arguments given for function \"${token.value}\".`;\n        }\n\n        const functionResult = getFormulaFunctionReturnType(fnArg, fArgs);\n        if (functionResult.errorMessage)\n          return `Function \"${token.value}\" is invalid. ${functionResult.errorMessage}`;\n        else\n          argStack.push(functionResult.value!);\n\n        break;\n    }\n  }\n\n  if (argStack.length !== 1) {\n    return \"Formula is invalid.\";\n  }\n\n  const resultType = argStack.pop();\n  if (!resultType || resultType === \"undefined\") {\n    return \"Formula cannot always return null.\";\n  }\n\n  return \"\";\n}\n\n"]}

package/lib/esm/formula/FormulaValidator.d.ts

@@ -0,0 +1,3 @@
+import type { PropertyMap } from "./Types";
+export declare function validateFormula(formula: string, properties: PropertyMap): string;
+//# sourceMappingURL=FormulaValidator.d.ts.map

package/lib/esm/formula/FormulaValidator.js

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { splitFormula } from "./FormulaSplitter";
+import { validateTokens } from "./FormulaTokensValidator";
+import { convertInfixToPostfix } from "./InfixToPostfixConverter";
+import { ParenthesisState, validateParenthesis } from "./ParenthesisValidator";
+export function validateFormula(formula, properties) {
+    var _a;
+    const parenthesisState = validateParenthesis(formula);
+    if (ParenthesisState.NotClosed === parenthesisState) {
+        return "Opened but not closed parenthesis found.";
+    }
+    else if (ParenthesisState.NotOpened === parenthesisState) {
+        return "Closed but not opened parenthesis found.";
+    }
+    let infixFormulaTokens;
+    try {
+        infixFormulaTokens = splitFormula(formula);
+    }
+    catch (ex) {
+        return ex.message;
+    }
+    const postfixFormulaTokens = convertInfixToPostfix(infixFormulaTokens);
+    if (undefined === postfixFormulaTokens.value) {
+        return (_a = postfixFormulaTokens.errorMessage) !== null && _a !== void 0 ? _a : "Unknown error";
+    }
+    return validateTokens(postfixFormulaTokens.value, properties);
+}
+//# sourceMappingURL=FormulaValidator.js.map

package/lib/esm/formula/FormulaValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaValidator.js","sourceRoot":"","sources":["../../../src/formula/FormulaValidator.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAG/E,MAAM,UAAU,eAAe,CAAC,OAAe,EAAE,UAAuB;;IACtE,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACtD,IAAI,gBAAgB,CAAC,SAAS,KAAK,gBAAgB,EAAE;QACnD,OAAO,0CAA0C,CAAC;KACnD;SAAM,IAAI,gBAAgB,CAAC,SAAS,KAAK,gBAAgB,EAAE;QAC1D,OAAO,0CAA0C,CAAC;KACnD;IAED,IAAI,kBAAkB,CAAC;IACvB,IAAI;QACF,kBAAkB,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;KAC5C;IAAC,OAAO,EAAE,EAAE;QACX,OAAQ,EAAY,CAAC,OAAO,CAAC;KAC9B;IAED,MAAM,oBAAoB,GAAG,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;IAEvE,IAAI,SAAS,KAAK,oBAAoB,CAAC,KAAK,EAAE;QAC5C,OAAO,MAAA,oBAAoB,CAAC,YAAY,mCAAI,eAAe,CAAC;KAC7D;IAED,OAAO,cAAc,CAAC,oBAAoB,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;AAChE,CAAC","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 { splitFormula } from \"./FormulaSplitter\";\nimport { validateTokens } from \"./FormulaTokensValidator\";\nimport { convertInfixToPostfix } from \"./InfixToPostfixConverter\";\nimport { ParenthesisState, validateParenthesis } from \"./ParenthesisValidator\";\nimport type { PropertyMap } from \"./Types\";\n\nexport function validateFormula(formula: string, properties: PropertyMap): string {\n  const parenthesisState = validateParenthesis(formula);\n  if (ParenthesisState.NotClosed === parenthesisState) {\n    return \"Opened but not closed parenthesis found.\";\n  } else if (ParenthesisState.NotOpened === parenthesisState) {\n    return \"Closed but not opened parenthesis found.\";\n  }\n\n  let infixFormulaTokens;\n  try {\n    infixFormulaTokens = splitFormula(formula);\n  } catch (ex) {\n    return (ex as Error).message;\n  }\n\n  const postfixFormulaTokens = convertInfixToPostfix(infixFormulaTokens);\n\n  if (undefined === postfixFormulaTokens.value) {\n    return postfixFormulaTokens.errorMessage ?? \"Unknown error\";\n  }\n\n  return validateTokens(postfixFormulaTokens.value, properties);\n}\n"]}

package/lib/esm/formula/IResult.d.ts

@@ -0,0 +1,5 @@
+export interface IResult<T> {
+    value?: T;
+    errorMessage?: string;
+}
+//# sourceMappingURL=IResult.d.ts.map

package/lib/esm/formula/IResult.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IResult.js.map

package/lib/esm/formula/IResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IResult.js","sourceRoot":"","sources":["../../../src/formula/IResult.ts"],"names":[],"mappings":"","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*--------------------------------------------------------------------------------------------*/\nexport interface IResult<T> {\n  value?: T;\n  errorMessage?: string;\n}\n"]}

package/lib/esm/formula/InfixToPostfixConverter.d.ts

@@ -0,0 +1,18 @@
+import type { IResult } from "./IResult";
+import { Queue } from "./Queue";
+export declare enum TokenType {
+    Number = 0,
+    Function = 1,
+    Operator = 2,
+    Variable = 3,
+    String = 4,
+    Boolean = 5,
+    Null = 6
+}
+export interface Token {
+    value: string;
+    type: TokenType;
+    argCount: number;
+}
+export declare function convertInfixToPostfix(infix: string[]): IResult<Queue<Token>>;
+//# sourceMappingURL=InfixToPostfixConverter.d.ts.map

package/lib/esm/formula/InfixToPostfixConverter.js

@@ -0,0 +1,295 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { isFunction } from "./FormulaFunctionProvider";
+import { getBinaryOperator, getOperatorAssociativity, getOperatorPrecedence, getUnaryOperator, isOperator, isSupportedOperator, OperatorAssociativity } from "./FormulaOperatorsProvider";
+import { Queue } from "./Queue";
+import { Stack } from "./Stack";
+import { isStringDelimiter } from "./Utils";
+function isNumber(part) {
+    return !isNaN(Number(part)) || !isNaN(parseFloat(part));
+}
+function isStringLiteral(token) {
+    if (token.length < 2) {
+        return false;
+    }
+    const firstCharacter = token[0];
+    const lastCharacter = token[token.length - 1];
+    return firstCharacter === lastCharacter && isStringDelimiter(firstCharacter);
+}
+function isBoolean(token) {
+    const lower = token.toLowerCase();
+    return lower === "true" || lower === "false";
+}
+function isNull(token) {
+    return token.toLowerCase() === "null";
+}
+export var TokenType;
+(function (TokenType) {
+    TokenType[TokenType["Number"] = 0] = "Number";
+    TokenType[TokenType["Function"] = 1] = "Function";
+    TokenType[TokenType["Operator"] = 2] = "Operator";
+    TokenType[TokenType["Variable"] = 3] = "Variable";
+    TokenType[TokenType["String"] = 4] = "String";
+    TokenType[TokenType["Boolean"] = 5] = "Boolean";
+    TokenType[TokenType["Null"] = 6] = "Null";
+})(TokenType || (TokenType = {}));
+var InternalTokenType;
+(function (InternalTokenType) {
+    InternalTokenType[InternalTokenType["Number"] = 0] = "Number";
+    InternalTokenType[InternalTokenType["Function"] = 1] = "Function";
+    InternalTokenType[InternalTokenType["Operator"] = 2] = "Operator";
+    InternalTokenType[InternalTokenType["Variable"] = 3] = "Variable";
+    InternalTokenType[InternalTokenType["OpeningParenthesis"] = 4] = "OpeningParenthesis";
+    InternalTokenType[InternalTokenType["ClosingParenthesis"] = 5] = "ClosingParenthesis";
+    InternalTokenType[InternalTokenType["ArgumentSeparator"] = 6] = "ArgumentSeparator";
+    InternalTokenType[InternalTokenType["String"] = 7] = "String";
+    InternalTokenType[InternalTokenType["Boolean"] = 8] = "Boolean";
+    InternalTokenType[InternalTokenType["Null"] = 9] = "Null";
+})(InternalTokenType || (InternalTokenType = {}));
+function getExternalQueue(internal) {
+    const external = new Queue();
+    while (internal.length > 0) {
+        const t = internal.dequeue();
+        switch (t.type) {
+            case InternalTokenType.Number:
+                external.enqueue({ value: t.value, type: TokenType.Number, argCount: t.argCount });
+                break;
+            case InternalTokenType.Function:
+                external.enqueue({ value: t.value, type: TokenType.Function, argCount: t.argCount });
+                break;
+            case InternalTokenType.Operator:
+                external.enqueue({ value: t.value, type: TokenType.Operator, argCount: t.argCount });
+                break;
+            case InternalTokenType.Variable:
+                external.enqueue({ value: t.value, type: TokenType.Variable, argCount: t.argCount });
+                break;
+            case InternalTokenType.String:
+                external.enqueue({ value: t.value, type: TokenType.String, argCount: t.argCount });
+                break;
+            case InternalTokenType.Boolean:
+                external.enqueue({ value: t.value, type: TokenType.Boolean, argCount: t.argCount });
+                break;
+            case InternalTokenType.Null:
+                external.enqueue({ value: t.value, type: TokenType.Null, argCount: t.argCount });
+                break;
+            default:
+                return { errorMessage: `Missing closing parenthesis ")".` };
+        }
+    }
+    return { value: external };
+}
+function incrementArgCount(token) {
+    if (!token.argCountIncremented) {
+        token.argCount++;
+        token.argCountIncremented = true;
+    }
+}
+function addOperand(ctx, type) {
+    ctx.resultQueue.enqueue({ value: ctx.currentToken, type, argCount: 0, argCountIncremented: false });
+    const currentOperators = ctx.operatorStack.peekN(2);
+    const op1 = currentOperators[0];
+    if (undefined !== op1) {
+        incrementArgCount(op1);
+        if (op1.argCount === 1) {
+            const op2 = currentOperators[1];
+            if (undefined !== op2 && op2.argCount !== 0) {
+                incrementArgCount(op2);
+            }
+        }
+    }
+}
+const addNumber = (ctx) => {
+    addOperand(ctx, InternalTokenType.Number);
+    return { value: true };
+};
+const addVariable = (ctx) => {
+    ctx = { ...ctx, currentToken: ctx.currentToken.toLowerCase() };
+    if (undefined !== ctx.previousToken && isNumber(ctx.previousToken)) {
+        addOperator({ ...ctx, currentToken: "*" });
+        addOperand({ ...ctx, previousToken: "*" }, InternalTokenType.Variable);
+    }
+    else {
+        addOperand(ctx, InternalTokenType.Variable);
+    }
+    return { value: true };
+};
+const addFunction = (ctx) => {
+    const currentOperator = ctx.operatorStack.peek();
+    if (undefined !== currentOperator) {
+        incrementArgCount(currentOperator);
+    }
+    ctx.operatorStack.push({ value: ctx.currentToken, type: InternalTokenType.Function, argCount: 0, argCountIncremented: false });
+    return { value: true };
+};
+const addOperator = (ctx) => {
+    if (!isSupportedOperator(ctx.currentToken)) {
+        return { errorMessage: `Operator "${ctx.currentToken}" is not supported.` };
+    }
+    const binary = undefined !== ctx.previousToken && "(" !== ctx.previousToken && "," !== ctx.previousToken && !isOperator(ctx.previousToken);
+    const unary = !binary;
+    const op = unary ? getUnaryOperator(ctx.currentToken) : getBinaryOperator(ctx.currentToken);
+    if (unary && undefined === op) {
+        return { errorMessage: `Unary "${ctx.currentToken}" is not supported.` };
+    }
+    const o1 = ctx.currentToken;
+    const o1Associativity = getOperatorAssociativity(op);
+    const o1Precedence = getOperatorPrecedence(op);
+    while (ctx.operatorStack.length > 0) {
+        const o2 = ctx.operatorStack.peek();
+        if (o2.value === "(") {
+            break;
+        }
+        const o2Unary = o2.argCount === 0;
+        const op2 = o2Unary ? getUnaryOperator(o2.value) : getBinaryOperator(o2.value);
+        const o2Precedence = getOperatorPrecedence(op2);
+        if (!(o2Precedence > o1Precedence || (o2Precedence === o1Precedence && o1Associativity === OperatorAssociativity.Left))) {
+            break;
+        }
+        ctx.resultQueue.enqueue(ctx.operatorStack.pop());
+        const currentOperator = ctx.operatorStack.peek();
+        if (undefined !== currentOperator) {
+            incrementArgCount(currentOperator);
+        }
+    }
+    ctx.operatorStack.push({
+        value: o1,
+        type: InternalTokenType.Operator,
+        argCount: binary ? 1 : 0,
+        argCountIncremented: false,
+    });
+    return { value: true };
+};
+const openParenthesis = (ctx) => {
+    if (undefined !== ctx.previousToken) {
+        if (InternalTokenType.Number === ctx.previousTokenType || InternalTokenType.ClosingParenthesis === ctx.previousTokenType) {
+            addOperator({ ...ctx, currentToken: "*" });
+        }
+        else if (InternalTokenType.Variable === ctx.previousTokenType) {
+            return { errorMessage: `Function "${ctx.previousToken}" is not supported.` };
+        }
+    }
+    const currentOperator = ctx.operatorStack.peek();
+    if (undefined !== currentOperator && currentOperator.type !== InternalTokenType.Function) {
+        incrementArgCount(currentOperator);
+    }
+    ctx.operatorStack.push({ value: "(", type: InternalTokenType.OpeningParenthesis, argCount: 0, argCountIncremented: false });
+    return { value: true };
+};
+const closeParenthesis = (ctx) => {
+    while (ctx.operatorStack.length > 0 && ctx.operatorStack.peek().value !== "(") {
+        ctx.resultQueue.enqueue(ctx.operatorStack.pop());
+    }
+    const leftParenthesis = ctx.operatorStack.pop();
+    if (undefined === leftParenthesis) {
+        return { errorMessage: `Closing parenthesis ")" found, but the opening parenthesis "(" is missing.` };
+    }
+    const potentialFnToken = ctx.operatorStack.peek();
+    if (undefined !== potentialFnToken && isFunction(potentialFnToken.value)) {
+        potentialFnToken.argCount = leftParenthesis.argCount;
+        ctx.resultQueue.enqueue(ctx.operatorStack.pop());
+    }
+    return { value: true };
+};
+const addString = (ctx) => {
+    const withoutDelimiters = ctx.currentToken.substring(1, ctx.currentToken.length - 1);
+    addOperand({ ...ctx, currentToken: withoutDelimiters }, InternalTokenType.String);
+    return { value: true };
+};
+const addBoolean = (ctx) => {
+    addOperand({ ...ctx, currentToken: ctx.currentToken.toLowerCase() }, InternalTokenType.Boolean);
+    return { value: true };
+};
+const addNull = (ctx) => {
+    addOperand({ ...ctx, currentToken: ctx.currentToken.toLowerCase() }, InternalTokenType.Null);
+    return { value: true };
+};
+const separateFunctionArgumentSeparator = (ctx) => {
+    while (ctx.operatorStack.length > 0 && ctx.operatorStack.peek().value !== "(") {
+        ctx.resultQueue.enqueue(ctx.operatorStack.pop());
+        const currentOperator = ctx.operatorStack.peek();
+        if (undefined !== currentOperator) {
+            incrementArgCount(currentOperator);
+        }
+    }
+    const last2Operators = ctx.operatorStack.peekN(2);
+    if (last2Operators.length < 2 || last2Operators[0].type !== InternalTokenType.OpeningParenthesis || last2Operators[1].type !== InternalTokenType.Function) {
+        return { errorMessage: `Function argument separator "," found outside of a function call.` };
+    }
+    last2Operators[0].argCountIncremented = false;
+    return { value: true };
+};
+function getTokenType(token, nextToken) {
+    if (isNumber(token)) {
+        return InternalTokenType.Number;
+    }
+    else if (isStringLiteral(token)) {
+        return InternalTokenType.String;
+    }
+    else if (isBoolean(token)) {
+        return InternalTokenType.Boolean;
+    }
+    else if (isNull(token)) {
+        return InternalTokenType.Null;
+    }
+    else if (isFunction(token) && "(" === nextToken) {
+        return InternalTokenType.Function;
+    }
+    else if (isOperator(token)) {
+        return InternalTokenType.Operator;
+    }
+    else if ("(" === token) {
+        return InternalTokenType.OpeningParenthesis;
+    }
+    else if (")" === token) {
+        return InternalTokenType.ClosingParenthesis;
+    }
+    else if ("," === token) {
+        return InternalTokenType.ArgumentSeparator;
+    }
+    else {
+        return InternalTokenType.Variable;
+    }
+}
+const tokenInterpreters = new Map([
+    [InternalTokenType.Number, addNumber],
+    [InternalTokenType.ArgumentSeparator, separateFunctionArgumentSeparator],
+    [InternalTokenType.ClosingParenthesis, closeParenthesis],
+    [InternalTokenType.Function, addFunction],
+    [InternalTokenType.OpeningParenthesis, openParenthesis],
+    [InternalTokenType.Operator, addOperator],
+    [InternalTokenType.Variable, addVariable],
+    [InternalTokenType.String, addString],
+    [InternalTokenType.Boolean, addBoolean],
+    [InternalTokenType.Null, addNull],
+]);
+export function convertInfixToPostfix(infix) {
+    const resultQueue = new Queue();
+    const operatorStack = new Stack();
+    for (let index = 0; index < infix.length; index++) {
+        const token = infix[index];
+        const ctx = {
+            resultQueue,
+            operatorStack,
+            currentToken: token,
+            currentTokenType: getTokenType(token, index < infix.length - 1 ? infix[index + 1] : undefined),
+            previousToken: index > 0 ? infix[index - 1] : undefined,
+            previousTokenType: index > 0 ? getTokenType(infix[index - 1], token) : undefined,
+        };
+        const fn = tokenInterpreters.get(ctx.currentTokenType);
+        const tmpResult = fn(ctx);
+        if (undefined === tmpResult.value) {
+            return { errorMessage: tmpResult.errorMessage };
+        }
+    }
+    while (operatorStack.length > 0) {
+        resultQueue.enqueue(operatorStack.pop());
+        const currentOperator = operatorStack.peek();
+        if (undefined !== currentOperator) {
+            incrementArgCount(currentOperator);
+        }
+    }
+    return getExternalQueue(resultQueue);
+}
+//# sourceMappingURL=InfixToPostfixConverter.js.map

package/lib/esm/formula/InfixToPostfixConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InfixToPostfixConverter.js","sourceRoot":"","sources":["../../../src/formula/InfixToPostfixConverter.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,UAAU,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAE1L,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5C,SAAS,QAAQ,CAAC,IAAY;IAC5B,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;AAC1D,CAAC;AAED,SAAS,eAAe,CAAC,KAAa;IACpC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;QACpB,OAAO,KAAK,CAAC;KACd;IAED,MAAM,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAChC,MAAM,aAAa,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC9C,OAAO,cAAc,KAAK,aAAa,IAAI,iBAAiB,CAAC,cAAc,CAAC,CAAC;AAC/E,CAAC;AAED,SAAS,SAAS,CAAC,KAAa;IAC9B,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;IAClC,OAAO,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,OAAO,CAAC;AAC/C,CAAC;AAED,SAAS,MAAM,CAAC,KAAa;IAC3B,OAAO,KAAK,CAAC,WAAW,EAAE,KAAK,MAAM,CAAC;AACxC,CAAC;AAED,MAAM,CAAN,IAAY,SAQX;AARD,WAAY,SAAS;IACnB,6CAAU,CAAA;IACV,iDAAY,CAAA;IACZ,iDAAY,CAAA;IACZ,iDAAY,CAAA;IACZ,6CAAU,CAAA;IACV,+CAAW,CAAA;IACX,yCAAQ,CAAA;AACV,CAAC,EARW,SAAS,KAAT,SAAS,QAQpB;AAED,IAAK,iBAWJ;AAXD,WAAK,iBAAiB;IACpB,6DAAU,CAAA;IACV,iEAAY,CAAA;IACZ,iEAAY,CAAA;IACZ,iEAAY,CAAA;IACZ,qFAAsB,CAAA;IACtB,qFAAsB,CAAA;IACtB,mFAAqB,CAAA;IACrB,6DAAU,CAAA;IACV,+DAAW,CAAA;IACX,yDAAQ,CAAA;AACV,CAAC,EAXI,iBAAiB,KAAjB,iBAAiB,QAWrB;AAeD,SAAS,gBAAgB,CAAC,QAA8B;IACtD,MAAM,QAAQ,GAAG,IAAI,KAAK,EAAS,CAAC;IACpC,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;QAC1B,MAAM,CAAC,GAAG,QAAQ,CAAC,OAAO,EAAG,CAAC;QAE9B,QAAQ,CAAC,CAAC,IAAI,EAAE;YACd,KAAK,iBAAiB,CAAC,MAAM;gBAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACnF,MAAM;YACR,KAAK,iBAAiB,CAAC,QAAQ;gBAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACrF,MAAM;YACR,KAAK,iBAAiB,CAAC,QAAQ;gBAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACrF,MAAM;YACR,KAAK,iBAAiB,CAAC,QAAQ;gBAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACrF,MAAM;YACR,KAAK,iBAAiB,CAAC,MAAM;gBAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACnF,MAAM;YACR,KAAK,iBAAiB,CAAC,OAAO;gBAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACpF,MAAM;YACR,KAAK,iBAAiB,CAAC,IAAI;gBACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACjF,MAAM;YACR;gBACE,OAAO,EAAE,YAAY,EAAE,kCAAkC,EAAE,CAAC;SAC/D;KACF;IAED,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;AAC7B,CAAC;AAaD,SAAS,iBAAiB,CAAC,KAAoB;IAC7C,IAAI,CAAC,KAAK,CAAC,mBAAmB,EAAE;QAC9B,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjB,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC;KAClC;AACH,CAAC;AAED,SAAS,UAAU,CAAC,GAAsB,EAAE,IAAuB;IACjE,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,mBAAmB,EAAE,KAAK,EAAE,CAAC,CAAC;IAEpG,MAAM,gBAAgB,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACpD,MAAM,GAAG,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAChC,IAAI,SAAS,KAAK,GAAG,EAAE;QACrB,iBAAiB,CAAC,GAAG,CAAC,CAAC;QACvB,IAAI,GAAG,CAAC,QAAQ,KAAK,CAAC,EAAE;YACtB,MAAM,GAAG,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;YAChC,IAAI,SAAS,KAAK,GAAG,IAAI,GAAG,CAAC,QAAQ,KAAK,CAAC,EAAE;gBAC3C,iBAAiB,CAAC,GAAG,CAAC,CAAC;aACxB;SACF;KACF;AACH,CAAC;AAED,MAAM,SAAS,GAAqB,CAAC,GAAsB,EAAE,EAAE;IAC7D,UAAU,CAAC,GAAG,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAC1C,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACzB,CAAC,CAAC;AAEF,MAAM,WAAW,GAAqB,CAAC,GAAsB,EAAE,EAAE;IAC/D,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,YAAY,EAAE,GAAG,CAAC,YAAY,CAAC,WAAW,EAAE,EAAE,CAAC;IAC/D,IAAI,SAAS,KAAK,GAAG,CAAC,aAAa,IAAI,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;QAClE,WAAW,CAAC,EAAE,GAAG,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,CAAC;QAC3C,UAAU,CAAC,EAAE,GAAG,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAC;KACxE;SAAM;QACL,UAAU,CAAC,GAAG,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAC;KAC7C;IACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACzB,CAAC,CAAC;AAEF,MAAM,WAAW,GAAqB,CAAC,GAAsB,EAAE,EAAE;IAC/D,MAAM,eAAe,GAAG,GAAG,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IACjD,IAAI,SAAS,KAAK,eAAe,EAAE;QACjC,iBAAiB,CAAC,eAAe,CAAC,CAAC;KACpC;IAED,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,EAAE,mBAAmB,EAAE,KAAK,EAAE,CAAC,CAAC;IAC/H,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACzB,CAAC,CAAC;AAEF,MAAM,WAAW,GAAqB,CAAC,GAAsB,EAAE,EAAE;IAC/D,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;QAC1C,OAAO,EAAE,YAAY,EAAE,aAAa,GAAG,CAAC,YAAY,qBAAqB,EAAE,CAAC;KAC7E;IAED,MAAM,MAAM,GAAG,SAAS,KAAK,GAAG,CAAC,aAAa,IAAI,GAAG,KAAK,GAAG,CAAC,aAAa,IAAI,GAAG,KAAK,GAAG,CAAC,aAAa,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;IAC3I,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC;IAEtB,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,gBAAgB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAC5F,IAAI,KAAK,IAAI,SAAS,KAAK,EAAE,EAAE;QAC7B,OAAO,EAAE,YAAY,EAAE,UAAU,GAAG,CAAC,YAAY,qBAAqB,EAAE,CAAC;KAC1E;IAED,MAAM,EAAE,GAAG,GAAG,CAAC,YAAY,CAAC;IAC5B,MAAM,eAAe,GAAG,wBAAwB,CAAC,EAAE,CAAC,CAAC;IACrD,MAAM,YAAY,GAAG,qBAAqB,CAAC,EAAE,CAAC,CAAC;IAC/C,OAAO,GAAG,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;QACnC,MAAM,EAAE,GAAG,GAAG,CAAC,aAAa,CAAC,IAAI,EAAG,CAAC;QAErC,IAAI,EAAE,CAAC,KAAK,KAAK,GAAG,EAAE;YACpB,MAAM;SACP;QAED,MAAM,OAAO,GAAG,EAAE,CAAC,QAAQ,KAAK,CAAC,CAAC;QAClC,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAC/E,MAAM,YAAY,GAAG,qBAAqB,CAAC,GAAG,CAAC,CAAC;QAChD,IAAI,CAAC,CAAC,YAAY,GAAG,YAAY,IAAI,CAAC,YAAY,KAAK,YAAY,IAAI,eAAe,KAAK,qBAAqB,CAAC,IAAI,CAAC,CAAC,EAAE;YACvH,MAAM;SACP;QAED,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,EAAG,CAAC,CAAC;QAElD,MAAM,eAAe,GAAG,GAAG,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QACjD,IAAI,SAAS,KAAK,eAAe,EAAE;YACjC,iBAAiB,CAAC,eAAe,CAAC,CAAC;SACpC;KACF;IAED,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC;QACrB,KAAK,EAAE,EAAE;QACT,IAAI,EAAE,iBAAiB,CAAC,QAAQ;QAChC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACxB,mBAAmB,EAAE,KAAK;KAC3B,CAAC,CAAC;IAEH,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACzB,CAAC,CAAC;AAEF,MAAM,eAAe,GAAqB,CAAC,GAAsB,EAAE,EAAE;IACnE,IAAI,SAAS,KAAK,GAAG,CAAC,aAAa,EAAE;QACnC,IAAI,iBAAiB,CAAC,MAAM,KAAK,GAAG,CAAC,iBAAiB,IAAI,iBAAiB,CAAC,kBAAkB,KAAK,GAAG,CAAC,iBAAiB,EAAE;YACxH,WAAW,CAAC,EAAE,GAAG,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,CAAC;SAC5C;aAAM,IAAI,iBAAiB,CAAC,QAAQ,KAAK,GAAG,CAAC,iBAAiB,EAAE;YAC/D,OAAO,EAAE,YAAY,EAAE,aAAa,GAAG,CAAC,aAAa,qBAAqB,EAAE,CAAC;SAC9E;KACF;IAED,MAAM,eAAe,GAAG,GAAG,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IACjD,IAAI,SAAS,KAAK,eAAe,IAAI,eAAe,CAAC,IAAI,KAAK,iBAAiB,CAAC,QAAQ,EAAE;QACxF,iBAAiB,CAAC,eAAe,CAAC,CAAC;KACpC;IAED,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,iBAAiB,CAAC,kBAAkB,EAAE,QAAQ,EAAE,CAAC,EAAE,mBAAmB,EAAE,KAAK,EAAE,CAAC,CAAC;IAC5H,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACzB,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAqB,CAAC,GAAsB,EAAE,EAAE;IACpE,OAAO,GAAG,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,IAAI,GAAG,CAAC,aAAa,CAAC,IAAI,EAAG,CAAC,KAAK,KAAK,GAAG,EAAE;QAC9E,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,EAAG,CAAC,CAAC;KACnD;IAED,MAAM,eAAe,GAAG,GAAG,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;IAChD,IAAI,SAAS,KAAK,eAAe,EAAE;QACjC,OAAO,EAAE,YAAY,EAAE,4EAA4E,EAAE,CAAC;KACvG;IAED,MAAM,gBAAgB,GAAG,GAAG,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IAClD,IAAI,SAAS,KAAK,gBAAgB,IAAI,UAAU,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE;QACxE,gBAAgB,CAAC,QAAQ,GAAG,eAAe,CAAC,QAAQ,CAAC;QACrD,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,EAAG,CAAC,CAAC;KACnD;IAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACzB,CAAC,CAAC;AAEF,MAAM,SAAS,GAAqB,CAAC,GAAsB,EAAE,EAAE;IAC7D,MAAM,iBAAiB,GAAG,GAAG,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACrF,UAAU,CAAC,EAAE,GAAG,GAAG,EAAE,YAAY,EAAE,iBAAiB,EAAE,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAClF,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACzB,CAAC,CAAC;AAEF,MAAM,UAAU,GAAqB,CAAC,GAAsB,EAAE,EAAE;IAC9D,UAAU,CAAC,EAAE,GAAG,GAAG,EAAE,YAAY,EAAE,GAAG,CAAC,YAAY,CAAC,WAAW,EAAE,EAAE,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAChG,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACzB,CAAC,CAAC;AAEF,MAAM,OAAO,GAAqB,CAAC,GAAsB,EAAE,EAAE;IAC3D,UAAU,CAAC,EAAE,GAAG,GAAG,EAAE,YAAY,EAAE,GAAG,CAAC,YAAY,CAAC,WAAW,EAAE,EAAE,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC7F,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACzB,CAAC,CAAC;AAEF,MAAM,iCAAiC,GAAqB,CAAC,GAAsB,EAAE,EAAE;IACrF,OAAO,GAAG,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,IAAI,GAAG,CAAC,aAAa,CAAC,IAAI,EAAG,CAAC,KAAK,KAAK,GAAG,EAAE;QAC9E,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,EAAG,CAAC,CAAC;QAElD,MAAM,eAAe,GAAG,GAAG,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QACjD,IAAI,SAAS,KAAK,eAAe,EAAE;YACjC,iBAAiB,CAAC,eAAe,CAAC,CAAC;SACpC;KACF;IAED,MAAM,cAAc,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClD,IAAI,cAAc,CAAC,MAAM,GAAG,CAAC,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,iBAAiB,CAAC,kBAAkB,IAAI,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,iBAAiB,CAAC,QAAQ,EAAE;QACzJ,OAAO,EAAE,YAAY,EAAE,mEAAmE,EAAE,CAAC;KAC9F;IAED,cAAc,CAAC,CAAC,CAAC,CAAC,mBAAmB,GAAG,KAAK,CAAC;IAC9C,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AACzB,CAAC,CAAC;AAEF,SAAS,YAAY,CAAC,KAAa,EAAE,SAA6B;IAChE,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE;QACnB,OAAO,iBAAiB,CAAC,MAAM,CAAC;KACjC;SAAM,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE;QACjC,OAAO,iBAAiB,CAAC,MAAM,CAAC;KACjC;SAAM,IAAI,SAAS,CAAC,KAAK,CAAC,EAAE;QAC3B,OAAO,iBAAiB,CAAC,OAAO,CAAC;KAClC;SAAM,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE;QACxB,OAAO,iBAAiB,CAAC,IAAI,CAAC;KAC/B;SAAM,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,GAAG,KAAK,SAAS,EAAE;QACjD,OAAO,iBAAiB,CAAC,QAAQ,CAAC;KACnC;SAAM,IAAI,UAAU,CAAC,KAAK,CAAC,EAAE;QAC5B,OAAO,iBAAiB,CAAC,QAAQ,CAAC;KACnC;SAAM,IAAI,GAAG,KAAK,KAAK,EAAE;QACxB,OAAO,iBAAiB,CAAC,kBAAkB,CAAC;KAC7C;SAAM,IAAI,GAAG,KAAK,KAAK,EAAE;QACxB,OAAO,iBAAiB,CAAC,kBAAkB,CAAC;KAC7C;SAAM,IAAI,GAAG,KAAK,KAAK,EAAE;QACxB,OAAO,iBAAiB,CAAC,iBAAiB,CAAC;KAC5C;SAAM;QACL,OAAO,iBAAiB,CAAC,QAAQ,CAAC;KACnC;AACH,CAAC;AAED,MAAM,iBAAiB,GAA6C,IAAI,GAAG,CAAC;IAC1E,CAAC,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC;IACrC,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,iCAAiC,CAAC;IACxE,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,gBAAgB,CAAC;IACxD,CAAC,iBAAiB,CAAC,QAAQ,EAAE,WAAW,CAAC;IACzC,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,eAAe,CAAC;IACvD,CAAC,iBAAiB,CAAC,QAAQ,EAAE,WAAW,CAAC;IACzC,CAAC,iBAAiB,CAAC,QAAQ,EAAE,WAAW,CAAC;IACzC,CAAC,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC;IACrC,CAAC,iBAAiB,CAAC,OAAO,EAAE,UAAU,CAAC;IACvC,CAAC,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC;CAClC,CAAC,CAAC;AAEH,MAAM,UAAU,qBAAqB,CAAC,KAAe;IACnD,MAAM,WAAW,GAAG,IAAI,KAAK,EAAiB,CAAC;IAC/C,MAAM,aAAa,GAAG,IAAI,KAAK,EAAiB,CAAC;IAEjD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;QACjD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAE3B,MAAM,GAAG,GAAsB;YAC7B,WAAW;YACX,aAAa;YACb,YAAY,EAAE,KAAK;YACnB,gBAAgB,EAAE,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC9F,aAAa,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;YACvD,iBAAiB,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS;SACjF,CAAC;QAEF,MAAM,EAAE,GAAG,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,gBAAgB,CAAE,CAAC;QAExD,MAAM,SAAS,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;QAC1B,IAAI,SAAS,KAAK,SAAS,CAAC,KAAK,EAAE;YACjC,OAAO,EAAE,YAAY,EAAE,SAAS,CAAC,YAAY,EAAE,CAAC;SACjD;KACF;IAED,OAAO,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;QAC/B,WAAW,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,EAAG,CAAC,CAAC;QAE1C,MAAM,eAAe,GAAG,aAAa,CAAC,IAAI,EAAE,CAAC;QAC7C,IAAI,SAAS,KAAK,eAAe,EAAE;YACjC,iBAAiB,CAAC,eAAe,CAAC,CAAC;SACpC;KACF;IAED,OAAO,gBAAgB,CAAC,WAAW,CAAC,CAAC;AACvC,CAAC","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 { isFunction } from \"./FormulaFunctionProvider\";\nimport { getBinaryOperator, getOperatorAssociativity, getOperatorPrecedence, getUnaryOperator, isOperator, isSupportedOperator, OperatorAssociativity } from \"./FormulaOperatorsProvider\";\nimport type { IResult } from \"./IResult\";\nimport { Queue } from \"./Queue\";\nimport { Stack } from \"./Stack\";\nimport { isStringDelimiter } from \"./Utils\";\n\nfunction isNumber(part: string): boolean {\n  return !isNaN(Number(part)) || !isNaN(parseFloat(part));\n}\n\nfunction isStringLiteral(token: string): boolean {\n  if (token.length < 2) {\n    return false;\n  }\n\n  const firstCharacter = token[0];\n  const lastCharacter = token[token.length - 1];\n  return firstCharacter === lastCharacter && isStringDelimiter(firstCharacter);\n}\n\nfunction isBoolean(token: string): boolean {\n  const lower = token.toLowerCase();\n  return lower === \"true\" || lower === \"false\";\n}\n\nfunction isNull(token: string): boolean {\n  return token.toLowerCase() === \"null\";\n}\n\nexport enum TokenType {\n  Number = 0,\n  Function = 1,\n  Operator = 2,\n  Variable = 3,\n  String = 4,\n  Boolean = 5,\n  Null = 6,\n}\n\nenum InternalTokenType {\n  Number = 0,\n  Function = 1,\n  Operator = 2,\n  Variable = 3,\n  OpeningParenthesis = 4,\n  ClosingParenthesis = 5,\n  ArgumentSeparator = 6,\n  String = 7,\n  Boolean = 8,\n  Null = 9,\n}\n\nexport interface Token {\n  value: string;\n  type: TokenType;\n  argCount: number;\n}\n\ninterface InternalToken {\n  value: string;\n  type: InternalTokenType;\n  argCount: number;\n  argCountIncremented: boolean;\n}\n\nfunction getExternalQueue(internal: Queue<InternalToken>): IResult<Queue<Token>> {\n  const external = new Queue<Token>();\n  while (internal.length > 0) {\n    const t = internal.dequeue()!;\n\n    switch (t.type) {\n      case InternalTokenType.Number:\n        external.enqueue({ value: t.value, type: TokenType.Number, argCount: t.argCount });\n        break;\n      case InternalTokenType.Function:\n        external.enqueue({ value: t.value, type: TokenType.Function, argCount: t.argCount });\n        break;\n      case InternalTokenType.Operator:\n        external.enqueue({ value: t.value, type: TokenType.Operator, argCount: t.argCount });\n        break;\n      case InternalTokenType.Variable:\n        external.enqueue({ value: t.value, type: TokenType.Variable, argCount: t.argCount });\n        break;\n      case InternalTokenType.String:\n        external.enqueue({ value: t.value, type: TokenType.String, argCount: t.argCount });\n        break;\n      case InternalTokenType.Boolean:\n        external.enqueue({ value: t.value, type: TokenType.Boolean, argCount: t.argCount });\n        break;\n      case InternalTokenType.Null:\n        external.enqueue({ value: t.value, type: TokenType.Null, argCount: t.argCount });\n        break;\n      default:\n        return { errorMessage: `Missing closing parenthesis \")\".` };\n    }\n  }\n\n  return { value: external };\n}\n\ninterface IConverterContext {\n  resultQueue: Queue<InternalToken>;\n  operatorStack: Stack<InternalToken>;\n  currentToken: string;\n  currentTokenType: InternalTokenType;\n  previousToken?: string;\n  previousTokenType?: InternalTokenType;\n}\n\ntype TokenInterpreter = (ctx: IConverterContext) => IResult<boolean>;\n\nfunction incrementArgCount(token: InternalToken) {\n  if (!token.argCountIncremented) {\n    token.argCount++;\n    token.argCountIncremented = true;\n  }\n}\n\nfunction addOperand(ctx: IConverterContext, type: InternalTokenType) {\n  ctx.resultQueue.enqueue({ value: ctx.currentToken, type, argCount: 0, argCountIncremented: false });\n\n  const currentOperators = ctx.operatorStack.peekN(2);\n  const op1 = currentOperators[0];\n  if (undefined !== op1) {\n    incrementArgCount(op1);\n    if (op1.argCount === 1) {\n      const op2 = currentOperators[1];\n      if (undefined !== op2 && op2.argCount !== 0) {\n        incrementArgCount(op2);\n      }\n    }\n  }\n}\n\nconst addNumber: TokenInterpreter = (ctx: IConverterContext) => {\n  addOperand(ctx, InternalTokenType.Number);\n  return { value: true };\n};\n\nconst addVariable: TokenInterpreter = (ctx: IConverterContext) => {\n  ctx = { ...ctx, currentToken: ctx.currentToken.toLowerCase() };\n  if (undefined !== ctx.previousToken && isNumber(ctx.previousToken)) {\n    addOperator({ ...ctx, currentToken: \"*\" });\n    addOperand({ ...ctx, previousToken: \"*\" }, InternalTokenType.Variable);\n  } else {\n    addOperand(ctx, InternalTokenType.Variable);\n  }\n  return { value: true };\n};\n\nconst addFunction: TokenInterpreter = (ctx: IConverterContext) => {\n  const currentOperator = ctx.operatorStack.peek();\n  if (undefined !== currentOperator) {\n    incrementArgCount(currentOperator);\n  }\n\n  ctx.operatorStack.push({ value: ctx.currentToken, type: InternalTokenType.Function, argCount: 0, argCountIncremented: false });\n  return { value: true };\n};\n\nconst addOperator: TokenInterpreter = (ctx: IConverterContext) => {\n  if (!isSupportedOperator(ctx.currentToken)) {\n    return { errorMessage: `Operator \"${ctx.currentToken}\" is not supported.` };\n  }\n\n  const binary = undefined !== ctx.previousToken && \"(\" !== ctx.previousToken && \",\" !== ctx.previousToken && !isOperator(ctx.previousToken);\n  const unary = !binary;\n\n  const op = unary ? getUnaryOperator(ctx.currentToken) : getBinaryOperator(ctx.currentToken);\n  if (unary && undefined === op) {\n    return { errorMessage: `Unary \"${ctx.currentToken}\" is not supported.` };\n  }\n\n  const o1 = ctx.currentToken;\n  const o1Associativity = getOperatorAssociativity(op);\n  const o1Precedence = getOperatorPrecedence(op);\n  while (ctx.operatorStack.length > 0) {\n    const o2 = ctx.operatorStack.peek()!;\n\n    if (o2.value === \"(\") {\n      break;\n    }\n\n    const o2Unary = o2.argCount === 0;\n    const op2 = o2Unary ? getUnaryOperator(o2.value) : getBinaryOperator(o2.value);\n    const o2Precedence = getOperatorPrecedence(op2);\n    if (!(o2Precedence > o1Precedence || (o2Precedence === o1Precedence && o1Associativity === OperatorAssociativity.Left))) {\n      break;\n    }\n\n    ctx.resultQueue.enqueue(ctx.operatorStack.pop()!);\n\n    const currentOperator = ctx.operatorStack.peek();\n    if (undefined !== currentOperator) {\n      incrementArgCount(currentOperator);\n    }\n  }\n\n  ctx.operatorStack.push({\n    value: o1,\n    type: InternalTokenType.Operator,\n    argCount: binary ? 1 : 0,\n    argCountIncremented: false,\n  });\n\n  return { value: true };\n};\n\nconst openParenthesis: TokenInterpreter = (ctx: IConverterContext) => {\n  if (undefined !== ctx.previousToken) {\n    if (InternalTokenType.Number === ctx.previousTokenType || InternalTokenType.ClosingParenthesis === ctx.previousTokenType) {\n      addOperator({ ...ctx, currentToken: \"*\" });\n    } else if (InternalTokenType.Variable === ctx.previousTokenType) {\n      return { errorMessage: `Function \"${ctx.previousToken}\" is not supported.` };\n    }\n  }\n\n  const currentOperator = ctx.operatorStack.peek();\n  if (undefined !== currentOperator && currentOperator.type !== InternalTokenType.Function) {\n    incrementArgCount(currentOperator);\n  }\n\n  ctx.operatorStack.push({ value: \"(\", type: InternalTokenType.OpeningParenthesis, argCount: 0, argCountIncremented: false });\n  return { value: true };\n};\n\nconst closeParenthesis: TokenInterpreter = (ctx: IConverterContext) => {\n  while (ctx.operatorStack.length > 0 && ctx.operatorStack.peek()!.value !== \"(\") {\n    ctx.resultQueue.enqueue(ctx.operatorStack.pop()!);\n  }\n\n  const leftParenthesis = ctx.operatorStack.pop();\n  if (undefined === leftParenthesis) {\n    return { errorMessage: `Closing parenthesis \")\" found, but the opening parenthesis \"(\" is missing.` };\n  }\n\n  const potentialFnToken = ctx.operatorStack.peek();\n  if (undefined !== potentialFnToken && isFunction(potentialFnToken.value)) {\n    potentialFnToken.argCount = leftParenthesis.argCount;\n    ctx.resultQueue.enqueue(ctx.operatorStack.pop()!);\n  }\n\n  return { value: true };\n};\n\nconst addString: TokenInterpreter = (ctx: IConverterContext) => {\n  const withoutDelimiters = ctx.currentToken.substring(1, ctx.currentToken.length - 1);\n  addOperand({ ...ctx, currentToken: withoutDelimiters }, InternalTokenType.String);\n  return { value: true };\n};\n\nconst addBoolean: TokenInterpreter = (ctx: IConverterContext) => {\n  addOperand({ ...ctx, currentToken: ctx.currentToken.toLowerCase() }, InternalTokenType.Boolean);\n  return { value: true };\n};\n\nconst addNull: TokenInterpreter = (ctx: IConverterContext) => {\n  addOperand({ ...ctx, currentToken: ctx.currentToken.toLowerCase() }, InternalTokenType.Null);\n  return { value: true };\n};\n\nconst separateFunctionArgumentSeparator: TokenInterpreter = (ctx: IConverterContext) => {\n  while (ctx.operatorStack.length > 0 && ctx.operatorStack.peek()!.value !== \"(\") {\n    ctx.resultQueue.enqueue(ctx.operatorStack.pop()!);\n\n    const currentOperator = ctx.operatorStack.peek();\n    if (undefined !== currentOperator) {\n      incrementArgCount(currentOperator);\n    }\n  }\n\n  const last2Operators = ctx.operatorStack.peekN(2);\n  if (last2Operators.length < 2 || last2Operators[0].type !== InternalTokenType.OpeningParenthesis || last2Operators[1].type !== InternalTokenType.Function) {\n    return { errorMessage: `Function argument separator \",\" found outside of a function call.` };\n  }\n\n  last2Operators[0].argCountIncremented = false;\n  return { value: true };\n};\n\nfunction getTokenType(token: string, nextToken: string | undefined): InternalTokenType {\n  if (isNumber(token)) {\n    return InternalTokenType.Number;\n  } else if (isStringLiteral(token)) {\n    return InternalTokenType.String;\n  } else if (isBoolean(token)) {\n    return InternalTokenType.Boolean;\n  } else if (isNull(token)) {\n    return InternalTokenType.Null;\n  } else if (isFunction(token) && \"(\" === nextToken) {\n    return InternalTokenType.Function;\n  } else if (isOperator(token)) {\n    return InternalTokenType.Operator;\n  } else if (\"(\" === token) {\n    return InternalTokenType.OpeningParenthesis;\n  } else if (\")\" === token) {\n    return InternalTokenType.ClosingParenthesis;\n  } else if (\",\" === token) {\n    return InternalTokenType.ArgumentSeparator;\n  } else {\n    return InternalTokenType.Variable;\n  }\n}\n\nconst tokenInterpreters: Map<InternalTokenType, TokenInterpreter> = new Map([\n  [InternalTokenType.Number, addNumber],\n  [InternalTokenType.ArgumentSeparator, separateFunctionArgumentSeparator],\n  [InternalTokenType.ClosingParenthesis, closeParenthesis],\n  [InternalTokenType.Function, addFunction],\n  [InternalTokenType.OpeningParenthesis, openParenthesis],\n  [InternalTokenType.Operator, addOperator],\n  [InternalTokenType.Variable, addVariable],\n  [InternalTokenType.String, addString],\n  [InternalTokenType.Boolean, addBoolean],\n  [InternalTokenType.Null, addNull],\n]);\n\nexport function convertInfixToPostfix(infix: string[]): IResult<Queue<Token>> {\n  const resultQueue = new Queue<InternalToken>();\n  const operatorStack = new Stack<InternalToken>();\n\n  for (let index = 0; index < infix.length; index++) {\n    const token = infix[index];\n\n    const ctx: IConverterContext = {\n      resultQueue,\n      operatorStack,\n      currentToken: token,\n      currentTokenType: getTokenType(token, index < infix.length - 1 ? infix[index + 1] : undefined),\n      previousToken: index > 0 ? infix[index - 1] : undefined,\n      previousTokenType: index > 0 ? getTokenType(infix[index - 1], token) : undefined,\n    };\n\n    const fn = tokenInterpreters.get(ctx.currentTokenType)!;\n\n    const tmpResult = fn(ctx);\n    if (undefined === tmpResult.value) {\n      return { errorMessage: tmpResult.errorMessage };\n    }\n  }\n\n  while (operatorStack.length > 0) {\n    resultQueue.enqueue(operatorStack.pop()!);\n\n    const currentOperator = operatorStack.peek();\n    if (undefined !== currentOperator) {\n      incrementArgCount(currentOperator);\n    }\n  }\n\n  return getExternalQueue(resultQueue);\n}\n"]}

package/lib/esm/formula/InputStream.d.ts

@@ -0,0 +1,12 @@
+export declare class InputStream {
+    private readonly _stream;
+    private _nextIndex;
+    private _current;
+    constructor(_stream: string);
+    get next(): string;
+    get undo(): string;
+    get current(): string;
+    get peek(): string;
+    get isEOF(): boolean;
+}
+//# sourceMappingURL=InputStream.d.ts.map

package/lib/esm/formula/InputStream.js

@@ -0,0 +1,32 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+export class InputStream {
+    constructor(_stream) {
+        this._stream = _stream;
+        this._nextIndex = 0;
+        this._current = "";
+    }
+    get next() {
+        this._current = this.isEOF ? "" : this._stream[this._nextIndex++];
+        return this.current;
+    }
+    get undo() {
+        if (this._nextIndex === 0)
+            return this.current;
+        this._nextIndex--;
+        this._current = this._nextIndex === 0 ? "" : this._stream[this._nextIndex - 1];
+        return this.current;
+    }
+    get current() {
+        return this._current;
+    }
+    get peek() {
+        return this.isEOF ? "" : this._stream[this._nextIndex];
+    }
+    get isEOF() {
+        return this._nextIndex >= this._stream.length;
+    }
+}
+//# sourceMappingURL=InputStream.js.map

package/lib/esm/formula/InputStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputStream.js","sourceRoot":"","sources":["../../../src/formula/InputStream.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F,MAAM,OAAO,WAAW;IAItB,YAA6B,OAAe;QAAf,YAAO,GAAP,OAAO,CAAQ;QAHpC,eAAU,GAAG,CAAC,CAAC;QACf,aAAQ,GAAG,EAAE,CAAC;IAE0B,CAAC;IAEjD,IAAW,IAAI;QACb,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QAClE,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,IAAW,IAAI;QACb,IAAI,IAAI,CAAC,UAAU,KAAK,CAAC;YACvB,OAAO,IAAI,CAAC,OAAO,CAAC;QAEtB,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,UAAU,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;QAC/E,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACzD,CAAC;IAED,IAAW,KAAK;QACd,OAAO,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;IAChD,CAAC;CACF","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*--------------------------------------------------------------------------------------------*/\nexport class InputStream {\n  private _nextIndex = 0;\n  private _current = \"\";\n\n  constructor(private readonly _stream: string) { }\n\n  public get next(): string {\n    this._current = this.isEOF ? \"\" : this._stream[this._nextIndex++];\n    return this.current;\n  }\n\n  public get undo(): string {\n    if (this._nextIndex === 0)\n      return this.current;\n\n    this._nextIndex--;\n    this._current = this._nextIndex === 0 ? \"\" : this._stream[this._nextIndex - 1];\n    return this.current;\n  }\n\n  public get current(): string {\n    return this._current;\n  }\n\n  public get peek(): string {\n    return this.isEOF ? \"\" : this._stream[this._nextIndex];\n  }\n\n  public get isEOF(): boolean {\n    return this._nextIndex >= this._stream.length;\n  }\n}\n"]}

package/lib/esm/formula/ParenthesisValidator.d.ts

@@ -0,0 +1,7 @@
+export declare enum ParenthesisState {
+    Valid = 0,
+    NotClosed = 1,
+    NotOpened = 2
+}
+export declare function validateParenthesis(infixFormula: string): ParenthesisState;
+//# sourceMappingURL=ParenthesisValidator.d.ts.map