@ricsam/formula-engine 0.2.2 → 0.2.3

package/dist/cjs/evaluator/comparison/equals.cjs

@@ -2,27 +2,37 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).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
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -61,4 +71,4 @@ var equals = (left, right) => {
   return { type: "boolean", value: false };
 };
 
-//# debugId=2C4AFBAA566A87C564756E2164756E21
+//# debugId=BAFBF851028614E064756E2164756E21

package/dist/cjs/evaluator/comparison/equals.cjs.map

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\n\n/**\n * Equals operator (=) - Returns TRUE if both values are exactly equal\n * Strict type checking: both type and value must match\n */\nexport const equals: ArethmeticEvaluator = (left, right) => {\n  // Check type equality first\n  if (left.type !== right.type) {\n    return { type: \"boolean\", value: false };\n  }\n\n  // Handle each type specifically\n  switch (left.type) {\n    case \"number\":\n      if (right.type === \"number\") {\n        return { type: \"boolean\", value: left.value === right.value };\n      }\n      break;\n    \n    case \"string\":\n      if (right.type === \"string\") {\n        return { type: \"boolean\", value: left.value === right.value };\n      }\n      break;\n    \n    case \"boolean\":\n      if (right.type === \"boolean\") {\n        return { type: \"boolean\", value: left.value === right.value };\n      }\n      break;\n    \n    case \"infinity\":\n      if (right.type === \"infinity\") {\n        return { type: \"boolean\", value: left.sign === right.sign };\n      }\n      break;\n  }\n\n  // This should never be reached due to type check above\n  return { type: \"boolean\", value: false };\n};\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,IAAM,SAA8B,CAAC,MAAM,UAAU;AAAA,EAE1D,IAAI,KAAK,SAAS,MAAM,MAAM;AAAA,IAC5B,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA,EACzC;AAAA,EAGA,QAAQ,KAAK;AAAA,SACN;AAAA,MACH,IAAI,MAAM,SAAS,UAAU;AAAA,QAC3B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,UAAU,MAAM,MAAM;AAAA,MAC9D;AAAA,MACA;AAAA,SAEG;AAAA,MACH,IAAI,MAAM,SAAS,UAAU;AAAA,QAC3B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,UAAU,MAAM,MAAM;AAAA,MAC9D;AAAA,MACA;AAAA,SAEG;AAAA,MACH,IAAI,MAAM,SAAS,WAAW;AAAA,QAC5B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,UAAU,MAAM,MAAM;AAAA,MAC9D;AAAA,MACA;AAAA,SAEG;AAAA,MACH,IAAI,MAAM,SAAS,YAAY;AAAA,QAC7B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,SAAS,MAAM,KAAK;AAAA,MAC5D;AAAA,MACA;AAAA;AAAA,EAIJ,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA;",
-  "debugId": "2C4AFBAA566A87C564756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOO,IAAM,SAA8B,CAAC,MAAM,UAAU;AAAA,EAE1D,IAAI,KAAK,SAAS,MAAM,MAAM;AAAA,IAC5B,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA,EACzC;AAAA,EAGA,QAAQ,KAAK;AAAA,SACN;AAAA,MACH,IAAI,MAAM,SAAS,UAAU;AAAA,QAC3B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,UAAU,MAAM,MAAM;AAAA,MAC9D;AAAA,MACA;AAAA,SAEG;AAAA,MACH,IAAI,MAAM,SAAS,UAAU;AAAA,QAC3B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,UAAU,MAAM,MAAM;AAAA,MAC9D;AAAA,MACA;AAAA,SAEG;AAAA,MACH,IAAI,MAAM,SAAS,WAAW;AAAA,QAC5B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,UAAU,MAAM,MAAM;AAAA,MAC9D;AAAA,MACA;AAAA,SAEG;AAAA,MACH,IAAI,MAAM,SAAS,YAAY;AAAA,QAC7B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,SAAS,MAAM,KAAK;AAAA,MAC5D;AAAA,MACA;AAAA;AAAA,EAIJ,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA;",
+  "debugId": "BAFBF851028614E064756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/comparison/greater-than-or-equal.cjs

@@ -2,27 +2,37 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).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
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -58,4 +68,4 @@ var greaterThanOrEqual = (left, right, context) => {
   };
 };
 
-//# debugId=73E0122E9857568264756E2164756E21
+//# debugId=22662DF023D003E364756E2164756E21

