@ricsam/formula-engine 0.0.1

package/dist/mjs/functions/text/mid/mid.mjs

@@ -0,0 +1,75 @@
+// src/functions/text/mid/mid.ts
+import {
+  FormulaError
+} from "src/core/types";
+import { midOperation, createMidSpilledResult } from "../text-helpers.mjs";
+var MID = {
+  name: "MID",
+  evaluate: function(node, context) {
+    if (node.args.length !== 3) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "MID function takes exactly 3 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const textResult = this.evaluateNode(node.args[0], context);
+    if (textResult.type === "error" || textResult.type === "awaiting-evaluation") {
+      return textResult;
+    }
+    const startNumResult = this.evaluateNode(node.args[1], context);
+    if (startNumResult.type === "error" || startNumResult.type === "awaiting-evaluation") {
+      return startNumResult;
+    }
+    const numCharsResult = this.evaluateNode(node.args[2], context);
+    if (numCharsResult.type === "error" || numCharsResult.type === "awaiting-evaluation") {
+      return numCharsResult;
+    }
+    if (textResult.type === "spilled-values" || startNumResult.type === "spilled-values" || numCharsResult.type === "spilled-values") {
+      return createMidSpilledResult.call(this, {
+        textResult,
+        startNumResult,
+        numCharsResult,
+        context
+      });
+    }
+    if (textResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "Text argument must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (startNumResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "Start_num argument must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (numCharsResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "Num_chars argument must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    const result = midOperation(textResult, startNumResult, numCharsResult, context);
+    if (result.type === "error" || result.type === "awaiting-evaluation") {
+      return result;
+    }
+    return {
+      type: "value",
+      result: result.result
+    };
+  }
+};
+export {
+  MID
+};
+
+//# debugId=F4075A7448E40AEC64756E2164756E21

package/dist/mjs/functions/text/mid/mid.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/text/mid/mid.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport { midOperation, createMidSpilledResult } from \"../text-helpers.mjs\";\n\n/**\n * MID function - Returns characters from the middle of a text string\n *\n * Usage: MID(text, start_num, num_chars)\n *\n * text: The text string to extract characters from.\n * start_num: The position of the first character to extract (1-based).\n * num_chars: The number of characters to extract.\n *\n * Example: MID(\"Hello, World!\", 8, 5) returns \"World\"\n *\n * Note:\n * - If start_num is less than 1, the function returns an error.\n * - If num_chars is less than 0, the function returns an error.\n * - If start_num is greater than the length of text, the function returns an empty string.\n * - Supports dynamic arrays (spilled values) for all arguments\n * - Strict type checking: text must be string, start_num and num_chars must be numbers\n */\nexport const MID: FunctionDefinition = {\n  name: \"MID\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length !== 3) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"MID function takes exactly 3 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate the text argument\n    const textResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      textResult.type === \"error\" ||\n      textResult.type === \"awaiting-evaluation\"\n    ) {\n      return textResult;\n    }\n\n    // Evaluate the start_num argument\n    const startNumResult = this.evaluateNode(node.args[1]!, context);\n    if (\n      startNumResult.type === \"error\" ||\n      startNumResult.type === \"awaiting-evaluation\"\n    ) {\n      return startNumResult;\n    }\n\n    // Evaluate the num_chars argument\n    const numCharsResult = this.evaluateNode(node.args[2]!, context);\n    if (\n      numCharsResult.type === \"error\" ||\n      numCharsResult.type === \"awaiting-evaluation\"\n    ) {\n      return numCharsResult;\n    }\n\n    // Handle spilled-values inputs\n    if (\n      textResult.type === \"spilled-values\" ||\n      startNumResult.type === \"spilled-values\" ||\n      numCharsResult.type === \"spilled-values\"\n    ) {\n      return createMidSpilledResult.call(this, {\n        textResult,\n        startNumResult,\n        numCharsResult,\n        context,\n      });\n    }\n\n    // Strict type checking - no coercion\n    if (textResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Text argument must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (startNumResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Start_num argument must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (numCharsResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Num_chars argument must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const result = midOperation(\n      textResult,\n      startNumResult,\n      numCharsResult,\n      context\n    );\n    if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n      return result;\n    }\n    return {\n      type: \"value\",\n      result: result.result,\n    };\n  },\n};\n"
+  ],
+  "mappings": ";AAAA;AAAA;AAAA;AAKA;AAoBO,IAAM,MAA0B;AAAA,EACrC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,WAAW,GAAG;AAAA,MAC1B,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,aAAa,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC3D,IACE,WAAW,SAAS,WACpB,WAAW,SAAS,uBACpB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IACE,eAAe,SAAS,WACxB,eAAe,SAAS,uBACxB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IACE,eAAe,SAAS,WACxB,eAAe,SAAS,uBACxB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAGA,IACE,WAAW,SAAS,oBACpB,eAAe,SAAS,oBACxB,eAAe,SAAS,kBACxB;AAAA,MACA,OAAO,uBAAuB,KAAK,MAAM;AAAA,QACvC;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IAGA,IAAI,WAAW,OAAO,SAAS,UAAU;AAAA,MACvC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,IAAI,eAAe,OAAO,SAAS,UAAU;AAAA,MAC3C,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,IAAI,eAAe,OAAO,SAAS,UAAU;AAAA,MAC3C,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,MAAM,SAAS,aACb,YACA,gBACA,gBACA,OACF;AAAA,IACA,IAAI,OAAO,SAAS,WAAW,OAAO,SAAS,uBAAuB;AAAA,MACpE,OAAO;AAAA,IACT;AAAA,IACA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,QAAQ,OAAO;AAAA,IACjB;AAAA;AAEJ;",
+  "debugId": "F4075A7448E40AEC64756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/text/right/right.mjs

@@ -0,0 +1,143 @@
+// src/functions/text/right/right.ts
+import {
+  FormulaError
+} from "src/core/types";
+import {
+  midOperation,
+  convertToString,
+  extractNumericValue
+} from "../text-helpers.mjs";
+function rightOperation(textResult, numCharsResult, context) {
+  const textStr = convertToString(textResult, context);
+  const numChars = extractNumericValue(numCharsResult, context);
+  if (typeof textStr === "object" && (textStr.type === "awaiting-evaluation" || textStr.type === "error")) {
+    return textStr;
+  }
+  if (typeof numChars === "object" && (numChars.type === "awaiting-evaluation" || numChars.type === "error")) {
+    return numChars;
+  }
+  const textValue = textStr;
+  const numCharsValue = numChars;
+  if (numCharsValue < 0) {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "NumChars argument must be a positive number",
+      errAddress: context.dependencyNode
+    };
+  }
+  const textLength = textValue.length;
+  const startPos = Math.max(1, textLength - Math.floor(numCharsValue) + 1);
+  const startNumResult = {
+    type: "value",
+    result: { type: "number", value: startPos }
+  };
+  return midOperation(textResult, startNumResult, numCharsResult, context);
+}
+var RIGHT = {
+  name: "RIGHT",
+  evaluate: function(node, context) {
+    if (node.args.length < 1 || node.args.length > 2) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "RIGHT function takes 1 or 2 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const textResult = this.evaluateNode(node.args[0], context);
+    if (textResult.type === "error" || textResult.type === "awaiting-evaluation") {
+      return textResult;
+    }
+    let numCharsResult;
+    if (node.args.length > 1) {
+      numCharsResult = this.evaluateNode(node.args[1], context);
+      if (numCharsResult.type === "error" || numCharsResult.type === "awaiting-evaluation") {
+        return numCharsResult;
+      }
+    } else {
+      numCharsResult = {
+        type: "value",
+        result: { type: "number", value: 1 }
+      };
+    }
+    if (textResult.type === "spilled-values" || numCharsResult.type === "spilled-values") {
+      return createRightSpilledResult.call(this, {
+        textResult,
+        numCharsResult,
+        context
+      });
+    }
+    if (textResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "Text argument must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (numCharsResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "NumChars argument must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    return rightOperation(textResult, numCharsResult, context);
+  }
+};
+function createRightSpilledResult({
+  textResult,
+  numCharsResult,
+  context
+}) {
+  if (textResult.type !== "spilled-values" && numCharsResult.type !== "spilled-values") {
+    throw new Error("createRightSpilledResult called without spilled values");
+  }
+  return {
+    type: "spilled-values",
+    spillArea: (origin) => {
+      let spillArea;
+      if (textResult.type === "spilled-values") {
+        spillArea = textResult.spillArea(origin);
+      } else if (numCharsResult.type === "spilled-values") {
+        spillArea = numCharsResult.spillArea(origin);
+      } else {
+        throw new Error("No spilled values found");
+      }
+      if (textResult.type === "spilled-values" && numCharsResult.type === "spilled-values") {
+        spillArea = this.unionRanges(this.projectRange(textResult.spillArea(origin), origin), this.projectRange(numCharsResult.spillArea(origin), origin));
+      }
+      return spillArea;
+    },
+    source: "RIGHT with spilled values",
+    evaluate: (spilledCell, evalContext) => {
+      const spillTextResult = textResult.type === "spilled-values" ? textResult.evaluate(spilledCell, evalContext) : textResult;
+      const spillNumResult = numCharsResult.type === "spilled-values" ? numCharsResult.evaluate(spilledCell, evalContext) : numCharsResult;
+      if (spillTextResult === undefined || spillNumResult === undefined) {
+        return {
+          type: "error",
+          err: FormulaError.REF,
+          message: "The spilled results have not been evaluated",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillNumResult.type === "error") {
+        return spillNumResult;
+      }
+      if (spillTextResult.type === "error") {
+        return spillTextResult;
+      }
+      return rightOperation(spillTextResult, spillNumResult, context);
+    },
+    evaluateAllCells: (intersectingRange) => {
+      throw new Error("WIP: evaluateAllCells for RIGHT is not implemented");
+    }
+  };
+}
+export {
+  RIGHT
+};
+
+//# debugId=3F45A73A185160C264756E2164756E21

package/dist/mjs/functions/text/right/right.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/text/right/right.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type CellString,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type ErrorEvaluationResult,\n  type SingleEvaluationResult,\n} from \"src/core/types\";\nimport { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport {\n  midOperation,\n  createMidSpilledResult,\n  convertToString,\n  extractNumericValue,\n} from \"../text-helpers.mjs\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * RIGHT function - Returns the rightmost characters from a text string\n *\n * Usage: RIGHT(text, num_chars)\n *\n * text: The text string to extract characters from.\n * num_chars: The number of characters to extract from the right side of the text.\n *\n * Example: RIGHT(\"Hello, World!\", 6) returns \"World!\"\n *\n * Note:\n * - If num_chars is less than 0, the function returns an error.\n * - If num_chars is greater than the length of text, the function returns the entire text.\n * - Supports dynamic arrays (spilled values) for both arguments\n * - Strict type checking: text must be string, num_chars must be number\n * - Implemented as MID(text, LEN(text) - num_chars + 1, num_chars)\n */\n\n/**\n * Helper function to calculate RIGHT operation using MID\n */\nfunction rightOperation(\n  textResult: FunctionEvaluationResult,\n  numCharsResult: FunctionEvaluationResult,\n  context: EvaluationContext\n): { type: \"value\"; result: CellString } | ErrorEvaluationResult {\n  const textStr = convertToString(textResult, context);\n  const numChars = extractNumericValue(numCharsResult, context);\n\n  // Check if any of the results are awaiting evaluation or errors\n  if (\n    typeof textStr === \"object\" &&\n    (textStr.type === \"awaiting-evaluation\" || textStr.type === \"error\")\n  ) {\n    return textStr;\n  }\n  if (\n    typeof numChars === \"object\" &&\n    (numChars.type === \"awaiting-evaluation\" || numChars.type === \"error\")\n  ) {\n    return numChars;\n  }\n\n  // At this point, all values should be primitive types\n  const textValue = textStr as string;\n  const numCharsValue = numChars as number;\n\n  // Validate numChars\n  if (numCharsValue < 0) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"NumChars argument must be a positive number\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Calculate start position: LEN(text) - num_chars + 1\n  const textLength = textValue.length;\n  const startPos = Math.max(1, textLength - Math.floor(numCharsValue) + 1);\n\n  // Create start_num result\n  const startNumResult: FunctionEvaluationResult = {\n    type: \"value\",\n    result: { type: \"number\", value: startPos },\n  };\n\n  // Use MID operation\n  return midOperation(textResult, startNumResult, numCharsResult, context);\n}\n\nexport const RIGHT: FunctionDefinition = {\n  name: \"RIGHT\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length < 1 || node.args.length > 2) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"RIGHT function takes 1 or 2 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate the text argument\n    const textResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      textResult.type === \"error\" ||\n      textResult.type === \"awaiting-evaluation\"\n    ) {\n      return textResult;\n    }\n\n    // Evaluate the numChars argument (optional, defaults to 1)\n    let numCharsResult: FunctionEvaluationResult;\n    if (node.args.length > 1) {\n      numCharsResult = this.evaluateNode(node.args[1]!, context);\n      if (\n        numCharsResult.type === \"error\" ||\n        numCharsResult.type === \"awaiting-evaluation\"\n      ) {\n        return numCharsResult;\n      }\n    } else {\n      numCharsResult = {\n        type: \"value\",\n        result: { type: \"number\", value: 1 },\n      };\n    }\n\n    // Handle spilled-values inputs\n    if (\n      textResult.type === \"spilled-values\" ||\n      numCharsResult.type === \"spilled-values\"\n    ) {\n      // For RIGHT with spilled values, we need a custom spilled result handler\n      // because we need to calculate start_num dynamically for each text value\n      return createRightSpilledResult.call(this, {\n        textResult,\n        numCharsResult,\n        context,\n      });\n    }\n\n    // Strict type checking - no coercion\n    if (textResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Text argument must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (numCharsResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"NumChars argument must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Use RIGHT operation: RIGHT(text, num_chars) = MID(text, LEN(text) - num_chars + 1, num_chars)\n    return rightOperation(textResult, numCharsResult, context);\n  },\n};\n\n/**\n * Helper for creating spilled-values result for RIGHT function\n */\nfunction createRightSpilledResult(\n  this: FormulaEvaluator,\n  {\n    textResult,\n    numCharsResult,\n    context,\n  }: {\n    textResult: FunctionEvaluationResult;\n    numCharsResult: FunctionEvaluationResult;\n    context: EvaluationContext;\n  }\n): SpilledValuesEvaluationResult | ErrorEvaluationResult {\n  if (\n    textResult.type !== \"spilled-values\" &&\n    numCharsResult.type !== \"spilled-values\"\n  ) {\n    throw new Error(\"createRightSpilledResult called without spilled values\");\n  }\n\n  return {\n    type: \"spilled-values\",\n    spillArea: (origin: CellAddress): SpreadsheetRange => {\n      // Calculate spill area\n      let spillArea;\n      if (textResult.type === \"spilled-values\") {\n        spillArea = textResult.spillArea(origin);\n      } else if (numCharsResult.type === \"spilled-values\") {\n        spillArea = numCharsResult.spillArea(origin);\n      } else {\n        throw new Error(\"No spilled values found\");\n      }\n\n      // Union spill areas if both are spilled\n      if (\n        textResult.type === \"spilled-values\" &&\n        numCharsResult.type === \"spilled-values\"\n      ) {\n        spillArea = this.unionRanges(\n          this.projectRange(textResult.spillArea(origin), origin),\n          this.projectRange(numCharsResult.spillArea(origin), origin)\n        );\n      }\n      return spillArea;\n    },\n    source: \"RIGHT with spilled values\",\n    evaluate: (spilledCell, evalContext): SingleEvaluationResult => {\n      // Evaluate arguments at this spilled position\n      const spillTextResult =\n        textResult.type === \"spilled-values\"\n          ? textResult.evaluate(spilledCell, evalContext)\n          : textResult;\n      const spillNumResult =\n        numCharsResult.type === \"spilled-values\"\n          ? numCharsResult.evaluate(spilledCell, evalContext)\n          : numCharsResult;\n\n      if (spillTextResult === undefined || spillNumResult === undefined) {\n        return {\n          type: \"error\",\n          err: FormulaError.REF,\n          message: \"The spilled results have not been evaluated\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      if (spillNumResult.type === \"error\") {\n        return spillNumResult;\n      }\n      if (spillTextResult.type === \"error\") {\n        return spillTextResult;\n      }\n\n      return rightOperation(spillTextResult, spillNumResult, context);\n    },\n    evaluateAllCells: (intersectingRange) => {\n      throw new Error(\"WIP: evaluateAllCells for RIGHT is not implemented\");\n    },\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "3F45A73A185160C264756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/text/text-helpers.mjs

@@ -0,0 +1,151 @@
+// src/functions/text/text-helpers.ts
+import {
+  FormulaError
+} from "src/core/types";
+function convertToString(result, context) {
+  if (result.type === "awaiting-evaluation") {
+    return result;
+  }
+  if (result.type !== "value") {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "Expected a value result",
+      errAddress: context.dependencyNode
+    };
+  }
+  if (result.result.type === "string") {
+    return result.result.value;
+  } else {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "Expected a string value",
+      errAddress: context.dependencyNode
+    };
+  }
+}
+function extractNumericValue(result, context) {
+  if (result.type === "awaiting-evaluation") {
+    return result;
+  }
+  if (result.type !== "value") {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "Expected a value result",
+      errAddress: context.dependencyNode
+    };
+  }
+  if (result.result.type === "number") {
+    return result.result.value;
+  } else {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "Expected a number value",
+      errAddress: context.dependencyNode
+    };
+  }
+}
+function midOperation(textResult, startNumResult, numCharsResult, context) {
+  const textStr = convertToString(textResult, context);
+  const startNum = extractNumericValue(startNumResult, context);
+  const numChars = extractNumericValue(numCharsResult, context);
+  if (typeof textStr === "object" && (textStr.type === "awaiting-evaluation" || textStr.type === "error")) {
+    return textStr;
+  }
+  if (typeof startNum === "object" && (startNum.type === "awaiting-evaluation" || startNum.type === "error")) {
+    return startNum;
+  }
+  if (typeof numChars === "object" && (numChars.type === "awaiting-evaluation" || numChars.type === "error")) {
+    return numChars;
+  }
+  const textValue = textStr;
+  const startNumValue = startNum;
+  const numCharsValue = numChars;
+  if (startNumValue < 1) {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "StartNum argument must be a positive number",
+      errAddress: context.dependencyNode
+    };
+  }
+  if (numCharsValue < 0) {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "NumChars argument must be a positive number",
+      errAddress: context.dependencyNode
+    };
+  }
+  const startIndex = Math.floor(startNumValue) - 1;
+  const length = Math.floor(numCharsValue);
+  const result = textValue.substring(startIndex, startIndex + length);
+  return { type: "value", result: { type: "string", value: result } };
+}
+function createMidSpilledResult({
+  textResult,
+  startNumResult,
+  numCharsResult,
+  context
+}) {
+  const hasSpilledText = textResult.type === "spilled-values";
+  const hasSpilledStart = startNumResult.type === "spilled-values";
+  const hasSpilledNum = numCharsResult.type === "spilled-values";
+  if (!hasSpilledText && !hasSpilledStart && !hasSpilledNum) {
+    throw new Error("createMidSpilledResult called without spilled values");
+  }
+  return {
+    type: "spilled-values",
+    spillArea: (origin) => {
+      let spillArea;
+      if (hasSpilledText && textResult.type === "spilled-values") {
+        spillArea = textResult.spillArea(origin);
+      } else if (hasSpilledStart && startNumResult.type === "spilled-values") {
+        spillArea = startNumResult.spillArea(origin);
+      } else if (hasSpilledNum && numCharsResult.type === "spilled-values") {
+        spillArea = numCharsResult.spillArea(origin);
+      } else {
+        throw new Error("No spilled values found");
+      }
+      if (hasSpilledText && hasSpilledStart && textResult.type === "spilled-values" && startNumResult.type === "spilled-values") {
+        spillArea = this.unionRanges(this.projectRange(textResult.spillArea(origin), origin), this.projectRange(startNumResult.spillArea(origin), origin));
+      }
+      if ((hasSpilledText || hasSpilledStart) && hasSpilledNum && numCharsResult.type === "spilled-values") {
+        const projectedSpillArea = this.projectRange(spillArea, origin);
+        const numSpillArea = this.projectRange(numCharsResult.spillArea(origin), origin);
+        spillArea = this.unionRanges(projectedSpillArea, numSpillArea);
+      }
+      return spillArea;
+    },
+    source: "MID with spilled values",
+    evaluate: (spilledCell, evalContext) => {
+      const spillTextResult = hasSpilledText ? textResult.evaluate(spilledCell, evalContext) : textResult;
+      const spillStartResult = hasSpilledStart ? startNumResult.evaluate(spilledCell, evalContext) : startNumResult;
+      const spillNumResult = hasSpilledNum ? numCharsResult.evaluate(spilledCell, evalContext) : numCharsResult;
+      if (!spillTextResult || spillTextResult.type === "error") {
+        return spillTextResult;
+      }
+      if (!spillStartResult || spillStartResult.type === "error") {
+        return spillStartResult;
+      }
+      if (!spillNumResult || spillNumResult.type === "error") {
+        return spillNumResult;
+      }
+      return midOperation(spillTextResult, spillStartResult, spillNumResult, evalContext);
+    },
+    evaluateAllCells: (intersectingRange) => {
+      throw new Error("WIP: evaluateAllCells for MID is not implemented");
+    }
+  };
+}
+export {
+  midOperation,
+  extractNumericValue,
+  createMidSpilledResult,
+  convertToString
+};
+
+//# debugId=99031B729F5EA4C764756E2164756E21

