@ricsam/formula-engine 0.0.1

package/dist/cjs/core/named-expression-renamer.cjs

@@ -0,0 +1,88 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/named-expression-renamer.ts
+var exports_named_expression_renamer = {};
+__export(exports_named_expression_renamer, {
+  renameNamedExpressionInFormula: () => renameNamedExpressionInFormula,
+  getReferencedNamedExpressionNames: () => getReferencedNamedExpressionNames,
+  formulaReferencesNamedExpression: () => formulaReferencesNamedExpression
+});
+module.exports = __toCommonJS(exports_named_expression_renamer);
+var import_parser = require("../parser/parser.cjs");
+var import_formatter = require("../parser/formatter.cjs");
+var import_ast_traverser = require("./ast-traverser.cjs");
+function renameNamedExpressionInFormula(formula, oldName, newName) {
+  try {
+    const ast = import_parser.parseFormula(formula);
+    const transformedAST = import_ast_traverser.transformAST(ast, (node) => {
+      if (node.type === "named-expression" && node.name === oldName) {
+        return {
+          ...node,
+          name: newName
+        };
+      }
+      return node;
+    });
+    return import_formatter.astToString(transformedAST);
+  } catch (error) {
+    return formula;
+  }
+}
+function formulaReferencesNamedExpression(formula, namedExpressionName) {
+  try {
+    const ast = import_parser.parseFormula(formula);
+    let hasReference = false;
+    import_ast_traverser.transformAST(ast, (node) => {
+      if (node.type === "named-expression" && node.name === namedExpressionName) {
+        hasReference = true;
+      }
+      return node;
+    });
+    return hasReference;
+  } catch (error) {
+    return false;
+  }
+}
+function getReferencedNamedExpressionNames(formula) {
+  try {
+    const ast = import_parser.parseFormula(formula);
+    const namedExpressionNames = new Set;
+    import_ast_traverser.transformAST(ast, (node) => {
+      if (node.type === "named-expression" && node.name) {
+        namedExpressionNames.add(node.name);
+      }
+      return node;
+    });
+    return Array.from(namedExpressionNames);
+  } catch (error) {
+    return [];
+  }
+}
+
+//# debugId=29DDE7C137B216D164756E2164756E21

package/dist/cjs/core/named-expression-renamer.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/named-expression-renamer.ts"],
+  "sourcesContent": [
+    "import { parseFormula } from \"../parser/parser.cjs\";\nimport { astToString } from \"../parser/formatter.cjs\";\nimport { transformAST } from \"./ast-traverser.cjs\";\n\n/**\n * Renames named expression references in a formula string\n * @param formula - The formula string (without the leading =)\n * @param oldName - The current named expression name to replace\n * @param newName - The new named expression name\n * @returns The updated formula string, or the original if no changes were made\n */\nexport function renameNamedExpressionInFormula(\n  formula: string,\n  oldName: string,\n  newName: string\n): string {\n  try {\n    const ast = parseFormula(formula);\n    \n    const transformedAST = transformAST(ast, (node) => {\n      if (node.type === \"named-expression\" && node.name === oldName) {\n        return {\n          ...node,\n          name: newName\n        };\n      }\n      return node;\n    });\n\n    return astToString(transformedAST);\n  } catch (error) {\n    // If parsing fails, return the original formula\n    return formula;\n  }\n}\n\n/**\n * Checks if a formula contains references to a specific named expression\n * @param formula - The formula string (without the leading =)\n * @param namedExpressionName - The named expression name to search for\n * @returns True if the formula contains references to the named expression\n */\nexport function formulaReferencesNamedExpression(formula: string, namedExpressionName: string): boolean {\n  try {\n    const ast = parseFormula(formula);\n    let hasReference = false;\n\n    transformAST(ast, (node) => {\n      if (node.type === \"named-expression\" && node.name === namedExpressionName) {\n        hasReference = true;\n      }\n      return node;\n    });\n\n    return hasReference;\n  } catch (error) {\n    // If parsing fails, assume no reference\n    return false;\n  }\n}\n\n/**\n * Gets all named expression names referenced in a formula\n * @param formula - The formula string (without the leading =)\n * @returns Array of unique named expression names referenced in the formula\n */\nexport function getReferencedNamedExpressionNames(formula: string): string[] {\n  try {\n    const ast = parseFormula(formula);\n    const namedExpressionNames = new Set<string>();\n\n    transformAST(ast, (node) => {\n      if (node.type === \"named-expression\" && node.name) {\n        namedExpressionNames.add(node.name);\n      }\n      return node;\n    });\n\n    return Array.from(namedExpressionNames);\n  } catch (error) {\n    // If parsing fails, return empty array\n    return [];\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAA6B,IAA7B;AAC4B,IAA5B;AAC6B,IAA7B;AASO,SAAS,8BAA8B,CAC5C,SACA,SACA,SACQ;AAAA,EACR,IAAI;AAAA,IACF,MAAM,MAAM,2BAAa,OAAO;AAAA,IAEhC,MAAM,iBAAiB,kCAAa,KAAK,CAAC,SAAS;AAAA,MACjD,IAAI,KAAK,SAAS,sBAAsB,KAAK,SAAS,SAAS;AAAA,QAC7D,OAAO;AAAA,aACF;AAAA,UACH,MAAM;AAAA,QACR;AAAA,MACF;AAAA,MACA,OAAO;AAAA,KACR;AAAA,IAED,OAAO,6BAAY,cAAc;AAAA,IACjC,OAAO,OAAO;AAAA,IAEd,OAAO;AAAA;AAAA;AAUJ,SAAS,gCAAgC,CAAC,SAAiB,qBAAsC;AAAA,EACtG,IAAI;AAAA,IACF,MAAM,MAAM,2BAAa,OAAO;AAAA,IAChC,IAAI,eAAe;AAAA,IAEnB,kCAAa,KAAK,CAAC,SAAS;AAAA,MAC1B,IAAI,KAAK,SAAS,sBAAsB,KAAK,SAAS,qBAAqB;AAAA,QACzE,eAAe;AAAA,MACjB;AAAA,MACA,OAAO;AAAA,KACR;AAAA,IAED,OAAO;AAAA,IACP,OAAO,OAAO;AAAA,IAEd,OAAO;AAAA;AAAA;AASJ,SAAS,iCAAiC,CAAC,SAA2B;AAAA,EAC3E,IAAI;AAAA,IACF,MAAM,MAAM,2BAAa,OAAO;AAAA,IAChC,MAAM,uBAAuB,IAAI;AAAA,IAEjC,kCAAa,KAAK,CAAC,SAAS;AAAA,MAC1B,IAAI,KAAK,SAAS,sBAAsB,KAAK,MAAM;AAAA,QACjD,qBAAqB,IAAI,KAAK,IAAI;AAAA,MACpC;AAAA,MACA,OAAO;AAAA,KACR;AAAA,IAED,OAAO,MAAM,KAAK,oBAAoB;AAAA,IACtC,OAAO,OAAO;AAAA,IAEd,OAAO,CAAC;AAAA;AAAA;",
+  "debugId": "29DDE7C137B216D164756E2164756E21",
+  "names": []
+}