package/dist/cjs/evaluator/comparison/greater-than-or-equal.cjs.map

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\nimport { lessThan } from \"./less-than.cjs\";\n\n/**\n * Greater than or equal operator (>=) - Returns TRUE if left >= right\n * Implemented as NOT (left < right)\n */\nexport const greaterThanOrEqual: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if ((left.type !== \"number\" && left.type !== \"infinity\") ||\n      (right.type !== \"number\" && right.type !== \"infinity\")) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot compare ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  const ltResult = lessThan(left, right, context);\n  if (ltResult.type === \"error\" || ltResult.type === \"awaiting-evaluation\") {\n    return ltResult;\n  }\n  \n  if (ltResult.type === \"boolean\") {\n    return { type: \"boolean\", value: !ltResult.value };\n  }\n  \n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: \"Invalid comparison result\",\n    errAddress: context.dependencyNode,\n  };\n};\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACyB,IAAzB;AAMO,IAAM,qBAA0C,CAAC,MAAM,OAAO,YAAY;AAAA,EAE/E,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,0BAAS,MAAM,OAAO,OAAO;AAAA,EAC9C,IAAI,SAAS,SAAS,WAAW,SAAS,SAAS,uBAAuB;AAAA,IACxE,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAAS,SAAS,WAAW;AAAA,IAC/B,OAAO,EAAE,MAAM,WAAW,OAAO,CAAC,SAAS,MAAM;AAAA,EACnD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
-  "debugId": "73E0122E9857568264756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACyB,IAAzB;AAMO,IAAM,qBAA0C,CAAC,MAAM,OAAO,YAAY;AAAA,EAE/E,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,0BAAS,MAAM,OAAO,OAAO;AAAA,EAC9C,IAAI,SAAS,SAAS,WAAW,SAAS,SAAS,uBAAuB;AAAA,IACxE,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAAS,SAAS,WAAW;AAAA,IAC/B,OAAO,EAAE,MAAM,WAAW,OAAO,CAAC,SAAS,MAAM;AAAA,EACnD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "22662DF023D003E364756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/comparison/greater-than.cjs

@@ -2,27 +2,37 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).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
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -58,4 +68,4 @@ var greaterThan = (left, right, context) => {
   };
 };
 
-//# debugId=54C39A2F0592101E64756E2164756E21
+//# debugId=DFB160676A206F1C64756E2164756E21

package/dist/cjs/evaluator/comparison/greater-than.cjs.map

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\nimport { lessThanOrEqual } from \"./less-than-or-equal.cjs\";\n\n/**\n * Greater than operator (>) - Returns TRUE if left > right\n * Implemented as NOT (left <= right)\n */\nexport const greaterThan: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if ((left.type !== \"number\" && left.type !== \"infinity\") ||\n      (right.type !== \"number\" && right.type !== \"infinity\")) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot compare ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  const lteResult = lessThanOrEqual(left, right, context);\n  if (lteResult.type === \"error\" || lteResult.type === \"awaiting-evaluation\") {\n    return lteResult;\n  }\n  \n  if (lteResult.type === \"boolean\") {\n    return { type: \"boolean\", value: !lteResult.value };\n  }\n  \n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: \"Invalid comparison result\",\n    errAddress: context.dependencyNode,\n  };\n};\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACgC,IAAhC;AAMO,IAAM,cAAmC,CAAC,MAAM,OAAO,YAAY;AAAA,EAExE,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,YAAY,0CAAgB,MAAM,OAAO,OAAO;AAAA,EACtD,IAAI,UAAU,SAAS,WAAW,UAAU,SAAS,uBAAuB;AAAA,IAC1E,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,UAAU,SAAS,WAAW;AAAA,IAChC,OAAO,EAAE,MAAM,WAAW,OAAO,CAAC,UAAU,MAAM;AAAA,EACpD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
-  "debugId": "54C39A2F0592101E64756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACgC,IAAhC;AAMO,IAAM,cAAmC,CAAC,MAAM,OAAO,YAAY;AAAA,EAExE,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,YAAY,0CAAgB,MAAM,OAAO,OAAO;AAAA,EACtD,IAAI,UAAU,SAAS,WAAW,UAAU,SAAS,uBAAuB;AAAA,IAC1E,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,UAAU,SAAS,WAAW;AAAA,IAChC,OAAO,EAAE,MAAM,WAAW,OAAO,CAAC,UAAU,MAAM;AAAA,EACpD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "DFB160676A206F1C64756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/comparison/less-than-or-equal.cjs