package/dist/mjs/functions/text/text-helpers.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/functions/text/text-helpers.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellString,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type ErrorEvaluationResult,\n  type SingleEvaluationResult,\n} from \"src/core/types\";\nimport type { FormulaEngine } from \"src/core/engine\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * Strictly extracts string value without type coercion\n */\nexport function convertToString(result: FunctionEvaluationResult, context: EvaluationContext): string | ErrorEvaluationResult {\n  if (result.type === \"awaiting-evaluation\") {\n    return result;\n  }\n  \n  if (result.type !== \"value\") {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Expected a value result\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  if (result.result.type === \"string\") {\n    return result.result.value;\n  } else {\n    // No type coercion - only strings are valid\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Expected a string value\",\n      errAddress: context.dependencyNode,\n    };\n  }\n}\n\n/**\n * Strictly extracts numeric value without type coercion\n */\nexport function extractNumericValue(result: FunctionEvaluationResult, context: EvaluationContext): number | ErrorEvaluationResult {\n  if (result.type === \"awaiting-evaluation\") {\n    return result;\n  }\n  \n  if (result.type !== \"value\") {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Expected a value result\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  if (result.result.type === \"number\") {\n    return result.result.value;\n  } else {\n    // No type coercion - only numbers are valid\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Expected a number value\",\n      errAddress: context.dependencyNode,\n    };\n  }\n}\n\n/**\n * MID substring operation for MID function\n */\nexport function midOperation(\n  textResult: FunctionEvaluationResult,\n  startNumResult: FunctionEvaluationResult,\n  numCharsResult: FunctionEvaluationResult,\n  context: EvaluationContext\n): { type: \"value\"; result: CellString } | ErrorEvaluationResult {\n  const textStr = convertToString(textResult, context);\n  const startNum = extractNumericValue(startNumResult, context);\n  const numChars = extractNumericValue(numCharsResult, context);\n\n  // Check if any of the results are awaiting evaluation or errors\n  if (typeof textStr === \"object\" && (textStr.type === \"awaiting-evaluation\" || textStr.type === \"error\")) {\n    return textStr;\n  }\n  if (typeof startNum === \"object\" && (startNum.type === \"awaiting-evaluation\" || startNum.type === \"error\")) {\n    return startNum;\n  }\n  if (typeof numChars === \"object\" && (numChars.type === \"awaiting-evaluation\" || numChars.type === \"error\")) {\n    return numChars;\n  }\n\n  // At this point, all values should be primitive types\n  const textValue = textStr as string;\n  const startNumValue = startNum as number;\n  const numCharsValue = numChars as number;\n\n  // Validate startNum and numChars\n  if (startNumValue < 1) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"StartNum argument must be a positive number\",\n      errAddress: context.dependencyNode,\n    };\n  }\n  if (numCharsValue < 0) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"NumChars argument must be a positive number\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Convert to 0-based index (Excel uses 1-based)\n  const startIndex = Math.floor(startNumValue) - 1;\n  const length = Math.floor(numCharsValue);\n\n  // Extract substring\n  const result = textValue.substring(startIndex, startIndex + length);\n\n  return { type: \"value\", result: { type: \"string\", value: result } };\n}\n\n/**\n * Helper for creating spilled-values result for MID function (3 parameters)\n */\nexport function createMidSpilledResult(\n  this: FormulaEvaluator,\n  {\n    textResult,\n    startNumResult,\n    numCharsResult,\n    context,\n  }: {\n    textResult: FunctionEvaluationResult;\n    startNumResult: FunctionEvaluationResult;\n    numCharsResult: FunctionEvaluationResult;\n    context: EvaluationContext;\n  }\n): FunctionEvaluationResult {\n  const hasSpilledText = textResult.type === \"spilled-values\";\n  const hasSpilledStart = startNumResult.type === \"spilled-values\";\n  const hasSpilledNum = numCharsResult.type === \"spilled-values\";\n\n  if (!hasSpilledText && !hasSpilledStart && !hasSpilledNum) {\n    throw new Error(\"createMidSpilledResult called without spilled values\");\n  }\n\n  return {\n    type: \"spilled-values\",\n    spillArea: (origin: CellAddress) => {\n      // Calculate spill area (union of all spilled ranges)\n      let spillArea: SpreadsheetRange;\n\n      if (hasSpilledText && textResult.type === \"spilled-values\") {\n        spillArea = textResult.spillArea(origin);\n      } else if (hasSpilledStart && startNumResult.type === \"spilled-values\") {\n        spillArea = startNumResult.spillArea(origin);\n      } else if (hasSpilledNum && numCharsResult.type === \"spilled-values\") {\n        spillArea = numCharsResult.spillArea(origin);\n      } else {\n        // This shouldn't happen since we check for spilled values at the beginning\n        throw new Error(\"No spilled values found\");\n      }\n\n      // Union with other spilled ranges if they exist\n      if (\n        hasSpilledText &&\n        hasSpilledStart &&\n        textResult.type === \"spilled-values\" &&\n        startNumResult.type === \"spilled-values\"\n      ) {\n        spillArea = this.unionRanges(\n          this.projectRange(textResult.spillArea(origin), origin),\n          this.projectRange(startNumResult.spillArea(origin), origin)\n        );\n      }\n\n      if (\n        (hasSpilledText || hasSpilledStart) &&\n        hasSpilledNum &&\n        numCharsResult.type === \"spilled-values\"\n      ) {\n        const projectedSpillArea = this.projectRange(spillArea, origin);\n        const numSpillArea = this.projectRange(\n          numCharsResult.spillArea(origin),\n          origin\n        );\n        spillArea = this.unionRanges(projectedSpillArea, numSpillArea);\n      }\n      return spillArea;\n    },\n    source: \"MID with spilled values\",\n    evaluate: (\n      spilledCell,\n      evalContext\n    ): SingleEvaluationResult => {\n      // Evaluate all arguments at this spilled position\n      const spillTextResult = hasSpilledText\n        ? textResult.evaluate(spilledCell, evalContext)\n        : textResult;\n      const spillStartResult = hasSpilledStart\n        ? startNumResult.evaluate(spilledCell, evalContext)\n        : startNumResult;\n      const spillNumResult = hasSpilledNum\n        ? numCharsResult.evaluate(spilledCell, evalContext)\n        : numCharsResult;\n\n      if (!spillTextResult || spillTextResult.type === \"error\") {\n        return spillTextResult;\n      }\n      if (!spillStartResult || spillStartResult.type === \"error\") {\n        return spillStartResult;\n      }\n      if (!spillNumResult || spillNumResult.type === \"error\") {\n        return spillNumResult;\n      }\n\n      return midOperation(spillTextResult, spillStartResult, spillNumResult, evalContext);\n    },\n    evaluateAllCells: (intersectingRange) => {\n      throw new Error(\"WIP: evaluateAllCells for MID is not implemented\");\n    },\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "99031B729F5EA4C764756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/text/textjoin/textjoin.mjs