package/dist/cjs/core/sheet-renamer.cjs

@@ -0,0 +1,89 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/sheet-renamer.ts
+var exports_sheet_renamer = {};
+__export(exports_sheet_renamer, {
+  renameSheetInFormula: () => renameSheetInFormula,
+  getReferencedSheetNames: () => getReferencedSheetNames,
+  formulaReferencesSheet: () => formulaReferencesSheet
+});
+module.exports = __toCommonJS(exports_sheet_renamer);
+var import_parser = require("../parser/parser.cjs");
+var import_formatter = require("../parser/formatter.cjs");
+var import_ast_traverser = require("./ast-traverser.cjs");
+function renameSheetInFormula(options) {
+  const { formula, oldSheetName, newSheetName } = options;
+  try {
+    const ast = import_parser.parseFormula(formula);
+    const updatedAst = import_ast_traverser.transformAST(ast, (node) => {
+      if (node.type === "reference" && node.sheetName === oldSheetName) {
+        return {
+          ...node,
+          sheetName: newSheetName
+        };
+      }
+      if (node.type === "range" && node.sheetName === oldSheetName) {
+        return {
+          ...node,
+          sheetName: newSheetName
+        };
+      }
+      return node;
+    });
+    return import_formatter.astToString(updatedAst);
+  } catch (error) {
+    return formula;
+  }
+}
+function formulaReferencesSheet(formula, sheetName) {
+  try {
+    const ast = import_parser.parseFormula(formula);
+    const referencedSheets = getReferencedSheetNames(formula);
+    return referencedSheets.includes(sheetName);
+  } catch (error) {
+    return false;
+  }
+}
+function getReferencedSheetNames(formula) {
+  try {
+    const ast = import_parser.parseFormula(formula);
+    const sheetNames = new Set;
+    import_ast_traverser.transformAST(ast, (node) => {
+      if ((node.type === "reference" || node.type === "range") && node.sheetName) {
+        sheetNames.add(node.sheetName);
+      }
+      return node;
+    });
+    return Array.from(sheetNames);
+  } catch (error) {
+    return [];
+  }
+}
+
+//# debugId=ABD0A5EE1052D5B064756E2164756E21