@@ -2,27 +2,37 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).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
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -66,4 +76,4 @@ var lessThanOrEqual = (left, right, context) => {
   };
 };
 
-//# debugId=9E5011BF96D756C964756E2164756E21
+//# debugId=3A5E58FA07A1591264756E2164756E21

package/dist/cjs/evaluator/comparison/less-than-or-equal.cjs.map

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\nimport { lessThan } from \"./less-than.cjs\";\nimport { equals } from \"./equals.cjs\";\n\n/**\n * Less than or equal operator (<=) - Returns TRUE if left <= right\n * Uses lessThan OR equals logic\n */\nexport const lessThanOrEqual: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if ((left.type !== \"number\" && left.type !== \"infinity\") ||\n      (right.type !== \"number\" && right.type !== \"infinity\")) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot compare ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  const ltResult = lessThan(left, right, context);\n  if (ltResult.type === \"error\" || ltResult.type === \"awaiting-evaluation\") {\n    return ltResult;\n  }\n  \n  if (ltResult.type === \"boolean\" && ltResult.value === true) {\n    return { type: \"boolean\", value: true };\n  }\n  \n  // Check equality\n  const eqResult = equals(left, right, context);\n  if (eqResult.type === \"error\" || eqResult.type === \"awaiting-evaluation\") {\n    return eqResult;\n  }\n  \n  if (eqResult.type === \"boolean\") {\n    return { type: \"boolean\", value: eqResult.value };\n  }\n  \n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: \"Invalid comparison result\",\n    errAddress: context.dependencyNode,\n  };\n};\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACyB,IAAzB;AACuB,IAAvB;AAMO,IAAM,kBAAuC,CAAC,MAAM,OAAO,YAAY;AAAA,EAE5E,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,0BAAS,MAAM,OAAO,OAAO;AAAA,EAC9C,IAAI,SAAS,SAAS,WAAW,SAAS,SAAS,uBAAuB;AAAA,IACxE,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAAS,SAAS,aAAa,SAAS,UAAU,MAAM;AAAA,IAC1D,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK;AAAA,EACxC;AAAA,EAGA,MAAM,WAAW,qBAAO,MAAM,OAAO,OAAO;AAAA,EAC5C,IAAI,SAAS,SAAS,WAAW,SAAS,SAAS,uBAAuB;AAAA,IACxE,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAAS,SAAS,WAAW;AAAA,IAC/B,OAAO,EAAE,MAAM,WAAW,OAAO,SAAS,MAAM;AAAA,EAClD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
-  "debugId": "9E5011BF96D756C964756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACyB,IAAzB;AACuB,IAAvB;AAMO,IAAM,kBAAuC,CAAC,MAAM,OAAO,YAAY;AAAA,EAE5E,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,0BAAS,MAAM,OAAO,OAAO;AAAA,EAC9C,IAAI,SAAS,SAAS,WAAW,SAAS,SAAS,uBAAuB;AAAA,IACxE,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAAS,SAAS,aAAa,SAAS,UAAU,MAAM;AAAA,IAC1D,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK;AAAA,EACxC;AAAA,EAGA,MAAM,WAAW,qBAAO,MAAM,OAAO,OAAO;AAAA,EAC5C,IAAI,SAAS,SAAS,WAAW,SAAS,SAAS,uBAAuB;AAAA,IACxE,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAAS,SAAS,WAAW;AAAA,IAC/B,OAAO,EAAE,MAAM,WAAW,OAAO,SAAS,MAAM;AAAA,EAClD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "3A5E58FA07A1591264756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/comparison/less-than.cjs

@@ -2,27 +2,37 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).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
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -65,4 +75,4 @@ var lessThan = (left, right, context) => {
   };
 };
 
-//# debugId=E05D3E66898EA2FC64756E2164756E21
+//# debugId=F9AD84D0B2B9344364756E2164756E21