@@ -0,0 +1,145 @@
+// src/functions/text/textjoin/textjoin.ts
+import {
+  FormulaError
+} from "src/core/types";
+var MAX_TEXT_LENGTH = 32767;
+function coerceToString(value) {
+  switch (value.type) {
+    case "string":
+      return value.value;
+    case "number":
+      if (value.value === Infinity) {
+        return "INFINITY";
+      } else if (value.value === -Infinity) {
+        return "-INFINITY";
+      } else if (isNaN(value.value)) {
+        return "NaN";
+      } else {
+        return value.value.toString();
+      }
+    case "boolean":
+      return value.value ? "TRUE" : "FALSE";
+    case "infinity":
+      return value.sign === "positive" ? "INFINITY" : "-INFINITY";
+    default:
+      return "";
+  }
+}
+function collectTextItems(args, ignoreEmpty, context) {
+  const textItems = [];
+  for (const arg of args) {
+    if (arg.type === "error") {
+      return arg;
+    }
+    if (arg.type === "value") {
+      const text = coerceToString(arg.result);
+      if (!ignoreEmpty || text !== "") {
+        textItems.push(text);
+      }
+    } else if (arg.type === "spilled-values") {
+      const cellValues = arg.evaluateAllCells.call(this, {
+        context,
+        origin: context.cellAddress,
+        evaluate: arg.evaluate,
+        lookupOrder: "col-major"
+      });
+      if (cellValues.type !== "values") {
+        return cellValues;
+      }
+      for (const cellValue of cellValues.values) {
+        if (cellValue.result.type === "error" || cellValue.result.type === "awaiting-evaluation") {
+          return cellValue.result;
+        }
+        if (cellValue.result.type === "value") {
+          const text = coerceToString(cellValue.result.result);
+          if (!ignoreEmpty || text !== "") {
+            textItems.push(text);
+          }
+        }
+      }
+    }
+  }
+  return textItems;
+}
+var TEXTJOIN = {
+  name: "TEXTJOIN",
+  evaluate: function(node, context) {
+    if (node.args.length < 3) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "TEXTJOIN function requires at least 3 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const delimiterResult = this.evaluateNode(node.args[0], context);
+    if (delimiterResult.type === "error") {
+      return delimiterResult;
+    }
+    if (delimiterResult.type === "awaiting-evaluation") {
+      return delimiterResult;
+    }
+    if (delimiterResult.type === "spilled-values") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "TEXTJOIN delimiter must be a single value",
+        errAddress: context.dependencyNode
+      };
+    }
+    const delimiter = coerceToString(delimiterResult.result);
+    const ignoreEmptyResult = this.evaluateNode(node.args[1], context);
+    if (ignoreEmptyResult.type === "error") {
+      return ignoreEmptyResult;
+    }
+    if (ignoreEmptyResult.type === "awaiting-evaluation") {
+      return ignoreEmptyResult;
+    }
+    if (ignoreEmptyResult.type === "spilled-values") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "TEXTJOIN ignore_empty must be a single value",
+        errAddress: context.dependencyNode
+      };
+    }
+    let ignoreEmpty = false;
+    if (ignoreEmptyResult.result.type === "boolean") {
+      ignoreEmpty = ignoreEmptyResult.result.value;
+    } else if (ignoreEmptyResult.result.type === "number") {
+      ignoreEmpty = ignoreEmptyResult.result.value !== 0;
+    } else if (ignoreEmptyResult.result.type === "string") {
+      ignoreEmpty = ignoreEmptyResult.result.value !== "";
+    }
+    const textArgs = [];
+    for (let i = 2;i < node.args.length; i++) {
+      const result2 = this.evaluateNode(node.args[i], context);
+      if (result2.type === "error" || result2.type === "awaiting-evaluation") {
+        return result2;
+      }
+      textArgs.push(result2);
+    }
+    const textItems = collectTextItems.call(this, textArgs, ignoreEmpty, context);
+    if (!Array.isArray(textItems)) {
+      return textItems;
+    }
+    const result = textItems.join(delimiter);
+    if (result.length > MAX_TEXT_LENGTH) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: `TEXTJOIN result exceeds ${MAX_TEXT_LENGTH} character limit`,
+        errAddress: context.dependencyNode
+      };
+    }
+    return {
+      type: "value",
+      result: { type: "string", value: result }
+    };
+  }
+};
+export {
+  TEXTJOIN
+};
+
+//# debugId=C520C9CA8A80F6D964756E2164756E21