package/dist/cjs/core/sheet-renamer.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/sheet-renamer.ts"],
+  "sourcesContent": [
+    "/**\n * Sheet renamer utility for updating cross-sheet references in formulas\n */\n\nimport { parseFormula } from \"../parser/parser.cjs\";\nimport { astToString } from \"../parser/formatter.cjs\";\nimport { transformAST } from \"./ast-traverser.cjs\";\nimport type { ASTNode } from \"../parser/ast.cjs\";\n\n/**\n * Renames sheet references in a formula string\n * @param formula The formula string (without the leading =)\n * @param oldSheetName The old sheet name to replace\n * @param newSheetName The new sheet name to use\n * @returns The updated formula string\n */\nexport function renameSheetInFormula(options: {\n  formula: string,\n  oldSheetName: string;\n  newSheetName: string;\n}): string {\n  const { formula, oldSheetName, newSheetName } = options;\n  try {\n    const ast = parseFormula(formula);\n    \n    const updatedAst = transformAST(ast, (node) => {\n      // Handle regular cross-sheet references (e.g., Sheet1!A1)\n      if (node.type === \"reference\" && node.sheetName === oldSheetName) {\n        return {\n          ...node,\n          sheetName: newSheetName,\n        };\n      }\n      \n      // Handle range references with sheet names (e.g., Sheet1!A1:B2)\n      if (node.type === \"range\" && node.sheetName === oldSheetName) {\n        return {\n          ...node,\n          sheetName: newSheetName,\n        };\n      }\n      \n      return node;\n    });\n    \n    return astToString(updatedAst);\n  } catch (error) {\n    // If parsing fails, return the original formula\n    return formula;\n  }\n}\n\n/**\n * Checks if a formula references a specific sheet\n * @param formula The formula string (without the leading =)\n * @param sheetName The sheet name to check for\n * @returns True if the formula references the sheet\n */\nexport function formulaReferencesSheet(formula: string, sheetName: string): boolean {\n  try {\n    const ast = parseFormula(formula);\n    const referencedSheets = getReferencedSheetNames(formula);\n    return referencedSheets.includes(sheetName);\n  } catch (error) {\n    // If parsing fails, assume no reference\n    return false;\n  }\n}\n\n/**\n * Gets all sheet names referenced in a formula\n * @param formula The formula string (without the leading =)\n * @returns Array of unique sheet names referenced in the formula\n */\nexport function getReferencedSheetNames(formula: string): string[] {\n  try {\n    const ast = parseFormula(formula);\n    const sheetNames = new Set<string>();\n\n    transformAST(ast, (node) => {\n      // Handle cross-sheet references\n      if ((node.type === \"reference\" || node.type === \"range\") && node.sheetName) {\n        sheetNames.add(node.sheetName);\n      }\n      \n      return node;\n    });\n\n    return Array.from(sheetNames);\n  } catch (error) {\n    // If parsing fails, return empty array\n    return [];\n  }\n}\n\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAI6B,IAA7B;AAC4B,IAA5B;AAC6B,IAA7B;AAUO,SAAS,oBAAoB,CAAC,SAI1B;AAAA,EACT,QAAQ,SAAS,cAAc,iBAAiB;AAAA,EAChD,IAAI;AAAA,IACF,MAAM,MAAM,2BAAa,OAAO;AAAA,IAEhC,MAAM,aAAa,kCAAa,KAAK,CAAC,SAAS;AAAA,MAE7C,IAAI,KAAK,SAAS,eAAe,KAAK,cAAc,cAAc;AAAA,QAChE,OAAO;AAAA,aACF;AAAA,UACH,WAAW;AAAA,QACb;AAAA,MACF;AAAA,MAGA,IAAI,KAAK,SAAS,WAAW,KAAK,cAAc,cAAc;AAAA,QAC5D,OAAO;AAAA,aACF;AAAA,UACH,WAAW;AAAA,QACb;AAAA,MACF;AAAA,MAEA,OAAO;AAAA,KACR;AAAA,IAED,OAAO,6BAAY,UAAU;AAAA,IAC7B,OAAO,OAAO;AAAA,IAEd,OAAO;AAAA;AAAA;AAUJ,SAAS,sBAAsB,CAAC,SAAiB,WAA4B;AAAA,EAClF,IAAI;AAAA,IACF,MAAM,MAAM,2BAAa,OAAO;AAAA,IAChC,MAAM,mBAAmB,wBAAwB,OAAO;AAAA,IACxD,OAAO,iBAAiB,SAAS,SAAS;AAAA,IAC1C,OAAO,OAAO;AAAA,IAEd,OAAO;AAAA;AAAA;AASJ,SAAS,uBAAuB,CAAC,SAA2B;AAAA,EACjE,IAAI;AAAA,IACF,MAAM,MAAM,2BAAa,OAAO;AAAA,IAChC,MAAM,aAAa,IAAI;AAAA,IAEvB,kCAAa,KAAK,CAAC,SAAS;AAAA,MAE1B,KAAK,KAAK,SAAS,eAAe,KAAK,SAAS,YAAY,KAAK,WAAW;AAAA,QAC1E,WAAW,IAAI,KAAK,SAAS;AAAA,MAC/B;AAAA,MAEA,OAAO;AAAA,KACR;AAAA,IAED,OAAO,MAAM,KAAK,UAAU;AAAA,IAC5B,OAAO,OAAO;AAAA,IAEd,OAAO,CAAC;AAAA;AAAA;",
+  "debugId": "ABD0A5EE1052D5B064756E2164756E21",
+  "names": []
+}

package/dist/cjs/core/sheet-utils.cjs

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/sheet-utils.ts
+var exports_sheet_utils = {};
+__export(exports_sheet_utils, {
+  SheetUtils: () => SheetUtils
+});
+module.exports = __toCommonJS(exports_sheet_utils);
+
+class SheetUtils {
+}
+
+//# debugId=AFBD37A1161E1DF064756E2164756E21

package/dist/cjs/core/sheet-utils.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/sheet-utils.ts"],
+  "sourcesContent": [
+    "export class SheetUtils {\n    \n}"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAO,MAAM,WAAW;AAExB;",
+  "debugId": "AFBD37A1161E1DF064756E2164756E21",
+  "names": []
+}