package/dist/cjs/evaluator/comparison/less-than.cjs.map

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\n\n/**\n * Less than operator (<) - Returns TRUE if left < right\n * Only works with numbers and infinity\n */\nexport const lessThan: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if ((left.type !== \"number\" && left.type !== \"infinity\") ||\n      (right.type !== \"number\" && right.type !== \"infinity\")) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot compare ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Handle infinity cases\n  if (left.type === \"infinity\" && right.type === \"infinity\") {\n    // -∞ < +∞ is true, otherwise false (same infinities are equal)\n    if (left.sign === \"negative\" && right.sign === \"positive\") {\n      return { type: \"boolean\", value: true };\n    }\n    return { type: \"boolean\", value: false };\n  }\n  \n  if (left.type === \"infinity\") {\n    // +∞ is never less than anything, -∞ is less than any number\n    return { type: \"boolean\", value: left.sign === \"negative\" };\n  }\n  \n  if (right.type === \"infinity\") {\n    // Any number is less than +∞, no number is less than -∞\n    return { type: \"boolean\", value: right.sign === \"positive\" };\n  }\n  \n  // Both are numbers\n  if (left.type === \"number\" && right.type === \"number\") {\n    return { type: \"boolean\", value: left.value < right.value };\n  }\n  \n  // This should never be reached\n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: `Cannot compare ${left.type} and ${right.type}`,\n    errAddress: context.dependencyNode,\n  };\n};\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AAMO,IAAM,WAAgC,CAAC,MAAM,OAAO,YAAY;AAAA,EAErE,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,IAEzD,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,MACzD,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK;AAAA,IACxC;AAAA,IACA,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA,EACzC;AAAA,EAEA,IAAI,KAAK,SAAS,YAAY;AAAA,IAE5B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,SAAS,WAAW;AAAA,EAC5D;AAAA,EAEA,IAAI,MAAM,SAAS,YAAY;AAAA,IAE7B,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM,SAAS,WAAW;AAAA,EAC7D;AAAA,EAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,UAAU;AAAA,IACrD,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,QAAQ,MAAM,MAAM;AAAA,EAC5D;AAAA,EAGA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,IAClD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
-  "debugId": "E05D3E66898EA2FC64756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AAMO,IAAM,WAAgC,CAAC,MAAM,OAAO,YAAY;AAAA,EAErE,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,IAEzD,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,MACzD,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK;AAAA,IACxC;AAAA,IACA,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA,EACzC;AAAA,EAEA,IAAI,KAAK,SAAS,YAAY;AAAA,IAE5B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,SAAS,WAAW;AAAA,EAC5D;AAAA,EAEA,IAAI,MAAM,SAAS,YAAY;AAAA,IAE7B,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM,SAAS,WAAW;AAAA,EAC7D;AAAA,EAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,UAAU;AAAA,IACrD,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,QAAQ,MAAM,MAAM;AAAA,EAC5D;AAAA,EAGA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,IAClD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "F9AD84D0B2B9344364756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/comparison/not-equals.cjs

@@ -2,27 +2,37 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).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
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -50,4 +60,4 @@ var notEquals = (left, right, context) => {
   };
 };
 
-//# debugId=A9B57AE1A701EDB164756E2164756E21
+//# debugId=AB54E8B4DAD9E0EC64756E2164756E21

package/dist/cjs/evaluator/comparison/not-equals.cjs.map

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\nimport { equals } from \"./equals.cjs\";\n\n/**\n * Not equals operator (<>) - Returns TRUE if values are not equal\n * Uses the equals operator and negates the result\n */\nexport const notEquals: ArethmeticEvaluator = (left, right, context) => {\n  const equalsResult = equals(left, right, context);\n  \n  if (equalsResult.type === \"error\" || equalsResult.type === \"awaiting-evaluation\") {\n    return equalsResult;\n  }\n  \n  if (equalsResult.type === \"boolean\") {\n    return { type: \"boolean\", value: !equalsResult.value };\n  }\n  \n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: \"Invalid result from equals comparison\",\n    errAddress: context.dependencyNode,\n  };\n};\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACuB,IAAvB;AAMO,IAAM,YAAiC,CAAC,MAAM,OAAO,YAAY;AAAA,EACtE,MAAM,eAAe,qBAAO,MAAM,OAAO,OAAO;AAAA,EAEhD,IAAI,aAAa,SAAS,WAAW,aAAa,SAAS,uBAAuB;AAAA,IAChF,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,aAAa,SAAS,WAAW;AAAA,IACnC,OAAO,EAAE,MAAM,WAAW,OAAO,CAAC,aAAa,MAAM;AAAA,EACvD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
-  "debugId": "A9B57AE1A701EDB164756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACuB,IAAvB;AAMO,IAAM,YAAiC,CAAC,MAAM,OAAO,YAAY;AAAA,EACtE,MAAM,eAAe,qBAAO,MAAM,OAAO,OAAO;AAAA,EAEhD,IAAI,aAAa,SAAS,WAAW,aAAa,SAAS,uBAAuB;AAAA,IAChF,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,aAAa,SAAS,WAAW;AAAA,IACnC,OAAO,EAAE,MAAM,WAAW,OAAO,CAAC,aAAa,MAAM;AAAA,EACvD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "AB54E8B4DAD9E0EC64756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/concatenation/concatenate.cjs