package/dist/mjs/functions/text/textjoin/textjoin.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/text/textjoin/textjoin.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type SingleEvaluationResult,\n  type ErrorEvaluationResult,\n  type CellString,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\n\n/**\n * TEXTJOIN function - Joins text from multiple ranges and/or strings with a specified delimiter\n *\n * Usage: TEXTJOIN(delimiter, ignore_empty, text1, [text2], ...)\n *\n * delimiter: String to insert between text items (can be empty string \"\")\n * ignore_empty: If TRUE, empty cells/strings are ignored; if FALSE, they are included\n * text1, text2, ...: Text items to join (can be strings, ranges, or arrays)\n *\n * Examples:\n *   TEXTJOIN(\", \", TRUE, A1:A3) - joins A1, A2, A3 with \", \" separator, ignoring empty cells\n *   TEXTJOIN(\"-\", FALSE, \"a\", \"b\", \"c\") - returns \"a-b-c\"\n *   TEXTJOIN(\", \", TRUE, \"Red\", \"\", \"Blue\") - returns \"Red, Blue\" (empty string ignored)\n *\n * Note:\n * - Supports type coercion: numbers and booleans are converted to strings\n * - Returns #VALUE! if result exceeds 32,767 characters\n */\n\nconst MAX_TEXT_LENGTH = 32767;\n\n/**\n * Helper function to convert a cell value to string with type coercion\n */\nfunction coerceToString(value: CellValue): string {\n  switch (value.type) {\n    case \"string\":\n      return value.value;\n    case \"number\":\n      // Convert number to string\n      if (value.value === Infinity) {\n        return \"INFINITY\";\n      } else if (value.value === -Infinity) {\n        return \"-INFINITY\";\n      } else if (isNaN(value.value)) {\n        return \"NaN\";\n      } else {\n        return value.value.toString();\n      }\n    case \"boolean\":\n      // Convert boolean to string\n      return value.value ? \"TRUE\" : \"FALSE\";\n    case \"infinity\":\n      return value.sign === \"positive\" ? \"INFINITY\" : \"-INFINITY\";\n    default:\n      return \"\";\n  }\n}\n\n/**\n * Helper function to collect all text items from arguments, handling ranges\n */\nfunction collectTextItems(\n  this: FormulaEvaluator,\n  args: FunctionEvaluationResult[],\n  ignoreEmpty: boolean,\n  context: EvaluationContext\n): string[] | ErrorEvaluationResult {\n  const textItems: string[] = [];\n\n  for (const arg of args) {\n    if (arg.type === \"error\") {\n      return arg;\n    }\n\n    if (arg.type === \"value\") {\n      const text = coerceToString(arg.result);\n      if (!ignoreEmpty || text !== \"\") {\n        textItems.push(text);\n      }\n    } else if (arg.type === \"spilled-values\") {\n      // Extract all values from the range\n      const cellValues = arg.evaluateAllCells.call(this, {\n        context,\n        origin: context.cellAddress,\n        evaluate: arg.evaluate,\n        lookupOrder: \"col-major\",\n      });\n\n      if (cellValues.type !== \"values\") {\n        return cellValues;\n      }\n\n      for (const cellValue of cellValues.values) {\n        if (\n          cellValue.result.type === \"error\" ||\n          cellValue.result.type === \"awaiting-evaluation\"\n        ) {\n          return cellValue.result;\n        }\n        if (cellValue.result.type === \"value\") {\n          const text = coerceToString(cellValue.result.result);\n          if (!ignoreEmpty || text !== \"\") {\n            textItems.push(text);\n          }\n        }\n      }\n    }\n  }\n\n  return textItems;\n}\n\n/**\n * TEXTJOIN function implementation\n */\nexport const TEXTJOIN: FunctionDefinition = {\n  name: \"TEXTJOIN\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length < 3) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"TEXTJOIN function requires at least 3 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate delimiter (first argument)\n    const delimiterResult = this.evaluateNode(node.args[0]!, context);\n    if (delimiterResult.type === \"error\") {\n      return delimiterResult;\n    }\n    if (delimiterResult.type === \"awaiting-evaluation\") {\n      return delimiterResult;\n    }\n\n    // Delimiter must be a single value\n    if (delimiterResult.type === \"spilled-values\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"TEXTJOIN delimiter must be a single value\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const delimiter = coerceToString(delimiterResult.result);\n\n    // Evaluate ignore_empty (second argument)\n    const ignoreEmptyResult = this.evaluateNode(node.args[1]!, context);\n    if (ignoreEmptyResult.type === \"error\") {\n      return ignoreEmptyResult;\n    }\n    if (ignoreEmptyResult.type === \"awaiting-evaluation\") {\n      return ignoreEmptyResult;\n    }\n\n    // ignore_empty must be a single value\n    if (ignoreEmptyResult.type === \"spilled-values\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"TEXTJOIN ignore_empty must be a single value\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Convert ignore_empty to boolean\n    let ignoreEmpty = false;\n    if (ignoreEmptyResult.result.type === \"boolean\") {\n      ignoreEmpty = ignoreEmptyResult.result.value;\n    } else if (ignoreEmptyResult.result.type === \"number\") {\n      ignoreEmpty = ignoreEmptyResult.result.value !== 0;\n    } else if (ignoreEmptyResult.result.type === \"string\") {\n      ignoreEmpty = ignoreEmptyResult.result.value !== \"\";\n    }\n\n    // Evaluate text arguments (remaining arguments)\n    const textArgs: FunctionEvaluationResult[] = [];\n    for (let i = 2; i < node.args.length; i++) {\n      const result = this.evaluateNode(node.args[i]!, context);\n      if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n        return result;\n      }\n      textArgs.push(result);\n    }\n\n    // Collect all text items from arguments\n    const textItems = collectTextItems.call(\n      this,\n      textArgs,\n      ignoreEmpty,\n      context\n    );\n\n    // Check if we got an error\n    if (!Array.isArray(textItems)) {\n      return textItems;\n    }\n\n    // Join text items with delimiter\n    const result = textItems.join(delimiter);\n\n    // Check length limit\n    if (result.length > MAX_TEXT_LENGTH) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `TEXTJOIN result exceeds ${MAX_TEXT_LENGTH} character limit`,\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    return {\n      type: \"value\",\n      result: { type: \"string\", value: result },\n    };\n  },\n};\n"
+  ],
+  "mappings": ";AAAA;AAAA;AAAA;AAoCA,IAAM,kBAAkB;AAKxB,SAAS,cAAc,CAAC,OAA0B;AAAA,EAChD,QAAQ,MAAM;AAAA,SACP;AAAA,MACH,OAAO,MAAM;AAAA,SACV;AAAA,MAEH,IAAI,MAAM,UAAU,UAAU;AAAA,QAC5B,OAAO;AAAA,MACT,EAAO,SAAI,MAAM,UAAU,WAAW;AAAA,QACpC,OAAO;AAAA,MACT,EAAO,SAAI,MAAM,MAAM,KAAK,GAAG;AAAA,QAC7B,OAAO;AAAA,MACT,EAAO;AAAA,QACL,OAAO,MAAM,MAAM,SAAS;AAAA;AAAA,SAE3B;AAAA,MAEH,OAAO,MAAM,QAAQ,SAAS;AAAA,SAC3B;AAAA,MACH,OAAO,MAAM,SAAS,aAAa,aAAa;AAAA;AAAA,MAEhD,OAAO;AAAA;AAAA;AAOb,SAAS,gBAAgB,CAEvB,MACA,aACA,SACkC;AAAA,EAClC,MAAM,YAAsB,CAAC;AAAA,EAE7B,WAAW,OAAO,MAAM;AAAA,IACtB,IAAI,IAAI,SAAS,SAAS;AAAA,MACxB,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,IAAI,SAAS,SAAS;AAAA,MACxB,MAAM,OAAO,eAAe,IAAI,MAAM;AAAA,MACtC,IAAI,CAAC,eAAe,SAAS,IAAI;AAAA,QAC/B,UAAU,KAAK,IAAI;AAAA,MACrB;AAAA,IACF,EAAO,SAAI,IAAI,SAAS,kBAAkB;AAAA,MAExC,MAAM,aAAa,IAAI,iBAAiB,KAAK,MAAM;AAAA,QACjD;AAAA,QACA,QAAQ,QAAQ;AAAA,QAChB,UAAU,IAAI;AAAA,QACd,aAAa;AAAA,MACf,CAAC;AAAA,MAED,IAAI,WAAW,SAAS,UAAU;AAAA,QAChC,OAAO;AAAA,MACT;AAAA,MAEA,WAAW,aAAa,WAAW,QAAQ;AAAA,QACzC,IACE,UAAU,OAAO,SAAS,WAC1B,UAAU,OAAO,SAAS,uBAC1B;AAAA,UACA,OAAO,UAAU;AAAA,QACnB;AAAA,QACA,IAAI,UAAU,OAAO,SAAS,SAAS;AAAA,UACrC,MAAM,OAAO,eAAe,UAAU,OAAO,MAAM;AAAA,UACnD,IAAI,CAAC,eAAe,SAAS,IAAI;AAAA,YAC/B,UAAU,KAAK,IAAI;AAAA,UACrB;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEA,OAAO;AAAA;AAMF,IAAM,WAA+B;AAAA,EAC1C,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,SAAS,GAAG;AAAA,MACxB,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,kBAAkB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAChE,IAAI,gBAAgB,SAAS,SAAS;AAAA,MACpC,OAAO;AAAA,IACT;AAAA,IACA,IAAI,gBAAgB,SAAS,uBAAuB;AAAA,MAClD,OAAO;AAAA,IACT;AAAA,IAGA,IAAI,gBAAgB,SAAS,kBAAkB;AAAA,MAC7C,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,MAAM,YAAY,eAAe,gBAAgB,MAAM;AAAA,IAGvD,MAAM,oBAAoB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAClE,IAAI,kBAAkB,SAAS,SAAS;AAAA,MACtC,OAAO;AAAA,IACT;AAAA,IACA,IAAI,kBAAkB,SAAS,uBAAuB;AAAA,MACpD,OAAO;AAAA,IACT;AAAA,IAGA,IAAI,kBAAkB,SAAS,kBAAkB;AAAA,MAC/C,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,IAAI,cAAc;AAAA,IAClB,IAAI,kBAAkB,OAAO,SAAS,WAAW;AAAA,MAC/C,cAAc,kBAAkB,OAAO;AAAA,IACzC,EAAO,SAAI,kBAAkB,OAAO,SAAS,UAAU;AAAA,MACrD,cAAc,kBAAkB,OAAO,UAAU;AAAA,IACnD,EAAO,SAAI,kBAAkB,OAAO,SAAS,UAAU;AAAA,MACrD,cAAc,kBAAkB,OAAO,UAAU;AAAA,IACnD;AAAA,IAGA,MAAM,WAAuC,CAAC;AAAA,IAC9C,SAAS,IAAI,EAAG,IAAI,KAAK,KAAK,QAAQ,KAAK;AAAA,MACzC,MAAM,UAAS,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,MACvD,IAAI,QAAO,SAAS,WAAW,QAAO,SAAS,uBAAuB;AAAA,QACpE,OAAO;AAAA,MACT;AAAA,MACA,SAAS,KAAK,OAAM;AAAA,IACtB;AAAA,IAGA,MAAM,YAAY,iBAAiB,KACjC,MACA,UACA,aACA,OACF;AAAA,IAGA,IAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AAAA,MAC7B,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,SAAS,UAAU,KAAK,SAAS;AAAA,IAGvC,IAAI,OAAO,SAAS,iBAAiB;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS,2BAA2B;AAAA,QACpC,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,QAAQ,EAAE,MAAM,UAAU,OAAO,OAAO;AAAA,IAC1C;AAAA;AAEJ;",
+  "debugId": "C520C9CA8A80F6D964756E2164756E21",
+  "names": []
+}

package/dist/mjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/formula-engine",
+  "version": "0.0.1",
+  "type": "module"
+}