package/dist/cjs/core/table-renamer.cjs

@@ -0,0 +1,88 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/table-renamer.ts
+var exports_table_renamer = {};
+__export(exports_table_renamer, {
+  renameTableInFormula: () => renameTableInFormula,
+  getReferencedTableNames: () => getReferencedTableNames,
+  formulaReferencesTable: () => formulaReferencesTable
+});
+module.exports = __toCommonJS(exports_table_renamer);
+var import_parser = require("../parser/parser.cjs");
+var import_formatter = require("../parser/formatter.cjs");
+var import_ast_traverser = require("./ast-traverser.cjs");
+function renameTableInFormula(formula, oldTableName, newTableName) {
+  try {
+    const ast = import_parser.parseFormula(formula);
+    const transformedAST = import_ast_traverser.transformAST(ast, (node) => {
+      if (node.type === "structured-reference" && node.tableName === oldTableName) {
+        return {
+          ...node,
+          tableName: newTableName
+        };
+      }
+      return node;
+    });
+    return import_formatter.astToString(transformedAST);
+  } catch (error) {
+    return formula;
+  }
+}
+function formulaReferencesTable(formula, tableName) {
+  try {
+    const ast = import_parser.parseFormula(formula);
+    let hasReference = false;
+    import_ast_traverser.transformAST(ast, (node) => {
+      if (node.type === "structured-reference" && node.tableName === tableName) {
+        hasReference = true;
+      }
+      return node;
+    });
+    return hasReference;
+  } catch (error) {
+    return false;
+  }
+}
+function getReferencedTableNames(formula) {
+  try {
+    const ast = import_parser.parseFormula(formula);
+    const tableNames = new Set;
+    import_ast_traverser.transformAST(ast, (node) => {
+      if (node.type === "structured-reference" && node.tableName) {
+        tableNames.add(node.tableName);
+      }
+      return node;
+    });
+    return Array.from(tableNames);
+  } catch (error) {
+    return [];
+  }
+}
+
+//# debugId=1BAF4F172CC0F81864756E2164756E21

package/dist/cjs/core/table-renamer.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/table-renamer.ts"],
+  "sourcesContent": [
+    "import { parseFormula } from \"../parser/parser.cjs\";\nimport { astToString } from \"../parser/formatter.cjs\";\nimport { transformAST } from \"./ast-traverser.cjs\";\n\n/**\n * Renames table references in a formula string\n * @param formula - The formula string (without the leading =)\n * @param oldTableName - The current table name to replace\n * @param newTableName - The new table name\n * @returns The updated formula string, or the original if no changes were made\n */\nexport function renameTableInFormula(\n  formula: string,\n  oldTableName: string,\n  newTableName: string\n): string {\n  try {\n    const ast = parseFormula(formula);\n    \n    const transformedAST = transformAST(ast, (node) => {\n      if (node.type === \"structured-reference\" && node.tableName === oldTableName) {\n        return {\n          ...node,\n          tableName: newTableName\n        };\n      }\n      return node;\n    });\n\n    return astToString(transformedAST);\n  } catch (error) {\n    // If parsing fails, return the original formula\n    return formula;\n  }\n}\n\n/**\n * Checks if a formula contains references to a specific table\n * @param formula - The formula string (without the leading =)\n * @param tableName - The table name to search for\n * @returns True if the formula contains references to the table\n */\nexport function formulaReferencesTable(formula: string, tableName: string): boolean {\n  try {\n    const ast = parseFormula(formula);\n    let hasReference = false;\n\n    transformAST(ast, (node) => {\n      if (node.type === \"structured-reference\" && node.tableName === tableName) {\n        hasReference = true;\n      }\n      return node;\n    });\n\n    return hasReference;\n  } catch (error) {\n    // If parsing fails, assume no reference\n    return false;\n  }\n}\n\n/**\n * Gets all table names referenced in a formula\n * @param formula - The formula string (without the leading =)\n * @returns Array of unique table names referenced in the formula\n */\nexport function getReferencedTableNames(formula: string): string[] {\n  try {\n    const ast = parseFormula(formula);\n    const tableNames = new Set<string>();\n\n    transformAST(ast, (node) => {\n      if (node.type === \"structured-reference\" && node.tableName) {\n        tableNames.add(node.tableName);\n      }\n      return node;\n    });\n\n    return Array.from(tableNames);\n  } catch (error) {\n    // If parsing fails, return empty array\n    return [];\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAA6B,IAA7B;AAC4B,IAA5B;AAC6B,IAA7B;AASO,SAAS,oBAAoB,CAClC,SACA,cACA,cACQ;AAAA,EACR,IAAI;AAAA,IACF,MAAM,MAAM,2BAAa,OAAO;AAAA,IAEhC,MAAM,iBAAiB,kCAAa,KAAK,CAAC,SAAS;AAAA,MACjD,IAAI,KAAK,SAAS,0BAA0B,KAAK,cAAc,cAAc;AAAA,QAC3E,OAAO;AAAA,aACF;AAAA,UACH,WAAW;AAAA,QACb;AAAA,MACF;AAAA,MACA,OAAO;AAAA,KACR;AAAA,IAED,OAAO,6BAAY,cAAc;AAAA,IACjC,OAAO,OAAO;AAAA,IAEd,OAAO;AAAA;AAAA;AAUJ,SAAS,sBAAsB,CAAC,SAAiB,WAA4B;AAAA,EAClF,IAAI;AAAA,IACF,MAAM,MAAM,2BAAa,OAAO;AAAA,IAChC,IAAI,eAAe;AAAA,IAEnB,kCAAa,KAAK,CAAC,SAAS;AAAA,MAC1B,IAAI,KAAK,SAAS,0BAA0B,KAAK,cAAc,WAAW;AAAA,QACxE,eAAe;AAAA,MACjB;AAAA,MACA,OAAO;AAAA,KACR;AAAA,IAED,OAAO;AAAA,IACP,OAAO,OAAO;AAAA,IAEd,OAAO;AAAA;AAAA;AASJ,SAAS,uBAAuB,CAAC,SAA2B;AAAA,EACjE,IAAI;AAAA,IACF,MAAM,MAAM,2BAAa,OAAO;AAAA,IAChC,MAAM,aAAa,IAAI;AAAA,IAEvB,kCAAa,KAAK,CAAC,SAAS;AAAA,MAC1B,IAAI,KAAK,SAAS,0BAA0B,KAAK,WAAW;AAAA,QAC1D,WAAW,IAAI,KAAK,SAAS;AAAA,MAC/B;AAAA,MACA,OAAO;AAAA,KACR;AAAA,IAED,OAAO,MAAM,KAAK,UAAU;AAAA,IAC5B,OAAO,OAAO;AAAA,IAEd,OAAO,CAAC;AAAA;AAAA;",
+  "debugId": "1BAF4F172CC0F81864756E2164756E21",
+  "names": []
+}