@@ -2,27 +2,37 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).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
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -69,4 +79,4 @@ var concatenate = (left, right, context) => {
   return { type: "string", value: leftStr + rightStr };
 };
 
-//# debugId=4D4ACC1ED63C125264756E2164756E21
+//# debugId=1B4AC84B2404EF2664756E2164756E21

package/dist/cjs/evaluator/concatenation/concatenate.cjs.map

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\n\n/**\n * Concatenation operator (&) - Concatenates two values as strings\n * Works with numbers and strings only\n */\nexport const concatenate: ArethmeticEvaluator = (left, right, context) => {\n  // Convert each value to string based on type\n  let leftStr: string;\n  let rightStr: string;\n\n  // Handle left operand\n  switch (left.type) {\n    case \"string\":\n      leftStr = left.value;\n      break;\n    case \"number\":\n      leftStr = left.value.toString();\n      break;\n    default:\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `Cannot concatenate ${left.type} - only numbers and strings are supported`,\n        errAddress: context.dependencyNode,\n      };\n  }\n\n  // Handle right operand\n  switch (right.type) {\n    case \"string\":\n      rightStr = right.value;\n      break;\n    case \"number\":\n      rightStr = right.value.toString();\n      break;\n    default:\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `Cannot concatenate ${right.type} - only numbers and strings are supported`,\n        errAddress: context.dependencyNode,\n      };\n  }\n\n  return { type: \"string\", value: leftStr + rightStr };\n};\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AAMO,IAAM,cAAmC,CAAC,MAAM,OAAO,YAAY;AAAA,EAExE,IAAI;AAAA,EACJ,IAAI;AAAA,EAGJ,QAAQ,KAAK;AAAA,SACN;AAAA,MACH,UAAU,KAAK;AAAA,MACf;AAAA,SACG;AAAA,MACH,UAAU,KAAK,MAAM,SAAS;AAAA,MAC9B;AAAA;AAAA,MAEA,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS,sBAAsB,KAAK;AAAA,QACpC,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,EAIJ,QAAQ,MAAM;AAAA,SACP;AAAA,MACH,WAAW,MAAM;AAAA,MACjB;AAAA,SACG;AAAA,MACH,WAAW,MAAM,MAAM,SAAS;AAAA,MAChC;AAAA;AAAA,MAEA,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS,sBAAsB,MAAM;AAAA,QACrC,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,EAGJ,OAAO,EAAE,MAAM,UAAU,OAAO,UAAU,SAAS;AAAA;",
-  "debugId": "4D4ACC1ED63C125264756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AAMO,IAAM,cAAmC,CAAC,MAAM,OAAO,YAAY;AAAA,EAExE,IAAI;AAAA,EACJ,IAAI;AAAA,EAGJ,QAAQ,KAAK;AAAA,SACN;AAAA,MACH,UAAU,KAAK;AAAA,MACf;AAAA,SACG;AAAA,MACH,UAAU,KAAK,MAAM,SAAS;AAAA,MAC9B;AAAA;AAAA,MAEA,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS,sBAAsB,KAAK;AAAA,QACpC,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,EAIJ,QAAQ,MAAM;AAAA,SACP;AAAA,MACH,WAAW,MAAM;AAAA,MACjB;AAAA,SACG;AAAA,MACH,WAAW,MAAM,MAAM,SAAS;AAAA,MAChC;AAAA;AAAA,MAEA,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS,sBAAsB,MAAM;AAAA,QACrC,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,EAGJ,OAAO,EAAE,MAAM,UAAU,OAAO,UAAU,SAAS;AAAA;",
+  "debugId": "1B4AC84B2404EF2664756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/dependency-nodes/ast-evaluation-node.cjs

@@ -2,27 +2,37 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).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
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -55,4 +65,4 @@ class AstEvaluationNode extends import_base_eval_node.BaseEvalNode {
   }
 }
 