package/dist/cjs/core/types.cjs

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/types.ts
+var exports_types = {};
+__export(exports_types, {
+  FormulaError: () => FormulaError
+});
+module.exports = __toCommonJS(exports_types);
+var FormulaError;
+((FormulaError2) => {
+  FormulaError2["DIV0"] = "#DIV/0!";
+  FormulaError2["NA"] = "#N/A";
+  FormulaError2["NAME"] = "#NAME?";
+  FormulaError2["NUM"] = "#NUM!";
+  FormulaError2["REF"] = "#REF!";
+  FormulaError2["VALUE"] = "#VALUE!";
+  FormulaError2["CYCLE"] = "#CYCLE!";
+  FormulaError2["ERROR"] = "#ERROR!";
+  FormulaError2["SPILL"] = "#SPILL!";
+})(FormulaError ||= {});
+
+//# debugId=F54C7C141D21E24164756E2164756E21

package/dist/cjs/core/types.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/types.ts"],
+  "sourcesContent": [
+    "/**\n * Core type definitions for FormulaEngine\n * This file contains all fundamental types used throughout the engine\n */\n\nimport type { ASTNode, FunctionNode } from \"src/parser/ast\";\nimport type { FormulaEngine } from \"./engine.cjs\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { CellValueNode } from \"src/evaluator/dependency-nodes/cell-value-node\";\nimport type { EmptyCellEvaluationNode } from \"src/evaluator/dependency-nodes/empty-cell-evaluation-node\";\nimport type { RangeEvaluationNode } from \"src/evaluator/range-evaluation-node\";\nimport type { DependencyNode } from \"./managers/dependency-node.cjs\";\nimport type { LookupOrder } from \"./managers/range-eval-order-builder.cjs\";\n\n// Cell addressing types\nexport interface CellAddress {\n  sheetName: string;\n  workbookName: string;\n  colIndex: number;\n  rowIndex: number;\n}\n\nexport interface RangeAddress {\n  sheetName: string;\n  workbookName: string;\n  range: SpreadsheetRange;\n}\n\nexport interface LocalCellAddress {\n  colIndex: number;\n  rowIndex: number;\n}\n\nexport type ArethmeticEvaluator = (\n  left: CellValue,\n  right: CellValue,\n  context: EvaluationContext\n) => CellValue | ErrorEvaluationResult;\n\nexport type PositiveInfinity = {\n  type: \"infinity\";\n  sign: \"positive\";\n};\n\nexport type CellInfinity = {\n  type: \"infinity\";\n  sign: \"positive\" | \"negative\";\n};\n\nexport type CellNumber = {\n  type: \"number\";\n  value: number;\n};\n\nexport type SpreadsheetRangeEnd = CellNumber | PositiveInfinity;\n\nexport type SpreadsheetRange = {\n  start: {\n    col: number;\n    row: number;\n  };\n  end: {\n    col: SpreadsheetRangeEnd;\n    row: SpreadsheetRangeEnd;\n  };\n};\n\nexport type RelativeRange = {\n  start: {\n    col: number;\n    row: number;\n  };\n  width: SpreadsheetRangeEnd;\n  height: SpreadsheetRangeEnd;\n};\n\nexport type FiniteSpreadsheetRange = {\n  start: {\n    col: number;\n    row: number;\n  };\n  end: {\n    col: number;\n    row: number;\n  };\n};\n\nexport type CellString = {\n  type: \"string\";\n  value: string;\n};\n\nexport type CellBoolean = {\n  type: \"boolean\";\n  value: boolean;\n};\n\n// Cell value types\nexport type CellValue = CellNumber | CellString | CellBoolean | CellInfinity;\n/**\n * undefined and \"\" are considered empty values\n * undefineds are converted to \"\" in the engine\n *\n * any empty values are deleted from the sheet content\n */\nexport type SerializedCellValue = string | number | boolean | undefined;\n\n// Named expressions\nexport interface NamedExpression {\n  name: string;\n  expression: string;\n}\n\nexport interface TableDefinition {\n  name: string;\n  start: {\n    rowIndex: number;\n    colIndex: number;\n  };\n  headers: Map<string, { name: string; index: number }>;\n  endRow: SpreadsheetRangeEnd;\n  sheetName: string;\n  workbookName: string;\n}\n\n// Formula errors\nexport enum FormulaError {\n  DIV0 = \"#DIV/0!\",\n  NA = \"#N/A\",\n  NAME = \"#NAME?\",\n  NUM = \"#NUM!\",\n  REF = \"#REF!\",\n  VALUE = \"#VALUE!\",\n  CYCLE = \"#CYCLE!\",\n  ERROR = \"#ERROR!\",\n  SPILL = \"#SPILL!\",\n}\n\n// Sheet structure\nexport interface Sheet {\n  name: string;\n  index: number; // 0-based index of the sheet\n  content: Map<string, SerializedCellValue>;\n}\n\nexport interface Workbook {\n  name: string;\n  sheets: Map<string, Sheet>;\n}\n\nexport type ValueEvaluationResult = {\n  type: \"value\";\n  result: CellValue;\n  /**\n   * If the terminating evaluation result is a reference (see evaluateReference)\n   * then we store information about the source cell for context dependent functions like CELL\n   */\n  sourceCell?: CellAddress;\n};\n\nexport type AwaitingEvaluationResult = {\n  type: \"awaiting-evaluation\";\n  waitingFor: DependencyNode;\n  errAddress: DependencyNode;\n  /**\n   * If the terminating evaluation result is a reference (see evaluateReference)\n   * then we store information about the source cell for context dependent functions like CELL\n   */\n  sourceCell?: CellAddress;\n};\n\nexport type DoesNotSpillResult = {\n  type: \"does-not-spill\";\n};\n\nexport type ErrorEvaluationResult =\n  | {\n      type: \"error\";\n      err: FormulaError;\n      errAddress: DependencyNode;\n      message: string;\n      /**\n       * If the terminating evaluation result is a reference (see evaluateReference)\n       * then we store information about the source cell for context dependent functions like CELL\n       */\n      sourceCell?: CellAddress;\n    }\n  | AwaitingEvaluationResult;\n\nexport type SingleEvaluationResult =\n  | ValueEvaluationResult\n  | ErrorEvaluationResult;\n\nexport type SpilledValuesEvaluator = (\n  spillOffset: { x: number; y: number },\n  context: EvaluationContext\n) => SingleEvaluationResult;\n\nexport type SpilledValuesEvaluationResult = {\n  type: \"spilled-values\";\n\n  /**\n   * When a raw range is evaluated, we will add it to the sourceRange so it can be used e.g. for context dependent functions\n   */\n  sourceRange?: RangeAddress;\n\n  /**\n   * If the terminating evaluation result is a reference (see evaluateReference)\n   * then we store information about the source cell for context dependent functions like CELL\n   * sourceCell will only be defined on a spilledValue when a single value is looked up,\n   */\n  sourceCell?: CellAddress;\n\n  spillArea: (origin: CellAddress) => SpreadsheetRange;\n  /**\n   * for debugging we add a source string to denote where the spilled values were created\n   */\n  source: string;\n  evaluate: SpilledValuesEvaluator;\n  /**\n   * evaluateAllCells evaluates all non-empty cells in the spilled range.\n   * Because a spilled range can be open-ended, we need to have logic for which cells we should evaluate.\n   * e.g. when evaluating a range such as D:D only the cells in the current sheet residing in\n   * column D should be evaluated and cells producing spilled values that spill onto D:D.\n   *\n   * In order to evaluate spilled cells in D:D the range evaluateAllCells need to get all cells in the\n   * the intersection of the spilled range and D:D, for that reason evaluateAllCells gets an intersection parameter,\n   * where the intersection is relative to the origin.\n   *\n   * #### Producers:\n   * In e.g. SEQUENCE and evaluateRange we have logic for which cells in a spilled range we should evaluate,\n   *\n   * #### Nesting:\n   * e.g. evaluation of scalar operators where we want to nest e.g. `5 * right.evaluate()`\n   * can be implemented by calling\n   * ```ts\n   * const vals = child.evaluateAllCells.call(this, options);\n   * return vals.map(val => ({ ...val, result: 5 * val.result }));\n   * ```\n   *\n   * #### Consumers:\n   * Only functions that need access to all spilled values in a range end up calling evaluateAllCells, e.g.\n   * SUM, MIN, MAX, MATCH. Other types of functions like INDEX doesn't need to evaluate all cells in a range,\n   * but does a lookup into a spilled range using the evaluate method.\n   *\n   */\n  evaluateAllCells: (\n    this: FormulaEvaluator,\n    options: {\n      /**\n       * an intersection relative to the origin\n       */\n      intersection?: SpreadsheetRange;\n      evaluate: SpilledValuesEvaluator;\n      context: EvaluationContext;\n      /**\n       * origin is the cell address that the spilled range is spilled from\n       * e.g. in A3=B2:B4 the origin is A3\n       */\n      origin: CellAddress;\n\n      lookupOrder: LookupOrder;\n    }\n  ) => EvaluateAllCellsResult;\n};\n\nexport type EvaluateAllCellsResult =\n  | ErrorEvaluationResult\n  | {\n      type: \"values\";\n      values: CellInRangeResult[];\n    };\n\nexport type CellInRangeResult = {\n  result: SingleEvaluationResult;\n  relativePos: { x: number; y: number };\n};\n\nexport type FunctionEvaluationResult =\n  | SingleEvaluationResult\n  | SpilledValuesEvaluationResult;\n\nexport type SpilledValue = {\n  /**\n   * spillOnto is the range that the spilled value is spilled onto\n   */\n  spillOnto: SpreadsheetRange;\n  /**\n   * origin is the cell address that the spilled value is spilled from\n   */\n  origin: CellAddress;\n};\n\n/**\n * Function definition\n */\nexport interface FunctionDefinition {\n  name: string;\n  evaluate: (\n    this: FormulaEvaluator,\n    node: FunctionNode,\n    context: EvaluationContext\n  ) => FunctionEvaluationResult;\n  aliases?: string[];\n}\n\n/**\n * Evaluation result\n */\nexport type EvaluationResult = {\n  dependencies: Set<string>;\n} & FunctionEvaluationResult;\n\nexport type SCC = {\n  id: number;\n  nodes: Set<DependencyNode>; // All nodes considering soft + hard edges\n  evaluationOrder: DependencyNode[]; // Flat topologically ordered list\n  resolved: boolean;\n  hardEdgeSCCs: Set<DependencyNode>[]; // SCCs formed by only hard edges (regular dependencies)\n};\n\nexport type SCCDAG = {\n  sccList: SCC[];\n  sccGraph: Map<number, Set<number>>; // Adjacency list of SCC dependencies\n};\n\nexport type EvaluationOrder = {\n  evaluationOrder: Set<DependencyNode>;\n  hasCycle: boolean;\n  cycleNodes?: Set<DependencyNode>;\n  hash: string;\n  sccDAG?: SCCDAG;\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+HO,IAAK;AAAA,CAAL,CAAK,kBAAL;AAAA,EACL,wBAAO;AAAA,EACP,sBAAK;AAAA,EACL,wBAAO;AAAA,EACP,uBAAM;AAAA,EACN,uBAAM;AAAA,EACN,yBAAQ;AAAA,EACR,yBAAQ;AAAA,EACR,yBAAQ;AAAA,EACR,yBAAQ;AAAA,GATE;",
+  "debugId": "F54C7C141D21E24164756E2164756E21",
+  "names": []
+}

package/dist/cjs/core/utils/range-serializer.cjs

@@ -0,0 +1,65 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/utils/range-serializer.ts
+var exports_range_serializer = {};
+__export(exports_range_serializer, {
+  serializeRangeWithSheet: () => serializeRangeWithSheet,
+  serializeRange: () => serializeRange
+});
+module.exports = __toCommonJS(exports_range_serializer);
+var import_utils = require("../utils.cjs");
+function serializeRange(range) {
+  const startCell = `${import_utils.indexToColumn(range.start.col)}${import_utils.getRowNumber(range.start.row)}`;
+  const endRowIsInfinity = range.end.row.type === "infinity";
+  const endColIsInfinity = range.end.col.type === "infinity";
+  let rangeEnd;
+  if (endRowIsInfinity && endColIsInfinity) {
+    rangeEnd = "INFINITY";
+  } else if (endRowIsInfinity && range.end.col.type === "number") {
+    rangeEnd = import_utils.indexToColumn(range.end.col.value);
+  } else if (range.end.row.type === "number" && endColIsInfinity) {
+    rangeEnd = import_utils.getRowNumber(range.end.row.value).toString();
+  } else if (range.end.row.type === "number" && range.end.col.type === "number") {
+    rangeEnd = `${import_utils.indexToColumn(range.end.col.value)}${import_utils.getRowNumber(range.end.row.value)}`;
+  } else {
+    throw new Error("Invalid range end configuration");
+  }
+  return `${startCell}:${rangeEnd}`;
+}
+function serializeRangeWithSheet(range, sheetName) {
+  const rangeStr = serializeRange(range);
+  if (sheetName) {
+    const needsQuotes = /[^A-Za-z0-9_]/.test(sheetName);
+    const quotedSheetName = needsQuotes ? `'${sheetName}'` : sheetName;
+    return `${quotedSheetName}!${rangeStr}`;
+  }
+  return rangeStr;
+}
+
+//# debugId=87F8373DEBFB4B2D64756E2164756E21