-//# debugId=1EE9A66B1752F00264756E2164756E21
+//# debugId=763D71D89551D8C664756E2164756E21

package/dist/cjs/evaluator/dependency-nodes/ast-evaluation-node.cjs.map

@@ -4,7 +4,7 @@
   "sourcesContent": [
     "import type { FunctionEvaluationResult } from \"../../core/types.cjs\";\nimport type { ASTNode } from \"../../parser/ast.cjs\";\nimport { astToString } from \"../../parser/formatter.cjs\";\nimport type { ContextDependency } from \"../evaluation-context.cjs\";\nimport { BaseEvalNode } from \"./base-eval-node.cjs\";\n\nexport class AstEvaluationNode extends BaseEvalNode<FunctionEvaluationResult> {\n  private _contextDependency: ContextDependency;\n  constructor(\n    public ast: ASTNode,\n    contextDependency: ContextDependency\n  ) {\n    const key = `ast:${astToString(ast)}`;\n    super(key);\n    this._contextDependency = contextDependency;\n  }\n\n  public override toString(): string {\n    return this.key;\n  }\n\n  getContextDependency() {\n    return this._contextDependency;\n  }\n\n  setContextDependency(contextDependency: ContextDependency) {\n    this._contextDependency = contextDependency;\n  }\n}\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE4B,IAA5B;AAE6B,IAA7B;AAAA;AAEO,MAAM,0BAA0B,mCAAuC;AAAA,EAGnE;AAAA,EAFD;AAAA,EACR,WAAW,CACF,KACP,mBACA;AAAA,IACA,MAAM,MAAM,OAAO,6BAAY,GAAG;AAAA,IAClC,MAAM,GAAG;AAAA,IAJF;AAAA,IAKP,KAAK,qBAAqB;AAAA;AAAA,EAGZ,QAAQ,GAAW;AAAA,IACjC,OAAO,KAAK;AAAA;AAAA,EAGd,oBAAoB,GAAG;AAAA,IACrB,OAAO,KAAK;AAAA;AAAA,EAGd,oBAAoB,CAAC,mBAAsC;AAAA,IACzD,KAAK,qBAAqB;AAAA;AAE9B;",
-  "debugId": "1EE9A66B1752F00264756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE4B,IAA5B;AAE6B,IAA7B;AAAA;AAEO,MAAM,0BAA0B,mCAAuC;AAAA,EAGnE;AAAA,EAFD;AAAA,EACR,WAAW,CACF,KACP,mBACA;AAAA,IACA,MAAM,MAAM,OAAO,6BAAY,GAAG;AAAA,IAClC,MAAM,GAAG;AAAA,IAJF;AAAA,IAKP,KAAK,qBAAqB;AAAA;AAAA,EAGZ,QAAQ,GAAW;AAAA,IACjC,OAAO,KAAK;AAAA;AAAA,EAGd,oBAAoB,GAAG;AAAA,IACrB,OAAO,KAAK;AAAA;AAAA,EAGd,oBAAoB,CAAC,mBAAsC;AAAA,IACzD,KAAK,qBAAqB;AAAA;AAE9B;",
+  "debugId": "763D71D89551D8C664756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/dependency-nodes/base-eval-node.cjs

@@ -2,27 +2,37 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).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
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -73,6 +83,16 @@ class BaseEvalNode {
   setEvaluationResult(result) {
     this._evaluationResult = result;
   }
+  invalidate() {
+    this._dependencies = new Set;
+    this._lastDependencies = new Set;
+    this._resolved = false;
+    this._evaluationResult = {
+      type: "awaiting-evaluation",
+      waitingFor: this,
+      errAddress: this
+    };
+  }
   resetDirectDepsUpdated() {
     if (this._resolved) {
       return;
@@ -83,6 +103,12 @@ class BaseEvalNode {
   getDependencies() {
     return this._dependencies;
   }
+  restoreResolvedSnapshot(options) {
+    this._dependencies = new Set(options.dependencies);
+    this._lastDependencies = new Set(options.dependencies);
+    this._evaluationResult = options.evaluationResult;
+    this._resolved = true;
+  }
   getAllDependencies() {
     return this.getDependencies();
   }
@@ -109,4 +135,4 @@ class BaseEvalNode {
   }
 }
 
-//# debugId=730E16EF65AFBFF564756E2164756E21
+//# debugId=C0536BA95A3B9D2364756E2164756E21