package/dist/cjs/core/utils/range-serializer.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/core/utils/range-serializer.ts"],
+  "sourcesContent": [
+    "import type { SpreadsheetRange } from \"../types.cjs\";\nimport { indexToColumn, getRowNumber } from \"../utils.cjs\";\n\n/**\n * Serializes a SpreadsheetRange into a human-readable range string following canonical format.\n * \n * Examples:\n * - Finite range: A2:B10\n * - Column-infinite range: A2:B (row infinite, column bounded)\n * - Row-infinite range: A2:10 (column infinite, row bounded)\n * - Fully infinite range: A2:INFINITY (both infinite)\n * \n * @param range The SpreadsheetRange to serialize\n * @returns A human-readable range string in canonical format\n */\nexport function serializeRange(range: SpreadsheetRange): string {\n  // Format start cell\n  const startCell = `${indexToColumn(range.start.col)}${getRowNumber(range.start.row)}`;\n  \n  // Determine end format based on infinity types\n  const endRowIsInfinity = range.end.row.type === \"infinity\";\n  const endColIsInfinity = range.end.col.type === \"infinity\";\n  \n  let rangeEnd: string;\n  \n  if (endRowIsInfinity && endColIsInfinity) {\n    // Both infinite: A2:INFINITY\n    rangeEnd = \"INFINITY\";\n  } else if (endRowIsInfinity && range.end.col.type === \"number\") {\n    // Row infinite, col finite: A2:B (column only)\n    rangeEnd = indexToColumn(range.end.col.value);\n  } else if (range.end.row.type === \"number\" && endColIsInfinity) {\n    // Row finite, col infinite: A2:10 (row only)\n    rangeEnd = getRowNumber(range.end.row.value).toString();\n  } else if (range.end.row.type === \"number\" && range.end.col.type === \"number\") {\n    // Both finite: A2:B10\n    rangeEnd = `${indexToColumn(range.end.col.value)}${getRowNumber(range.end.row.value)}`;\n  } else {\n    throw new Error(\"Invalid range end configuration\");\n  }\n  \n  return `${startCell}:${rangeEnd}`;\n}\n\n/**\n * Serializes a SpreadsheetRange with an optional sheet name prefix.\n * \n * @param range The SpreadsheetRange to serialize\n * @param sheetName Optional sheet name to prefix the range\n * @returns A human-readable range string, optionally prefixed with sheet name\n */\nexport function serializeRangeWithSheet(range: SpreadsheetRange, sheetName?: string): string {\n  const rangeStr = serializeRange(range);\n  \n  if (sheetName) {\n    // Handle sheet names that need quoting (contain spaces or special characters)\n    const needsQuotes = /[^A-Za-z0-9_]/.test(sheetName);\n    const quotedSheetName = needsQuotes ? `'${sheetName}'` : sheetName;\n    return `${quotedSheetName}!${rangeStr}`;\n  }\n  \n  return rangeStr;\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC4C,IAA5C;AAcO,SAAS,cAAc,CAAC,OAAiC;AAAA,EAE9D,MAAM,YAAY,GAAG,2BAAc,MAAM,MAAM,GAAG,IAAI,0BAAa,MAAM,MAAM,GAAG;AAAA,EAGlF,MAAM,mBAAmB,MAAM,IAAI,IAAI,SAAS;AAAA,EAChD,MAAM,mBAAmB,MAAM,IAAI,IAAI,SAAS;AAAA,EAEhD,IAAI;AAAA,EAEJ,IAAI,oBAAoB,kBAAkB;AAAA,IAExC,WAAW;AAAA,EACb,EAAO,SAAI,oBAAoB,MAAM,IAAI,IAAI,SAAS,UAAU;AAAA,IAE9D,WAAW,2BAAc,MAAM,IAAI,IAAI,KAAK;AAAA,EAC9C,EAAO,SAAI,MAAM,IAAI,IAAI,SAAS,YAAY,kBAAkB;AAAA,IAE9D,WAAW,0BAAa,MAAM,IAAI,IAAI,KAAK,EAAE,SAAS;AAAA,EACxD,EAAO,SAAI,MAAM,IAAI,IAAI,SAAS,YAAY,MAAM,IAAI,IAAI,SAAS,UAAU;AAAA,IAE7E,WAAW,GAAG,2BAAc,MAAM,IAAI,IAAI,KAAK,IAAI,0BAAa,MAAM,IAAI,IAAI,KAAK;AAAA,EACrF,EAAO;AAAA,IACL,MAAM,IAAI,MAAM,iCAAiC;AAAA;AAAA,EAGnD,OAAO,GAAG,aAAa;AAAA;AAUlB,SAAS,uBAAuB,CAAC,OAAyB,WAA4B;AAAA,EAC3F,MAAM,WAAW,eAAe,KAAK;AAAA,EAErC,IAAI,WAAW;AAAA,IAEb,MAAM,cAAc,gBAAgB,KAAK,SAAS;AAAA,IAClD,MAAM,kBAAkB,cAAc,IAAI,eAAe;AAAA,IACzD,OAAO,GAAG,mBAAmB;AAAA,EAC/B;AAAA,EAEA,OAAO;AAAA;",
+  "debugId": "87F8373DEBFB4B2D64756E2164756E21",
+  "names": []
+}