@lotics/cli 0.143.3 → 0.145.0

package/dist/render_page.js

@@ -2451,7 +2451,7 @@
     "../../node_modules/fast-formula-parser/formulas/helpers.js"(exports2, module2) {
       var FormulaError = require_error();
       var Collection = require_collection();
-      var Types = {
+      var Types3 = {
         NUMBER: 0,
         ARRAY: 1,
         BOOLEAN: 2,
@@ -2465,16 +2465,16 @@
       };
       var Factorials = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368e3, 20922789888e3, 355687428096e3, 6402373705728e3, 121645100408832e3, 243290200817664e4, 5109094217170944e4, 11240007277776077e5, 2585201673888498e7, 6204484017332394e8, 15511210043330986e9, 40329146112660565e10, 10888869450418352e12, 30488834461171387e13, 8841761993739702e15, 26525285981219107e16, 8222838654177922e18, 2631308369336935e20, 8683317618811886e21, 29523279903960416e22, 10333147966386145e24, 37199332678990125e25, 13763753091226346e27, 5230226174666011e29, 20397882081197444e30, 8159152832478977e32, 3345252661316381e34, 140500611775288e37, 6041526306337383e37, 2658271574788449e39, 11962222086548019e40, 5502622159812089e42, 25862324151116818e43, 12413915592536073e45, 6082818640342675e47, 30414093201713376e48, 15511187532873822e50, 8065817517094388e52, 42748832840600255e53, 2308436973392414e56, 12696403353658276e57, 7109985878048635e59, 40526919504877214e60, 23505613312828785e62, 13868311854568984e64, 832098711274139e67, 5075802138772248e68, 3146997326038794e70, 198260831540444e73, 12688693218588417e73, 8247650592082472e75, 5443449390774431e77, 3647111091818868e79, 24800355424368305e80, 1711224524281413e83, 11978571669969892e84, 8504785885678623e86, 61234458376886085e87, 44701154615126844e89, 3307885441519386e92, 248091408113954e95, 18854947016660504e95, 14518309202828587e97, 11324281178206297e99, 8946182130782976e101, 7156945704626381e103, 5797126020747368e105, 4753643337012842e107, 3945523969720659e109, 3314240134565353e111, 281710411438055e114, 24227095383672734e114, 2107757298379528e117, 18548264225739844e118, 1650795516090846e121, 14857159644817615e122, 1352001527678403e125, 12438414054641308e126, 11567725070816416e128, 1087366156656743e131, 1032997848823906e133, 9916779348709496e134, 9619275968248212e136, 9426890448883248e138, 9332621544394415e140, 9332621544394415e142];
       var ReversedTypes = {};
-      Object.keys(Types).forEach((key) => {
-        ReversedTypes[Types[key]] = key;
+      Object.keys(Types3).forEach((key) => {
+        ReversedTypes[Types3[key]] = key;
       });
-      var FormulaHelpers = class {
+      var FormulaHelpers3 = class {
         constructor() {
-          this.Types = Types;
+          this.Types = Types3;
           this.type2Number = {
-            number: Types.NUMBER,
-            boolean: Types.BOOLEAN,
-            string: Types.STRING,
+            number: Types3.NUMBER,
+            boolean: Types3.BOOLEAN,
+            string: Types3.STRING,
             object: -1
           };
         }
@@ -2557,7 +2557,7 @@
           if (params.length < minSize)
             throw FormulaError.ARG_MISSING([valueType]);
           if (defValue == null) {
-            defValue = valueType === Types.NUMBER ? 0 : valueType == null ? null : "";
+            defValue = valueType === Types3.NUMBER ? 0 : valueType == null ? null : "";
           }
           params.forEach((param) => {
             const { isCellRef, isRangeRef, isArray: isArray2 } = param;
@@ -2624,7 +2624,7 @@
             return param;
           if (param instanceof FormulaError)
             throw param;
-          if (type === Types.ARRAY) {
+          if (type === Types3.ARRAY) {
             if (Array.isArray(param)) {
               return flat ? this.flattenDeep(param) : param;
             } else if (param instanceof Collection) {
@@ -2633,26 +2633,26 @@
               return flat ? [param] : [[param]];
             }
             throw FormulaError.VALUE;
-          } else if (type === Types.COLLECTIONS) {
+          } else if (type === Types3.COLLECTIONS) {
             return param;
           }
           if (isArray2) {
             param = param[0][0];
           }
           const paramType = this.type(param);
-          if (type === Types.STRING) {
-            if (paramType === Types.BOOLEAN)
+          if (type === Types3.STRING) {
+            if (paramType === Types3.BOOLEAN)
               param = param ? "TRUE" : "FALSE";
             else
               param = `${param}`;
-          } else if (type === Types.BOOLEAN) {
-            if (paramType === Types.STRING)
+          } else if (type === Types3.BOOLEAN) {
+            if (paramType === Types3.STRING)
               throw FormulaError.VALUE;
-            if (paramType === Types.NUMBER)
+            if (paramType === Types3.NUMBER)
               param = Boolean(param);
-          } else if (type === Types.NUMBER) {
+          } else if (type === Types3.NUMBER) {
             param = this.acceptNumber(param, false);
-          } else if (type === Types.NUMBER_NO_BOOLEAN) {
+          } else if (type === Types3.NUMBER_NO_BOOLEAN) {
             param = this.acceptNumber(param, false, false);
           } else {
             throw FormulaError.VALUE;
@@ -2663,15 +2663,15 @@
           let type = this.type2Number[typeof variable];
           if (type === -1) {
             if (Array.isArray(variable))
-              type = Types.ARRAY;
+              type = Types3.ARRAY;
             else if (variable.ref) {
               if (variable.ref.from) {
-                type = Types.RANGE_REF;
+                type = Types3.RANGE_REF;
               } else {
-                type = Types.CELL_REF;
+                type = Types3.CELL_REF;
               }
             } else if (variable instanceof Collection)
-              type = Types.COLLECTIONS;
+              type = Types3.COLLECTIONS;
           }
           return type;
         }
@@ -2690,10 +2690,10 @@
         retrieveRanges(context, range1, range2) {
           range2 = Address.extend(range1, range2);
           range1 = this.retrieveArg(context, range1);
-          range1 = H.accept(range1, Types.ARRAY, void 0, false, true);
+          range1 = H.accept(range1, Types3.ARRAY, void 0, false, true);
           if (range2 !== range1) {
             range2 = this.retrieveArg(context, range2);
-            range2 = H.accept(range2, Types.ARRAY, void 0, false, true);
+            range2 = H.accept(range2, Types3.ARRAY, void 0, false, true);
           } else
             range2 = range1;
           return [range1, range2];
@@ -2705,7 +2705,7 @@
           return { value: res.val, isArray: res.isArray, ref: arg.ref };
         }
       };
-      var H = new FormulaHelpers();
+      var H = new FormulaHelpers3();
       var WildCard = {
         /**
          * @param {string|*} obj
@@ -2822,7 +2822,7 @@
       };
       module2.exports = {
         FormulaHelpers: H,
-        Types,
+        Types: Types3,
         ReversedTypes,
         Factorials,
         WildCard,
@@ -2895,8 +2895,8 @@
         return new FormulaError("#N/A", `Function ${functionName} has too many arguments.`);
       };
       FormulaError.ARG_MISSING = (args) => {
-        const { Types } = require_helpers();
-        return new FormulaError("#N/A", `Argument type ${args.map((arg) => Types[arg]).join(", ")} is missing.`);
+        const { Types: Types3 } = require_helpers();
+        return new FormulaError("#N/A", `Argument type ${args.map((arg) => Types3[arg]).join(", ")} is missing.`);
       };
       FormulaError.ERROR = (msg, details) => {
         return new FormulaError("#ERROR!", msg, details);
@@ -4246,8 +4246,8 @@
   var require_text = __commonJS({
     "../../node_modules/fast-formula-parser/formulas/functions/text.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers, Types, WildCard } = require_helpers();
-      var H = FormulaHelpers;
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3, WildCard } = require_helpers();
+      var H = FormulaHelpers3;
       var ssf = require_ssf();
       var bahttext = require_src();
       var charsets = {
@@ -4273,11 +4273,11 @@
       var toHalfWidth = (str0) => sets.reduce((str, set) => str.replace(re(set, "full"), toHalf(set)), str0);
       var TextFunctions = {
         ASC: (text) => {
-          text = H.accept(text, Types.STRING);
+          text = H.accept(text, Types3.STRING);
           return toHalfWidth(text);
         },
         BAHTTEXT: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           try {
             return bahttext(number);
           } catch (e) {
@@ -4286,25 +4286,25 @@ ${e.toString()}`);
           }
         },
         CHAR: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (number > 255 || number < 1)
             throw FormulaError.VALUE;
           return String.fromCharCode(number);
         },
         CLEAN: (text) => {
-          text = H.accept(text, Types.STRING);
+          text = H.accept(text, Types3.STRING);
           return text.replace(/[\x00-\x1F]/g, "");
         },
         CODE: (text) => {
-          text = H.accept(text, Types.STRING);
+          text = H.accept(text, Types3.STRING);
           if (text.length === 0)
             throw FormulaError.VALUE;
           return text.charCodeAt(0);
         },
         CONCAT: (...params) => {
           let text = "";
-          H.flattenParams(params, Types.STRING, false, (item) => {
-            item = H.accept(item, Types.STRING);
+          H.flattenParams(params, Types3.STRING, false, (item) => {
+            item = H.accept(item, Types3.STRING);
             text += item;
           });
           return text;
@@ -4314,30 +4314,30 @@ ${e.toString()}`);
           if (params.length === 0)
             throw Error("CONCATENATE need at least one argument.");
           params.forEach((param) => {
-            param = H.accept(param, Types.STRING);
+            param = H.accept(param, Types3.STRING);
             text += param;
           });
           return text;
         },
         DBCS: (text) => {
-          text = H.accept(text, Types.STRING);
+          text = H.accept(text, Types3.STRING);
           return toFullWidth(text);
         },
         DOLLAR: (number, decimals) => {
-          number = H.accept(number, Types.NUMBER);
-          decimals = H.accept(decimals, Types.NUMBER, 2);
+          number = H.accept(number, Types3.NUMBER);
+          decimals = H.accept(decimals, Types3.NUMBER, 2);
           const decimalString = Array(decimals).fill("0").join("");
           return ssf.format(`$#,##0.${decimalString}_);($#,##0.${decimalString})`, number).trim();
         },
         EXACT: (text1, text2) => {
-          text1 = H.accept(text1, [Types.STRING]);
-          text2 = H.accept(text2, [Types.STRING]);
+          text1 = H.accept(text1, [Types3.STRING]);
+          text2 = H.accept(text2, [Types3.STRING]);
           return text1 === text2;
         },
         FIND: (findText, withinText, startNum) => {
-          findText = H.accept(findText, Types.STRING);
-          withinText = H.accept(withinText, Types.STRING);
-          startNum = H.accept(startNum, Types.NUMBER, 1);
+          findText = H.accept(findText, Types3.STRING);
+          withinText = H.accept(withinText, Types3.STRING);
+          startNum = H.accept(startNum, Types3.NUMBER, 1);
           if (startNum < 1 || startNum > withinText.length)
             throw FormulaError.VALUE;
           const res = withinText.indexOf(findText, startNum - 1);
@@ -4349,16 +4349,16 @@ ${e.toString()}`);
           return TextFunctions.FIND(...params);
         },
         FIXED: (number, decimals, noCommas) => {
-          number = H.accept(number, Types.NUMBER);
-          decimals = H.accept(decimals, Types.NUMBER, 2);
-          noCommas = H.accept(noCommas, Types.BOOLEAN, false);
+          number = H.accept(number, Types3.NUMBER);
+          decimals = H.accept(decimals, Types3.NUMBER, 2);
+          noCommas = H.accept(noCommas, Types3.BOOLEAN, false);
           const decimalString = Array(decimals).fill("0").join("");
           const comma = noCommas ? "" : "#,";
           return ssf.format(`${comma}##0.${decimalString}_);(${comma}##0.${decimalString})`, number).trim();
         },
         LEFT: (text, numChars) => {
-          text = H.accept(text, Types.STRING);
-          numChars = H.accept(numChars, Types.NUMBER, 1);
+          text = H.accept(text, Types3.STRING);
+          numChars = H.accept(numChars, Types3.NUMBER, 1);
           if (numChars < 0)
             throw FormulaError.VALUE;
           if (numChars > text.length)
@@ -4369,20 +4369,20 @@ ${e.toString()}`);
           return TextFunctions.LEFT(...params);
         },
         LEN: (text) => {
-          text = H.accept(text, Types.STRING);
+          text = H.accept(text, Types3.STRING);
           return text.length;
         },
         LENB: (...params) => {
           return TextFunctions.LEN(...params);
         },
         LOWER: (text) => {
-          text = H.accept(text, Types.STRING);
+          text = H.accept(text, Types3.STRING);
           return text.toLowerCase();
         },
         MID: (text, startNum, numChars) => {
-          text = H.accept(text, Types.STRING);
-          startNum = H.accept(startNum, Types.NUMBER);
-          numChars = H.accept(numChars, Types.NUMBER);
+          text = H.accept(text, Types3.STRING);
+          startNum = H.accept(startNum, Types3.NUMBER);
+          numChars = H.accept(numChars, Types3.NUMBER);
           if (startNum > text.length)
             return "";
           if (startNum < 1 || numChars < 1)
@@ -4393,9 +4393,9 @@ ${e.toString()}`);
           return TextFunctions.MID(...params);
         },
         NUMBERVALUE: (text, decimalSeparator, groupSeparator) => {
-          text = H.accept(text, Types.STRING);
-          decimalSeparator = H.accept(decimalSeparator, Types.STRING, ".");
-          groupSeparator = H.accept(groupSeparator, Types.STRING, ",");
+          text = H.accept(text, Types3.STRING);
+          decimalSeparator = H.accept(decimalSeparator, Types3.STRING, ".");
+          groupSeparator = H.accept(groupSeparator, Types3.STRING, ",");
           if (text.length === 0)
             return 0;
           if (decimalSeparator.length === 0 || groupSeparator.length === 0)
@@ -4417,7 +4417,7 @@ ${e.toString()}`);
         PHONETIC: () => {
         },
         PROPER: (text) => {
-          text = H.accept(text, [Types.STRING]);
+          text = H.accept(text, [Types3.STRING]);
           text = text.toLowerCase();
           text = text.charAt(0).toUpperCase() + text.slice(1);
           return text.replace(
@@ -4426,10 +4426,10 @@ ${e.toString()}`);
           );
         },
         REPLACE: (old_text, start_num, num_chars, new_text) => {
-          old_text = H.accept(old_text, [Types.STRING]);
-          start_num = H.accept(start_num, [Types.NUMBER]);
-          num_chars = H.accept(num_chars, [Types.NUMBER]);
-          new_text = H.accept(new_text, [Types.STRING]);
+          old_text = H.accept(old_text, [Types3.STRING]);
+          start_num = H.accept(start_num, [Types3.NUMBER]);
+          num_chars = H.accept(num_chars, [Types3.NUMBER]);
+          new_text = H.accept(new_text, [Types3.STRING]);
           let arr = old_text.split("");
           arr.splice(start_num - 1, num_chars, new_text);
           return arr.join("");
@@ -4438,8 +4438,8 @@ ${e.toString()}`);
           return TextFunctions.REPLACE(...params);
         },
         REPT: (text, number_times) => {
-          text = H.accept(text, Types.STRING);
-          number_times = H.accept(number_times, Types.NUMBER);
+          text = H.accept(text, Types3.STRING);
+          number_times = H.accept(number_times, Types3.NUMBER);
           let str = "";
           for (let i3 = 0; i3 < number_times; i3++) {
             str += text;
@@ -4447,8 +4447,8 @@ ${e.toString()}`);
           return str;
         },
         RIGHT: (text, numChars) => {
-          text = H.accept(text, Types.STRING);
-          numChars = H.accept(numChars, Types.NUMBER, 1);
+          text = H.accept(text, Types3.STRING);
+          numChars = H.accept(numChars, Types3.NUMBER, 1);
           if (numChars < 0)
             throw FormulaError.VALUE;
           const len = text.length;
@@ -4460,9 +4460,9 @@ ${e.toString()}`);
           return TextFunctions.RIGHT(...params);
         },
         SEARCH: (findText, withinText, startNum) => {
-          findText = H.accept(findText, Types.STRING);
-          withinText = H.accept(withinText, Types.STRING);
-          startNum = H.accept(startNum, Types.NUMBER, 1);
+          findText = H.accept(findText, Types3.STRING);
+          withinText = H.accept(withinText, Types3.STRING);
+          startNum = H.accept(startNum, Types3.NUMBER, 1);
           if (startNum < 1 || startNum > withinText.length)
             throw FormulaError.VALUE;
           let findTextRegex = WildCard.isWildCard(findText) ? WildCard.toRegex(findText, "i") : findText;
@@ -4483,8 +4483,8 @@ ${e.toString()}`);
           return "";
         },
         TEXT: (value2, formatText) => {
-          value2 = H.accept(value2, Types.NUMBER);
-          formatText = H.accept(formatText, Types.STRING);
+          value2 = H.accept(value2, Types3.NUMBER);
+          formatText = H.accept(formatText, Types3.STRING);
           try {
             return ssf.format(formatText, value2);
           } catch (e) {
@@ -4495,11 +4495,11 @@ ${e.toString()}`);
         TEXTJOIN: (...params) => {
         },
         TRIM: (text) => {
-          text = H.accept(text, [Types.STRING]);
+          text = H.accept(text, [Types3.STRING]);
           return text.replace(/^\s+|\s+$/g, "");
         },
         UNICHAR: (number) => {
-          number = H.accept(number, [Types.NUMBER]);
+          number = H.accept(number, [Types3.NUMBER]);
           if (number <= 0)
             throw FormulaError.VALUE;
           return String.fromCharCode(number);
@@ -4516,7 +4516,7 @@ ${e.toString()}`);
   var require_operators = __commonJS({
     "../../node_modules/fast-formula-parser/formulas/operators.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers } = require_helpers();
+      var { FormulaHelpers: FormulaHelpers3 } = require_helpers();
       var Prefix = {
         unaryOp: (prefixes, value2, isArray2) => {
           let sign = 1;
@@ -4535,7 +4535,7 @@ ${e.toString()}`);
             return value2;
           }
           try {
-            value2 = FormulaHelpers.acceptNumber(value2, isArray2);
+            value2 = FormulaHelpers3.acceptNumber(value2, isArray2);
           } catch (e) {
             if (e instanceof FormulaError) {
               if (Array.isArray(value2))
@@ -4550,7 +4550,7 @@ ${e.toString()}`);
       var Postfix = {
         percentOp: (value2, postfix, isArray2) => {
           try {
-            value2 = FormulaHelpers.acceptNumber(value2, isArray2);
+            value2 = FormulaHelpers3.acceptNumber(value2, isArray2);
           } catch (e) {
             if (e instanceof FormulaError)
               return e;
@@ -4627,8 +4627,8 @@ ${e.toString()}`);
           if (value1 == null) value1 = 0;
           if (value2 == null) value2 = 0;
           try {
-            value1 = FormulaHelpers.acceptNumber(value1, isArray1);
-            value2 = FormulaHelpers.acceptNumber(value2, isArray2);
+            value1 = FormulaHelpers3.acceptNumber(value1, isArray1);
+            value2 = FormulaHelpers3.acceptNumber(value2, isArray2);
           } catch (e) {
             if (e instanceof FormulaError)
               return e;
@@ -4668,9 +4668,9 @@ ${e.toString()}`);
   var require_math = __commonJS({
     "../../node_modules/fast-formula-parser/formulas/functions/math.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers, Types, Factorials, Criteria } = require_helpers();
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3, Factorials, Criteria } = require_helpers();
       var { Infix: Infix2 } = require_operators();
-      var H = FormulaHelpers;
+      var H = FormulaHelpers3;
       var f = [];
       var fd2 = [];
       function factorial(n) {
@@ -4691,13 +4691,13 @@ ${e.toString()}`);
       }
       var MathFunctions = {
         ABS: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.abs(number);
         },
         AGGREGATE: (functionNum, options, ref1, ...refs) => {
         },
         ARABIC: (text) => {
-          text = H.accept(text, Types.STRING).toUpperCase();
+          text = H.accept(text, Types3.STRING).toUpperCase();
           if (!/^M*(?:D?C{0,3}|C[MD])(?:L?X{0,3}|X[CL])(?:V?I{0,3}|I[XV])$/.test(text)) {
             throw new FormulaError("#VALUE!", "Invalid roman numeral in ARABIC evaluation.");
           }
@@ -4722,13 +4722,13 @@ ${e.toString()}`);
           return r;
         },
         BASE: (number, radix, minLength) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (number < 0 || number >= 2 ** 53)
             throw FormulaError.NUM;
-          radix = H.accept(radix, Types.NUMBER);
+          radix = H.accept(radix, Types3.NUMBER);
           if (radix < 2 || radix > 36)
             throw FormulaError.NUM;
-          minLength = H.accept(minLength, Types.NUMBER, 0);
+          minLength = H.accept(minLength, Types3.NUMBER, 0);
           if (minLength < 0) {
             throw FormulaError.NUM;
           }
@@ -4736,8 +4736,8 @@ ${e.toString()}`);
           return new Array(Math.max(minLength + 1 - result.length, 0)).join("0") + result;
         },
         CEILING: (number, significance) => {
-          number = H.accept(number, Types.NUMBER);
-          significance = H.accept(significance, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          significance = H.accept(significance, Types3.NUMBER);
           if (significance === 0)
             return 0;
           if (number / significance % 1 === 0)
@@ -4752,9 +4752,9 @@ ${e.toString()}`);
           }
         },
         "CEILING.MATH": (number, significance, mode) => {
-          number = H.accept(number, Types.NUMBER);
-          significance = H.accept(significance, Types.NUMBER, number > 0 ? 1 : -1);
-          mode = H.accept(mode, Types.NUMBER, 0);
+          number = H.accept(number, Types3.NUMBER);
+          significance = H.accept(significance, Types3.NUMBER, number > 0 ? 1 : -1);
+          mode = H.accept(mode, Types3.NUMBER, 0);
           if (number >= 0) {
             return MathFunctions.CEILING(number, significance);
           }
@@ -4762,21 +4762,21 @@ ${e.toString()}`);
           return MathFunctions.CEILING(number, significance) - offset;
         },
         "CEILING.PRECISE": (number, significance) => {
-          number = H.accept(number, Types.NUMBER);
-          significance = H.accept(significance, Types.NUMBER, 1);
+          number = H.accept(number, Types3.NUMBER);
+          significance = H.accept(significance, Types3.NUMBER, 1);
           return MathFunctions.CEILING(number, Math.abs(significance));
         },
         COMBIN: (number, numberChosen) => {
-          number = H.accept(number, Types.NUMBER);
-          numberChosen = H.accept(numberChosen, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          numberChosen = H.accept(numberChosen, Types3.NUMBER);
           if (number < 0 || numberChosen < 0 || number < numberChosen)
             throw FormulaError.NUM;
           const nFactorial = MathFunctions.FACT(number), kFactorial = MathFunctions.FACT(numberChosen);
           return nFactorial / kFactorial / MathFunctions.FACT(number - numberChosen);
         },
         COMBINA: (number, numberChosen) => {
-          number = H.accept(number, Types.NUMBER);
-          numberChosen = H.accept(numberChosen, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          numberChosen = H.accept(numberChosen, Types3.NUMBER);
           if ((number === 0 || number === 1) && numberChosen === 0)
             return 1;
           if (number < 0 || numberChosen < 0)
@@ -4784,8 +4784,8 @@ ${e.toString()}`);
           return MathFunctions.COMBIN(number + numberChosen - 1, number - 1);
         },
         DECIMAL: (text, radix) => {
-          text = H.accept(text, Types.STRING);
-          radix = H.accept(radix, Types.NUMBER);
+          text = H.accept(text, Types3.STRING);
+          radix = H.accept(radix, Types3.NUMBER);
           radix = Math.trunc(radix);
           if (radix < 2 || radix > 36)
             throw FormulaError.NUM;
@@ -4795,18 +4795,18 @@ ${e.toString()}`);
           return res;
         },
         DEGREES: (radians) => {
-          radians = H.accept(radians, Types.NUMBER);
+          radians = H.accept(radians, Types3.NUMBER);
           return radians * (180 / Math.PI);
         },
         EVEN: (number) => {
           return MathFunctions.CEILING(number, -2);
         },
         EXP: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.exp(number);
         },
         FACT: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           number = Math.trunc(number);
           if (number > 170 || number < 0)
             throw FormulaError.NUM;
@@ -4815,7 +4815,7 @@ ${e.toString()}`);
           return factorial(number);
         },
         FACTDOUBLE: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           number = Math.trunc(number);
           if (number < -1)
             throw FormulaError.NUM;
@@ -4824,8 +4824,8 @@ ${e.toString()}`);
           return factorialDouble(number);
         },
         FLOOR: (number, significance) => {
-          number = H.accept(number, Types.NUMBER);
-          significance = H.accept(significance, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          significance = H.accept(significance, Types3.NUMBER);
           if (significance === 0)
             return 0;
           if (number > 0 && significance < 0)
@@ -4842,17 +4842,17 @@ ${e.toString()}`);
           }
         },
         "FLOOR.MATH": (number, significance, mode) => {
-          number = H.accept(number, Types.NUMBER);
-          significance = H.accept(significance, Types.NUMBER, number > 0 ? 1 : -1);
-          mode = H.accept(mode, Types.NUMBER, 0);
+          number = H.accept(number, Types3.NUMBER);
+          significance = H.accept(significance, Types3.NUMBER, number > 0 ? 1 : -1);
+          mode = H.accept(mode, Types3.NUMBER, 0);
           if (mode === 0 || number >= 0) {
             return MathFunctions.FLOOR(number, Math.abs(significance));
           }
           return MathFunctions.FLOOR(number, significance) + significance;
         },
         "FLOOR.PRECISE": (number, significance) => {
-          number = H.accept(number, Types.NUMBER);
-          significance = H.accept(significance, Types.NUMBER, 1);
+          number = H.accept(number, Types3.NUMBER);
+          significance = H.accept(significance, Types3.NUMBER, 1);
           return MathFunctions.FLOOR(number, Math.abs(significance));
         },
         GCD: (...params) => {
@@ -4883,7 +4883,7 @@ ${e.toString()}`);
           return x2;
         },
         INT: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.floor(number);
         },
         "ISO.CEILING": (...params) => {
@@ -4917,20 +4917,20 @@ ${e.toString()}`);
           return a;
         },
         LN: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.log(number);
         },
         LOG: (number, base2) => {
-          number = H.accept(number, Types.NUMBER);
-          base2 = H.accept(base2, Types.NUMBER, 10);
+          number = H.accept(number, Types3.NUMBER);
+          base2 = H.accept(base2, Types3.NUMBER, 10);
           return Math.log(number) / Math.log(base2);
         },
         LOG10: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.log10(number);
         },
         MDETERM: (array) => {
-          array = H.accept(array, Types.ARRAY, void 0, false, true);
+          array = H.accept(array, Types3.ARRAY, void 0, false, true);
           if (array[0].length !== array.length)
             throw FormulaError.VALUE;
           const numRow = array.length, numCol = array[0].length;
@@ -4954,8 +4954,8 @@ ${e.toString()}`);
         MINVERSE: (array) => {
         },
         MMULT: (array1, array2) => {
-          array1 = H.accept(array1, Types.ARRAY, void 0, false, true);
-          array2 = H.accept(array2, Types.ARRAY, void 0, false, true);
+          array1 = H.accept(array1, Types3.ARRAY, void 0, false, true);
+          array2 = H.accept(array2, Types3.ARRAY, void 0, false, true);
           const aNumRows = array1.length, aNumCols = array1[0].length, bNumRows = array2.length, bNumCols = array2[0].length, m = new Array(aNumRows);
           if (aNumCols !== bNumRows)
             throw FormulaError.VALUE;
@@ -4973,15 +4973,15 @@ ${e.toString()}`);
           return m;
         },
         MOD: (number, divisor) => {
-          number = H.accept(number, Types.NUMBER);
-          divisor = H.accept(divisor, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          divisor = H.accept(divisor, Types3.NUMBER);
           if (divisor === 0)
             throw FormulaError.DIV0;
           return number - divisor * MathFunctions.INT(number / divisor);
         },
         MROUND: (number, multiple) => {
-          number = H.accept(number, Types.NUMBER);
-          multiple = H.accept(multiple, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          multiple = H.accept(multiple, Types3.NUMBER);
           if (multiple === 0)
             return 0;
           if (number > 0 && multiple < 0 || number < 0 && multiple > 0)
@@ -4992,7 +4992,7 @@ ${e.toString()}`);
         },
         MULTINOMIAL: (...numbers2) => {
           let numerator = 0, denominator = 1;
-          H.flattenParams(numbers2, Types.NUMBER, false, (number) => {
+          H.flattenParams(numbers2, Types3.NUMBER, false, (number) => {
             if (number < 0)
               throw FormulaError.NUM;
             numerator += number;
@@ -5001,7 +5001,7 @@ ${e.toString()}`);
           return factorial(numerator) / denominator;
         },
         MUNIT: (dimension) => {
-          dimension = H.accept(dimension, Types.NUMBER);
+          dimension = H.accept(dimension, Types3.NUMBER);
           const matrix = [];
           for (let row = 0; row < dimension; row++) {
             const rowArr = [];
@@ -5016,7 +5016,7 @@ ${e.toString()}`);
           return matrix;
         },
         ODD: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (number === 0)
             return 1;
           let temp = Math.ceil(Math.abs(number));
@@ -5027,8 +5027,8 @@ ${e.toString()}`);
           return Math.PI;
         },
         POWER: (number, power) => {
-          number = H.accept(number, Types.NUMBER);
-          power = H.accept(power, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          power = H.accept(power, Types3.NUMBER);
           return number ** power;
         },
         PRODUCT: (...numbers2) => {
@@ -5045,25 +5045,25 @@ ${e.toString()}`);
           return product;
         },
         QUOTIENT: (numerator, denominator) => {
-          numerator = H.accept(numerator, Types.NUMBER);
-          denominator = H.accept(denominator, Types.NUMBER);
+          numerator = H.accept(numerator, Types3.NUMBER);
+          denominator = H.accept(denominator, Types3.NUMBER);
           return Math.trunc(numerator / denominator);
         },
         RADIANS: (degrees) => {
-          degrees = H.accept(degrees, Types.NUMBER);
+          degrees = H.accept(degrees, Types3.NUMBER);
           return degrees / 180 * Math.PI;
         },
         RAND: () => {
           return Math.random();
         },
         RANDBETWEEN: (bottom, top) => {
-          bottom = H.accept(bottom, Types.NUMBER);
-          top = H.accept(top, Types.NUMBER);
+          bottom = H.accept(bottom, Types3.NUMBER);
+          top = H.accept(top, Types3.NUMBER);
           return Math.floor(Math.random() * (top - bottom + 1) + bottom);
         },
         ROMAN: (number, form) => {
-          number = H.accept(number, Types.NUMBER);
-          form = H.accept(form, Types.NUMBER, 0);
+          number = H.accept(number, Types3.NUMBER);
+          form = H.accept(form, Types3.NUMBER, 0);
           if (form !== 0)
             throw Error("ROMAN: only allows form=0 (classic form).");
           const digits = String(number).split("");
@@ -5075,8 +5075,8 @@ ${e.toString()}`);
           return new Array(+digits.join("") + 1).join("M") + roman;
         },
         ROUND: (number, digits) => {
-          number = H.accept(number, Types.NUMBER);
-          digits = H.accept(digits, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          digits = H.accept(digits, Types3.NUMBER);
           const multiplier = Math.pow(10, Math.abs(digits));
           const sign = number > 0 ? 1 : -1;
           if (digits > 0) {
@@ -5088,8 +5088,8 @@ ${e.toString()}`);
           }
         },
         ROUNDDOWN: (number, digits) => {
-          number = H.accept(number, Types.NUMBER);
-          digits = H.accept(digits, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          digits = H.accept(digits, Types3.NUMBER);
           const multiplier = Math.pow(10, Math.abs(digits));
           const sign = number > 0 ? 1 : -1;
           if (digits > 0) {
@@ -5104,8 +5104,8 @@ ${e.toString()}`);
           }
         },
         ROUNDUP: (number, digits) => {
-          number = H.accept(number, Types.NUMBER);
-          digits = H.accept(digits, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          digits = H.accept(digits, Types3.NUMBER);
           const multiplier = Math.pow(10, Math.abs(digits));
           const sign = number > 0 ? 1 : -1;
           if (digits > 0) {
@@ -5120,11 +5120,11 @@ ${e.toString()}`);
           }
         },
         SERIESSUM: (x2, n, m, coefficients) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          n = H.accept(n, Types.NUMBER);
-          m = H.accept(m, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
+          n = H.accept(n, Types3.NUMBER);
+          m = H.accept(m, Types3.NUMBER);
           let i3 = 0, result;
-          H.flattenParams([coefficients], Types.NUMBER, false, (coefficient) => {
+          H.flattenParams([coefficients], Types3.NUMBER, false, (coefficient) => {
             if (typeof coefficient !== "number") {
               throw FormulaError.VALUE;
             }
@@ -5138,17 +5138,17 @@ ${e.toString()}`);
           return result;
         },
         SIGN: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return number > 0 ? 1 : number === 0 ? 0 : -1;
         },
         SQRT: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (number < 0)
             throw FormulaError.NUM;
           return Math.sqrt(number);
         },
         SQRTPI: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (number < 0)
             throw FormulaError.NUM;
           return Math.sqrt(number * Math.PI);
@@ -5159,7 +5159,7 @@ ${e.toString()}`);
           let result = 0;
           H.flattenParams(
             params,
-            Types.NUMBER,
+            Types3.NUMBER,
             true,
             (item, info) => {
               if (info.isLiteral) {
@@ -5202,9 +5202,9 @@ ${e.toString()}`);
         SUMIFS: () => {
         },
         SUMPRODUCT: (array1, ...arrays) => {
-          array1 = H.accept(array1, Types.ARRAY, void 0, false, true);
+          array1 = H.accept(array1, Types3.ARRAY, void 0, false, true);
           arrays.forEach((array) => {
-            array = H.accept(array, Types.ARRAY, void 0, false, true);
+            array = H.accept(array, Types3.ARRAY, void 0, false, true);
             if (array1[0].length !== array[0].length || array1.length !== array.length)
               throw FormulaError.VALUE;
             for (let i3 = 0; i3 < array1.length; i3++) {
@@ -5229,7 +5229,7 @@ ${e.toString()}`);
           let result = 0;
           H.flattenParams(
             params,
-            Types.NUMBER,
+            Types3.NUMBER,
             true,
             (item, info) => {
               if (info.isLiteral) {
@@ -5294,7 +5294,7 @@ ${e.toString()}`);
           return sum;
         },
         TRUNC: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.trunc(number);
         }
       };
@@ -5306,71 +5306,71 @@ ${e.toString()}`);
   var require_trigonometry = __commonJS({
     "../../node_modules/fast-formula-parser/formulas/functions/trigonometry.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers, Types } = require_helpers();
-      var H = FormulaHelpers;
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3 } = require_helpers();
+      var H = FormulaHelpers3;
       var MAX_NUMBER = 2 ** 27 - 1;
       var TrigFunctions = {
         ACOS: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (number > 1 || number < -1)
             throw FormulaError.NUM;
           return Math.acos(number);
         },
         ACOSH: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (number < 1)
             throw FormulaError.NUM;
           return Math.acosh(number);
         },
         ACOT: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.PI / 2 - Math.atan(number);
         },
         ACOTH: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (Math.abs(number) <= 1)
             throw FormulaError.NUM;
           return Math.atanh(1 / number);
         },
         ASIN: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (number > 1 || number < -1)
             throw FormulaError.NUM;
           return Math.asin(number);
         },
         ASINH: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.asinh(number);
         },
         ATAN: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.atan(number);
         },
         ATAN2: (x2, y) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          y = H.accept(y, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
+          y = H.accept(y, Types3.NUMBER);
           if (y === 0 && x2 === 0)
             throw FormulaError.DIV0;
           return Math.atan2(y, x2);
         },
         ATANH: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (Math.abs(number) > 1)
             throw FormulaError.NUM;
           return Math.atanh(number);
         },
         COS: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (Math.abs(number) > MAX_NUMBER)
             throw FormulaError.NUM;
           return Math.cos(number);
         },
         COSH: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.cosh(number);
         },
         COT: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (Math.abs(number) > MAX_NUMBER)
             throw FormulaError.NUM;
           if (number === 0)
@@ -5378,51 +5378,51 @@ ${e.toString()}`);
           return 1 / Math.tan(number);
         },
         COTH: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (number === 0)
             throw FormulaError.DIV0;
           return 1 / Math.tanh(number);
         },
         CSC: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (Math.abs(number) > MAX_NUMBER)
             throw FormulaError.NUM;
           return 1 / Math.sin(number);
         },
         CSCH: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (number === 0)
             throw FormulaError.DIV0;
           return 1 / Math.sinh(number);
         },
         SEC: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (Math.abs(number) > MAX_NUMBER)
             throw FormulaError.NUM;
           return 1 / Math.cos(number);
         },
         SECH: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return 1 / Math.cosh(number);
         },
         SIN: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (Math.abs(number) > MAX_NUMBER)
             throw FormulaError.NUM;
           return Math.sin(number);
         },
         SINH: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.sinh(number);
         },
         TAN: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           if (Math.abs(number) > MAX_NUMBER)
             throw FormulaError.NUM;
           return Math.tan(number);
         },
         TANH: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           return Math.tanh(number);
         }
       };
@@ -5434,8 +5434,8 @@ ${e.toString()}`);
   var require_logical = __commonJS({
     "../../node_modules/fast-formula-parser/formulas/functions/logical.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers, Types } = require_helpers();
-      var H = FormulaHelpers;
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3 } = require_helpers();
+      var H = FormulaHelpers3;
       function getNumLogicalValue(params) {
         let numTrue = 0, numFalse = 0;
         H.flattenParams(params, null, true, (val) => {
@@ -5468,7 +5468,7 @@ ${e.toString()}`);
         },
         // Special
         IF: (context, logicalTest, valueIfTrue, valueIfFalse) => {
-          logicalTest = H.accept(logicalTest, Types.BOOLEAN);
+          logicalTest = H.accept(logicalTest, Types3.BOOLEAN);
           valueIfTrue = H.accept(valueIfTrue);
           valueIfFalse = H.accept(valueIfFalse, null, false);
           return logicalTest ? valueIfTrue : valueIfFalse;
@@ -5485,7 +5485,7 @@ ${e.toString()}`);
           if (params.length % 2 !== 0)
             return new FormulaError("#N/A", "IFS expects all arguments after position 0 to be in pairs.");
           for (let i3 = 0; i3 < params.length / 2; i3++) {
-            const logicalTest = H.accept(params[i3 * 2], Types.BOOLEAN);
+            const logicalTest = H.accept(params[i3 * 2], Types3.BOOLEAN);
             const valueIfTrue = H.accept(params[i3 * 2 + 1]);
             if (logicalTest)
               return valueIfTrue;
@@ -5493,7 +5493,7 @@ ${e.toString()}`);
           return FormulaError.NA;
         },
         NOT: (logical) => {
-          logical = H.accept(logical, Types.BOOLEAN);
+          logical = H.accept(logical, Types3.BOOLEAN);
           return !logical;
         },
         OR: (...params) => {
@@ -9603,8 +9603,8 @@ ${e.toString()}`);
     "../../node_modules/fast-formula-parser/formulas/functions/engineering.js"(exports2, module2) {
       var FormulaError = require_error();
       var TextFunctions = require_text();
-      var { FormulaHelpers, Types } = require_helpers();
-      var H = FormulaHelpers;
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3 } = require_helpers();
+      var H = FormulaHelpers3;
       var bessel2 = require_bessel();
       var jStat2 = require_jstat();
       var MAX_OCT = 536870911;
@@ -9643,8 +9643,8 @@ ${e.toString()}`);
       }
       var EngineeringFunctions = {
         BESSELI: (x2, n) => {
-          x2 = H.accept(x2, Types.NUMBER_NO_BOOLEAN);
-          n = H.accept(n, Types.NUMBER_NO_BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER_NO_BOOLEAN);
+          n = H.accept(n, Types3.NUMBER_NO_BOOLEAN);
           n = Math.trunc(n);
           if (n < 0) {
             throw FormulaError.NUM;
@@ -9652,8 +9652,8 @@ ${e.toString()}`);
           return bessel2.besseli(x2, n);
         },
         BESSELJ: (x2, n) => {
-          x2 = H.accept(x2, Types.NUMBER_NO_BOOLEAN);
-          n = H.accept(n, Types.NUMBER_NO_BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER_NO_BOOLEAN);
+          n = H.accept(n, Types3.NUMBER_NO_BOOLEAN);
           n = Math.trunc(n);
           if (n < 0) {
             throw FormulaError.NUM;
@@ -9661,8 +9661,8 @@ ${e.toString()}`);
           return bessel2.besselj(x2, n);
         },
         BESSELK: (x2, n) => {
-          x2 = H.accept(x2, Types.NUMBER_NO_BOOLEAN);
-          n = H.accept(n, Types.NUMBER_NO_BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER_NO_BOOLEAN);
+          n = H.accept(n, Types3.NUMBER_NO_BOOLEAN);
           n = Math.trunc(n);
           if (n < 0) {
             throw FormulaError.NUM;
@@ -9670,8 +9670,8 @@ ${e.toString()}`);
           return bessel2.besselk(x2, n);
         },
         BESSELY: (x2, n) => {
-          x2 = H.accept(x2, Types.NUMBER_NO_BOOLEAN);
-          n = H.accept(n, Types.NUMBER_NO_BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER_NO_BOOLEAN);
+          n = H.accept(n, Types3.NUMBER_NO_BOOLEAN);
           n = Math.trunc(n);
           if (n < 0) {
             throw FormulaError.NUM;
@@ -9679,7 +9679,7 @@ ${e.toString()}`);
           return bessel2.bessely(x2, n);
         },
         BIN2DEC: (number) => {
-          number = H.accept(number, Types.NUMBER_NO_BOOLEAN);
+          number = H.accept(number, Types3.NUMBER_NO_BOOLEAN);
           let numberStr = number.toString();
           if (numberStr.length > 10) {
             throw FormulaError.NUM;
@@ -9691,8 +9691,8 @@ ${e.toString()}`);
           }
         },
         BIN2HEX: (number, places) => {
-          number = H.accept(number, Types.NUMBER_NO_BOOLEAN);
-          places = H.accept(places, Types.NUMBER_NO_BOOLEAN, null);
+          number = H.accept(number, Types3.NUMBER_NO_BOOLEAN);
+          places = H.accept(places, Types3.NUMBER_NO_BOOLEAN, null);
           const numberStr = number.toString();
           if (numberStr.length > 10) {
             throw FormulaError.NUM;
@@ -9716,8 +9716,8 @@ ${e.toString()}`);
           }
         },
         BIN2OCT: (number, places) => {
-          number = H.accept(number, Types.NUMBER_NO_BOOLEAN);
-          places = H.accept(places, Types.NUMBER, null);
+          number = H.accept(number, Types3.NUMBER_NO_BOOLEAN);
+          places = H.accept(places, Types3.NUMBER, null);
           let numberStr = number.toString();
           if (numberStr.length > 10) {
             throw FormulaError.NUM;
@@ -9741,8 +9741,8 @@ ${e.toString()}`);
           }
         },
         BITAND: (number1, number2) => {
-          number1 = H.accept(number1, Types.NUMBER);
-          number2 = H.accept(number2, Types.NUMBER);
+          number1 = H.accept(number1, Types3.NUMBER);
+          number2 = H.accept(number2, Types3.NUMBER);
           if (number1 < 0 || number2 < 0) {
             throw FormulaError.NUM;
           }
@@ -9755,8 +9755,8 @@ ${e.toString()}`);
           return number1 & number2;
         },
         BITLSHIFT: (number, shiftAmount) => {
-          number = H.accept(number, Types.NUMBER);
-          shiftAmount = H.accept(shiftAmount, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          shiftAmount = H.accept(shiftAmount, Types3.NUMBER);
           shiftAmount = Math.trunc(shiftAmount);
           if (Math.abs(shiftAmount) > 53) {
             throw FormulaError.NUM;
@@ -9771,8 +9771,8 @@ ${e.toString()}`);
             return result;
         },
         BITOR: (number1, number2) => {
-          number1 = H.accept(number1, Types.NUMBER);
-          number2 = H.accept(number2, Types.NUMBER);
+          number1 = H.accept(number1, Types3.NUMBER);
+          number2 = H.accept(number2, Types3.NUMBER);
           if (number1 < 0 || number2 < 0) {
             throw FormulaError.NUM;
           }
@@ -9785,13 +9785,13 @@ ${e.toString()}`);
           return number1 | number2;
         },
         BITRSHIFT: (number, shiftAmount) => {
-          number = H.accept(number, Types.NUMBER);
-          shiftAmount = H.accept(shiftAmount, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
+          shiftAmount = H.accept(shiftAmount, Types3.NUMBER);
           return EngineeringFunctions.BITLSHIFT(number, -shiftAmount);
         },
         BITXOR: (number1, number2) => {
-          number1 = H.accept(number1, Types.NUMBER);
-          number2 = H.accept(number2, Types.NUMBER);
+          number1 = H.accept(number1, Types3.NUMBER);
+          number2 = H.accept(number2, Types3.NUMBER);
           if (number1 < 0 || number1 > 281474976710655 || Math.floor(number1) !== number1) {
             throw FormulaError.NUM;
           }
@@ -9801,9 +9801,9 @@ ${e.toString()}`);
           return number1 ^ number2;
         },
         COMPLEX: (realNum, iNum, suffix) => {
-          realNum = H.accept(realNum, Types.NUMBER_NO_BOOLEAN);
-          iNum = H.accept(iNum, Types.NUMBER_NO_BOOLEAN);
-          suffix = H.accept(suffix, Types.STRING, "i");
+          realNum = H.accept(realNum, Types3.NUMBER_NO_BOOLEAN);
+          iNum = H.accept(iNum, Types3.NUMBER_NO_BOOLEAN);
+          suffix = H.accept(suffix, Types3.STRING, "i");
           if (suffix !== "i" && suffix !== "j") {
             throw FormulaError.VALUE;
           }
@@ -9831,8 +9831,8 @@ ${e.toString()}`);
           }
         },
         DEC2BIN: (number, places) => {
-          number = H.accept(number, Types.NUMBER);
-          places = H.accept(places, Types.NUMBER, null);
+          number = H.accept(number, Types3.NUMBER);
+          places = H.accept(places, Types3.NUMBER, null);
           if (number < MIN_BIN || number > MAX_BIN) {
             throw FormulaError.NUM;
           }
@@ -9853,8 +9853,8 @@ ${e.toString()}`);
           }
         },
         DEC2HEX: (number, places) => {
-          number = H.accept(number, Types.NUMBER);
-          places = H.accept(places, Types.NUMBER, null);
+          number = H.accept(number, Types3.NUMBER);
+          places = H.accept(places, Types3.NUMBER, null);
           if (number < -549755813888 || number > 549755813888) {
             throw FormulaError.NUM;
           }
@@ -9875,8 +9875,8 @@ ${e.toString()}`);
           }
         },
         DEC2OCT: (number, places) => {
-          number = H.accept(number, Types.NUMBER);
-          places = H.accept(places, Types.NUMBER, null);
+          number = H.accept(number, Types3.NUMBER);
+          places = H.accept(places, Types3.NUMBER, null);
           if (number < -536870912 || number > 536870912) {
             throw FormulaError.NUM;
           }
@@ -9897,27 +9897,27 @@ ${e.toString()}`);
           }
         },
         DELTA: (number1, number2) => {
-          number1 = H.accept(number1, Types.NUMBER_NO_BOOLEAN);
-          number2 = H.accept(number2, Types.NUMBER_NO_BOOLEAN, 0);
+          number1 = H.accept(number1, Types3.NUMBER_NO_BOOLEAN);
+          number2 = H.accept(number2, Types3.NUMBER_NO_BOOLEAN, 0);
           return number1 === number2 ? 1 : 0;
         },
         ERF: (lowerLimit, upperLimit) => {
-          lowerLimit = H.accept(lowerLimit, Types.NUMBER_NO_BOOLEAN);
-          upperLimit = H.accept(upperLimit, Types.NUMBER_NO_BOOLEAN, 0);
+          lowerLimit = H.accept(lowerLimit, Types3.NUMBER_NO_BOOLEAN);
+          upperLimit = H.accept(upperLimit, Types3.NUMBER_NO_BOOLEAN, 0);
           return jStat2.erf(lowerLimit);
         },
         ERFC: (x2) => {
-          x2 = H.accept(x2, Types.NUMBER_NO_BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER_NO_BOOLEAN);
           return jStat2.erfc(x2);
         },
         GESTEP: (number, step) => {
-          number = H.accept(number, Types.NUMBER_NO_BOOLEAN);
-          step = H.accept(step, Types.NUMBER_NO_BOOLEAN, 0);
+          number = H.accept(number, Types3.NUMBER_NO_BOOLEAN);
+          step = H.accept(step, Types3.NUMBER_NO_BOOLEAN, 0);
           return number >= step ? 1 : 0;
         },
         HEX2BIN: (number, places) => {
-          number = H.accept(number, Types.STRING);
-          places = H.accept(places, Types.NUMBER, null);
+          number = H.accept(number, Types3.STRING);
+          places = H.accept(places, Types3.NUMBER, null);
           if (number.length > 10 || !/^[0-9a-fA-F]*$/.test(number)) {
             throw FormulaError.NUM;
           }
@@ -9941,7 +9941,7 @@ ${e.toString()}`);
           }
         },
         HEX2DEC: (number) => {
-          number = H.accept(number, Types.STRING);
+          number = H.accept(number, Types3.STRING);
           if (number.length > 10 || !/^[0-9a-fA-F]*$/.test(number)) {
             throw FormulaError.NUM;
           }
@@ -9949,7 +9949,7 @@ ${e.toString()}`);
           return result >= 549755813888 ? result - 1099511627776 : result;
         },
         HEX2OCT: (number, places) => {
-          number = H.accept(number, Types.STRING);
+          number = H.accept(number, Types3.STRING);
           if (number.length > 10 || !/^[0-9a-fA-F]*$/.test(number)) {
             throw FormulaError.NUM;
           }
@@ -10060,7 +10060,7 @@ ${e.toString()}`);
         },
         IMPOWER: (iNumber, number) => {
           let { unit } = parseIM(iNumber);
-          number = H.accept(number, Types.NUMBER_NO_BOOLEAN);
+          number = H.accept(number, Types3.NUMBER_NO_BOOLEAN);
           let p = Math.pow(EngineeringFunctions.IMABS(iNumber), number);
           let t = EngineeringFunctions.IMARGUMENT(iNumber);
           let real = p * Math.cos(number * t);
@@ -10142,8 +10142,8 @@ ${e.toString()}`);
         },
         // FIXME: need to check the test cases
         OCT2BIN: (number, places) => {
-          number = H.accept(number, Types.STRING);
-          places = H.accept(places, Types.NUMBER, null);
+          number = H.accept(number, Types3.STRING);
+          places = H.accept(places, Types3.NUMBER, null);
           if (number.length > 10) {
             throw FormulaError.NUM;
           }
@@ -10172,7 +10172,7 @@ ${e.toString()}`);
           return TextFunctions.REPT("0", places - result.length) + result;
         },
         OCT2DEC: (number) => {
-          number = H.accept(number, Types.STRING);
+          number = H.accept(number, Types3.STRING);
           if (number.length > 10) {
             throw FormulaError.NUM;
           }
@@ -10185,8 +10185,8 @@ ${e.toString()}`);
           return result >= 536870912 ? result - 1073741824 : result;
         },
         OCT2HEX: (number, places) => {
-          number = H.accept(number, Types.STRING);
-          places = H.accept(places, Types.NUMBER_NO_BOOLEAN, null);
+          number = H.accept(number, Types3.STRING);
+          places = H.accept(places, Types3.NUMBER_NO_BOOLEAN, null);
           if (number.length > 10) {
             throw FormulaError.NUM;
           }
@@ -10219,16 +10219,16 @@ ${e.toString()}`);
   var require_reference = __commonJS({
     "../../node_modules/fast-formula-parser/formulas/functions/reference.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers, Types, WildCard, Address } = require_helpers();
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3, WildCard, Address } = require_helpers();
       var Collection = require_collection();
-      var H = FormulaHelpers;
+      var H = FormulaHelpers3;
       var ReferenceFunctions = {
         ADDRESS: (rowNumber, columnNumber, absNum, a1, sheetText) => {
-          rowNumber = H.accept(rowNumber, Types.NUMBER);
-          columnNumber = H.accept(columnNumber, Types.NUMBER);
-          absNum = H.accept(absNum, Types.NUMBER, 1);
-          a1 = H.accept(a1, Types.BOOLEAN, true);
-          sheetText = H.accept(sheetText, Types.STRING, "");
+          rowNumber = H.accept(rowNumber, Types3.NUMBER);
+          columnNumber = H.accept(columnNumber, Types3.NUMBER);
+          absNum = H.accept(absNum, Types3.NUMBER, 1);
+          a1 = H.accept(a1, Types3.BOOLEAN, true);
+          sheetText = H.accept(sheetText, Types3.STRING, "");
           if (rowNumber < 1 || columnNumber < 1 || absNum < 1 || absNum > 4)
             throw FormulaError.VALUE;
           let result = "";
@@ -10298,14 +10298,14 @@ ${e.toString()}`);
         HLOOKUP: (lookupValue, tableArray, rowIndexNum, rangeLookup) => {
           lookupValue = H.accept(lookupValue);
           try {
-            tableArray = H.accept(tableArray, Types.ARRAY, void 0, false);
+            tableArray = H.accept(tableArray, Types3.ARRAY, void 0, false);
           } catch (e) {
             if (e instanceof FormulaError)
               throw FormulaError.NA;
             throw e;
           }
-          rowIndexNum = H.accept(rowIndexNum, Types.NUMBER);
-          rangeLookup = H.accept(rangeLookup, Types.BOOLEAN, true);
+          rowIndexNum = H.accept(rowIndexNum, Types3.NUMBER);
+          rangeLookup = H.accept(rangeLookup, Types3.BOOLEAN, true);
           if (rowIndexNum < 1)
             throw FormulaError.VALUE;
           if (tableArray[rowIndexNum - 1] === void 0)
@@ -10350,14 +10350,14 @@ ${e.toString()}`);
         INDEX: (context, ranges, rowNum, colNum, areaNum) => {
           rowNum = context.utils.extractRefValue(rowNum);
           rowNum = { value: rowNum.val, isArray: rowNum.isArray };
-          rowNum = H.accept(rowNum, Types.NUMBER);
+          rowNum = H.accept(rowNum, Types3.NUMBER);
           rowNum = Math.trunc(rowNum);
           if (colNum == null) {
             colNum = 1;
           } else {
             colNum = context.utils.extractRefValue(colNum);
             colNum = { value: colNum.val, isArray: colNum.isArray };
-            colNum = H.accept(colNum, Types.NUMBER, 1);
+            colNum = H.accept(colNum, Types3.NUMBER, 1);
             colNum = Math.trunc(colNum);
           }
           if (areaNum == null) {
@@ -10365,7 +10365,7 @@ ${e.toString()}`);
           } else {
             areaNum = context.utils.extractRefValue(areaNum);
             areaNum = { value: areaNum.val, isArray: areaNum.isArray };
-            areaNum = H.accept(areaNum, Types.NUMBER, 1);
+            areaNum = H.accept(areaNum, Types3.NUMBER, 1);
             areaNum = Math.trunc(areaNum);
           }
           let range = ranges;
@@ -10456,7 +10456,7 @@ ${e.toString()}`);
           }
         },
         TRANSPOSE: (array) => {
-          array = H.accept(array, Types.ARRAY, void 0, false);
+          array = H.accept(array, Types3.ARRAY, void 0, false);
           const result = [];
           for (let i3 = 0; i3 < array[0].length; i3++) {
             result[i3] = [];
@@ -10469,14 +10469,14 @@ ${e.toString()}`);
         VLOOKUP: (lookupValue, tableArray, colIndexNum, rangeLookup) => {
           lookupValue = H.accept(lookupValue);
           try {
-            tableArray = H.accept(tableArray, Types.ARRAY, void 0, false);
+            tableArray = H.accept(tableArray, Types3.ARRAY, void 0, false);
           } catch (e) {
             if (e instanceof FormulaError)
               throw FormulaError.NA;
             throw e;
           }
-          colIndexNum = H.accept(colIndexNum, Types.NUMBER);
-          rangeLookup = H.accept(rangeLookup, Types.BOOLEAN, true);
+          colIndexNum = H.accept(colIndexNum, Types3.NUMBER);
+          rangeLookup = H.accept(rangeLookup, Types3.BOOLEAN, true);
           if (colIndexNum < 1)
             throw FormulaError.VALUE;
           if (tableArray[0][colIndexNum - 1] === void 0)
@@ -10527,8 +10527,8 @@ ${e.toString()}`);
   var require_information = __commonJS({
     "../../node_modules/fast-formula-parser/formulas/functions/information.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers, Types } = require_helpers();
-      var H = FormulaHelpers;
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3 } = require_helpers();
+      var H = FormulaHelpers3;
       var error2Number = {
         "#NULL!": 1,
         "#DIV/0!": 2,
@@ -10563,7 +10563,7 @@ ${e.toString()}`);
           return value2 instanceof FormulaError;
         },
         ISEVEN: (number) => {
-          number = H.accept(number, Types.NUMBER);
+          number = H.accept(number, Types3.NUMBER);
           number = Math.trunc(number);
           return number % 2 === 0;
         },
@@ -10645,48 +10645,48 @@ ${e.toString()}`);
   var require_distribution = __commonJS({
     "../../node_modules/fast-formula-parser/formulas/functions/distribution.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers, Types } = require_helpers();
-      var H = FormulaHelpers;
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3 } = require_helpers();
+      var H = FormulaHelpers3;
       var jStat2 = require_jstat();
       var MathFunctions = require_math();
       var SQRT2PI2 = 2.5066282746310002;
       var DistributionFunctions = {
         "BETA.DIST": (x2, alpha, beta, cumulative, a, b) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          alpha = H.accept(alpha, Types.NUMBER);
-          beta = H.accept(beta, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
-          a = H.accept(a, Types.NUMBER, 0);
-          b = H.accept(b, Types.NUMBER, 1);
+          x2 = H.accept(x2, Types3.NUMBER);
+          alpha = H.accept(alpha, Types3.NUMBER);
+          beta = H.accept(beta, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
+          a = H.accept(a, Types3.NUMBER, 0);
+          b = H.accept(b, Types3.NUMBER, 1);
           if (alpha <= 0 || beta <= 0 || x2 < a || x2 > b || a === b)
             throw FormulaError.NUM;
           x2 = (x2 - a) / (b - a);
           return cumulative ? jStat2.beta.cdf(x2, alpha, beta) : jStat2.beta.pdf(x2, alpha, beta) / (b - a);
         },
         "BETA.INV": (probability, alpha, beta, a, b) => {
-          probability = H.accept(probability, Types.NUMBER);
-          alpha = H.accept(alpha, Types.NUMBER);
-          beta = H.accept(beta, Types.NUMBER);
-          a = H.accept(a, Types.NUMBER, 0);
-          b = H.accept(b, Types.NUMBER, 1);
+          probability = H.accept(probability, Types3.NUMBER);
+          alpha = H.accept(alpha, Types3.NUMBER);
+          beta = H.accept(beta, Types3.NUMBER);
+          a = H.accept(a, Types3.NUMBER, 0);
+          b = H.accept(b, Types3.NUMBER, 1);
           if (alpha <= 0 || beta <= 0 || probability <= 0 || probability > 1)
             throw FormulaError.NUM;
           return jStat2.beta.inv(probability, alpha, beta) * (b - a) + a;
         },
         "BINOM.DIST": (numberS, trials, probabilityS, cumulative) => {
-          numberS = H.accept(numberS, Types.NUMBER);
-          trials = H.accept(trials, Types.NUMBER);
-          probabilityS = H.accept(probabilityS, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          numberS = H.accept(numberS, Types3.NUMBER);
+          trials = H.accept(trials, Types3.NUMBER);
+          probabilityS = H.accept(probabilityS, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           if (trials < 0 || probabilityS < 0 || probabilityS > 1 || numberS < 0 || numberS > trials)
             throw FormulaError.NUM;
           return cumulative ? jStat2.binomial.cdf(numberS, trials, probabilityS) : jStat2.binomial.pdf(numberS, trials, probabilityS);
         },
         "BINOM.DIST.RANGE": (trials, probabilityS, numberS, numberS2) => {
-          trials = H.accept(trials, Types.NUMBER);
-          probabilityS = H.accept(probabilityS, Types.NUMBER);
-          numberS = H.accept(numberS, Types.NUMBER);
-          numberS2 = H.accept(numberS2, Types.NUMBER, numberS);
+          trials = H.accept(trials, Types3.NUMBER);
+          probabilityS = H.accept(probabilityS, Types3.NUMBER);
+          numberS = H.accept(numberS, Types3.NUMBER);
+          numberS2 = H.accept(numberS2, Types3.NUMBER, numberS);
           if (trials < 0 || probabilityS < 0 || probabilityS > 1 || numberS < 0 || numberS > trials || numberS2 < numberS || numberS2 > trials)
             throw FormulaError.NUM;
           let result = 0;
@@ -10696,9 +10696,9 @@ ${e.toString()}`);
           return result;
         },
         "BINOM.INV": (trials, probabilityS, alpha) => {
-          trials = H.accept(trials, Types.NUMBER);
-          probabilityS = H.accept(probabilityS, Types.NUMBER);
-          alpha = H.accept(alpha, Types.NUMBER);
+          trials = H.accept(trials, Types3.NUMBER);
+          probabilityS = H.accept(probabilityS, Types3.NUMBER);
+          alpha = H.accept(alpha, Types3.NUMBER);
           if (trials < 0 || probabilityS < 0 || probabilityS > 1 || alpha < 0 || alpha > 1)
             throw FormulaError.NUM;
           let x2 = 0;
@@ -10710,41 +10710,41 @@ ${e.toString()}`);
           }
         },
         "CHISQ.DIST": (x2, degFreedom, cumulative) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          degFreedom = H.accept(degFreedom, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
+          degFreedom = H.accept(degFreedom, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.NUMBER);
           degFreedom = Math.trunc(degFreedom);
           if (x2 < 0 || degFreedom < 1 || degFreedom > 10 ** 10)
             throw FormulaError.NUM;
           return cumulative ? jStat2.chisquare.cdf(x2, degFreedom) : jStat2.chisquare.pdf(x2, degFreedom);
         },
         "CHISQ.DIST.RT": (x2, degFreedom) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          degFreedom = H.accept(degFreedom, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
+          degFreedom = H.accept(degFreedom, Types3.NUMBER);
           degFreedom = Math.trunc(degFreedom);
           if (x2 < 0 || degFreedom < 1 || degFreedom > 10 ** 10)
             throw FormulaError.NUM;
           return 1 - jStat2.chisquare.cdf(x2, degFreedom);
         },
         "CHISQ.INV": (probability, degFreedom) => {
-          probability = H.accept(probability, Types.NUMBER);
-          degFreedom = H.accept(degFreedom, Types.NUMBER);
+          probability = H.accept(probability, Types3.NUMBER);
+          degFreedom = H.accept(degFreedom, Types3.NUMBER);
           degFreedom = Math.trunc(degFreedom);
           if (probability < 0 || probability > 1 || degFreedom < 1 || degFreedom > 10 ** 10)
             throw FormulaError.NUM;
           return jStat2.chisquare.inv(probability, degFreedom);
         },
         "CHISQ.INV.RT": (probability, degFreedom) => {
-          probability = H.accept(probability, Types.NUMBER);
-          degFreedom = H.accept(degFreedom, Types.NUMBER);
+          probability = H.accept(probability, Types3.NUMBER);
+          degFreedom = H.accept(degFreedom, Types3.NUMBER);
           degFreedom = Math.trunc(degFreedom);
           if (probability < 0 || probability > 1 || degFreedom < 1 || degFreedom > 10 ** 10)
             throw FormulaError.NUM;
           return jStat2.chisquare.inv(1 - probability, degFreedom);
         },
         "CHISQ.TEST": (actualRange, expectedRange) => {
-          const actual = H.accept(actualRange, Types.ARRAY, void 0, false, false);
-          const expected = H.accept(expectedRange, Types.ARRAY, void 0, false, false);
+          const actual = H.accept(actualRange, Types3.ARRAY, void 0, false, false);
+          const expected = H.accept(expectedRange, Types3.ARRAY, void 0, false, false);
           if (actual.length !== expected.length || actual[0].length !== expected[0].length || actual.length === 1 && actual[0].length === 1)
             throw FormulaError.NA;
           const row = actual.length;
@@ -10781,18 +10781,18 @@ ${e.toString()}`);
           return 1 - p;
         },
         "CONFIDENCE.NORM": (alpha, std, size) => {
-          alpha = H.accept(alpha, Types.NUMBER);
-          std = H.accept(std, Types.NUMBER);
-          size = H.accept(size, Types.NUMBER);
+          alpha = H.accept(alpha, Types3.NUMBER);
+          std = H.accept(std, Types3.NUMBER);
+          size = H.accept(size, Types3.NUMBER);
           size = Math.trunc(size);
           if (alpha <= 0 || alpha >= 1 || std <= 0 || size < 1)
             throw FormulaError.NUM;
           return jStat2.normalci(1, alpha, std, size)[1] - 1;
         },
         "CONFIDENCE.T": (alpha, std, size) => {
-          alpha = H.accept(alpha, Types.NUMBER);
-          std = H.accept(std, Types.NUMBER);
-          size = H.accept(size, Types.NUMBER);
+          alpha = H.accept(alpha, Types3.NUMBER);
+          std = H.accept(std, Types3.NUMBER);
+          size = H.accept(size, Types3.NUMBER);
           size = Math.trunc(size);
           if (alpha <= 0 || alpha >= 1 || std <= 0 || size < 1)
             throw FormulaError.NUM;
@@ -10801,8 +10801,8 @@ ${e.toString()}`);
           return jStat2.tci(1, alpha, std, size)[1] - 1;
         },
         CORREL: (array1, array2) => {
-          array1 = H.accept(array1, Types.ARRAY, void 0, true, true);
-          array2 = H.accept(array2, Types.ARRAY, void 0, true, true);
+          array1 = H.accept(array1, Types3.ARRAY, void 0, true, true);
+          array2 = H.accept(array2, Types3.ARRAY, void 0, true, true);
           if (array1.length !== array2.length)
             throw FormulaError.NA;
           const filterArr1 = [], filterArr2 = [];
@@ -10817,8 +10817,8 @@ ${e.toString()}`);
           return jStat2.corrcoeff(filterArr1, filterArr2);
         },
         "COVARIANCE.P": (array1, array2) => {
-          array1 = H.accept(array1, Types.ARRAY, void 0, true, true);
-          array2 = H.accept(array2, Types.ARRAY, void 0, true, true);
+          array1 = H.accept(array1, Types3.ARRAY, void 0, true, true);
+          array2 = H.accept(array2, Types3.ARRAY, void 0, true, true);
           if (array1.length !== array2.length)
             throw FormulaError.NA;
           const filterArr1 = [], filterArr2 = [];
@@ -10836,8 +10836,8 @@ ${e.toString()}`);
           return result / filterArr1.length;
         },
         "COVARIANCE.S": (array1, array2) => {
-          array1 = H.accept(array1, Types.ARRAY, void 0, true, true);
-          array2 = H.accept(array2, Types.ARRAY, void 0, true, true);
+          array1 = H.accept(array1, Types3.ARRAY, void 0, true, true);
+          array2 = H.accept(array2, Types3.ARRAY, void 0, true, true);
           if (array1.length !== array2.length)
             throw FormulaError.NA;
           const filterArr1 = [], filterArr2 = [];
@@ -10853,7 +10853,7 @@ ${e.toString()}`);
         },
         DEVSQ: (...numbers2) => {
           let sum = 0, x2 = [];
-          H.flattenParams(numbers2, Types.NUMBER, true, (item, info) => {
+          H.flattenParams(numbers2, Types3.NUMBER, true, (item, info) => {
             if (typeof item === "number") {
               sum += item;
               x2.push(item);
@@ -10867,18 +10867,18 @@ ${e.toString()}`);
           return sum;
         },
         "EXPON.DIST": (x2, lambda, cumulative) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          lambda = H.accept(lambda, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER);
+          lambda = H.accept(lambda, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           if (x2 < 0 || lambda <= 0)
             throw FormulaError.NUM;
           return cumulative ? jStat2.exponential.cdf(x2, lambda) : jStat2.exponential.pdf(x2, lambda);
         },
         "F.DIST": (x2, d1, d2, cumulative) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          d1 = H.accept(d1, Types.NUMBER);
-          d2 = H.accept(d2, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER);
+          d1 = H.accept(d1, Types3.NUMBER);
+          d2 = H.accept(d2, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           if (x2 < 0 || d1 < 1 || d2 < 1) {
             throw FormulaError.NUM;
           }
@@ -10887,9 +10887,9 @@ ${e.toString()}`);
           return cumulative ? jStat2.centralF.cdf(x2, d1, d2) : jStat2.centralF.pdf(x2, d1, d2);
         },
         "F.DIST.RT": (x2, d1, d2) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          d1 = H.accept(d1, Types.NUMBER);
-          d2 = H.accept(d2, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
+          d1 = H.accept(d1, Types3.NUMBER);
+          d2 = H.accept(d2, Types3.NUMBER);
           if (x2 < 0 || d1 < 1 || d2 < 1) {
             throw FormulaError.NUM;
           }
@@ -10898,9 +10898,9 @@ ${e.toString()}`);
           return 1 - jStat2.centralF.cdf(x2, d1, d2);
         },
         "F.INV": (probability, d1, d2) => {
-          probability = H.accept(probability, Types.NUMBER);
-          d1 = H.accept(d1, Types.NUMBER);
-          d2 = H.accept(d2, Types.NUMBER);
+          probability = H.accept(probability, Types3.NUMBER);
+          d1 = H.accept(d1, Types3.NUMBER);
+          d2 = H.accept(d2, Types3.NUMBER);
           if (probability < 0 || probability > 1) {
             throw FormulaError.NUM;
           }
@@ -10912,9 +10912,9 @@ ${e.toString()}`);
           return jStat2.centralF.inv(probability, d1, d2);
         },
         "F.INV.RT": (probability, d1, d2) => {
-          probability = H.accept(probability, Types.NUMBER);
-          d1 = H.accept(d1, Types.NUMBER);
-          d2 = H.accept(d2, Types.NUMBER);
+          probability = H.accept(probability, Types3.NUMBER);
+          d1 = H.accept(d1, Types3.NUMBER);
+          d2 = H.accept(d2, Types3.NUMBER);
           if (probability < 0 || probability > 1) {
             throw FormulaError.NUM;
           }
@@ -10932,8 +10932,8 @@ ${e.toString()}`);
          * https://en.wikipedia.org/wiki/F-test_of_equality_of_variances
          */
         "F.TEST": (array1, array2) => {
-          array1 = H.accept(array1, Types.ARRAY, void 0, true, true);
-          array2 = H.accept(array2, Types.ARRAY, void 0, true, true);
+          array1 = H.accept(array1, Types3.ARRAY, void 0, true, true);
+          array2 = H.accept(array2, Types3.ARRAY, void 0, true, true);
           const x1 = [], x2 = [];
           let x1Mean = 0, x2Mean = 0;
           for (let i3 = 0; i3 < Math.max(array1.length, array2.length); i3++) {
@@ -10962,22 +10962,22 @@ ${e.toString()}`);
           return jStat2.centralF.cdf(s1 / s2, x1.length - 1, x2.length - 1) * 2;
         },
         FISHER: (x2) => {
-          x2 = H.accept(x2, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
           if (x2 <= -1 || x2 >= 1) {
             throw FormulaError.NUM;
           }
           return Math.log((1 + x2) / (1 - x2)) / 2;
         },
         FISHERINV: (x2) => {
-          x2 = H.accept(x2, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
           let e2y = Math.exp(2 * x2);
           return (e2y - 1) / (e2y + 1);
         },
         // FIXME
         FORECAST: (x2, knownYs, knownXs) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          knownYs = H.accept(knownYs, Types.ARRAY, void 0, true, true);
-          knownXs = H.accept(knownXs, Types.ARRAY, void 0, true, true);
+          x2 = H.accept(x2, Types3.NUMBER);
+          knownYs = H.accept(knownYs, Types3.ARRAY, void 0, true, true);
+          knownXs = H.accept(knownXs, Types3.ARRAY, void 0, true, true);
           if (knownXs.length !== knownYs.length)
             throw FormulaError.NA;
           const filteredY = [], filteredX = [];
@@ -11015,8 +11015,8 @@ ${e.toString()}`);
           return DistributionFunctions.FORECAST(...params);
         },
         FREQUENCY: (dataArray, binsArray) => {
-          dataArray = H.accept(dataArray, Types.ARRAY, void 0, true, true);
-          binsArray = H.accept(binsArray, Types.ARRAY, void 0, true, true);
+          dataArray = H.accept(dataArray, Types3.ARRAY, void 0, true, true);
+          binsArray = H.accept(binsArray, Types3.ARRAY, void 0, true, true);
           const binsArrayFiltered = [];
           for (let i3 = 0; i3 < binsArray.length; i3++) {
             if (typeof binsArray[i3] !== "number")
@@ -11043,52 +11043,52 @@ ${e.toString()}`);
           return result;
         },
         GAMMA: (x2) => {
-          x2 = H.accept(x2, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
           if (x2 === 0 || x2 < 0 && x2 === Math.trunc(x2)) {
             throw FormulaError.NUM;
           }
           return jStat2.gammafn(x2);
         },
         "GAMMA.DIST": (x2, alpha, beta, cumulative) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          alpha = H.accept(alpha, Types.NUMBER);
-          beta = H.accept(beta, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER);
+          alpha = H.accept(alpha, Types3.NUMBER);
+          beta = H.accept(beta, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           if (x2 < 0 || alpha <= 0 || beta <= 0) {
             throw FormulaError.NUM;
           }
           return cumulative ? jStat2.gamma.cdf(x2, alpha, beta, true) : jStat2.gamma.pdf(x2, alpha, beta, false);
         },
         "GAMMA.INV": (probability, alpha, beta) => {
-          probability = H.accept(probability, Types.NUMBER);
-          alpha = H.accept(alpha, Types.NUMBER);
-          beta = H.accept(beta, Types.NUMBER);
+          probability = H.accept(probability, Types3.NUMBER);
+          alpha = H.accept(alpha, Types3.NUMBER);
+          beta = H.accept(beta, Types3.NUMBER);
           if (probability < 0 || probability > 1 || alpha <= 0 || beta <= 0) {
             throw FormulaError.NUM;
           }
           return jStat2.gamma.inv(probability, alpha, beta);
         },
         GAMMALN: (x2) => {
-          x2 = H.accept(x2, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
           if (x2 <= 0) {
             throw FormulaError.NUM;
           }
           return jStat2.gammaln(x2);
         },
         "GAMMALN.PRECISE": (x2) => {
-          x2 = H.accept(x2, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
           if (x2 <= 0) {
             throw FormulaError.NUM;
           }
           return jStat2.gammaln(x2);
         },
         GAUSS: (z) => {
-          z = H.accept(z, Types.NUMBER);
+          z = H.accept(z, Types3.NUMBER);
           return jStat2.normal.cdf(z, 0, 1) - 0.5;
         },
         GEOMEAN: (...numbers2) => {
           const filterArr = [];
-          H.flattenParams(numbers2, Types.NUMBER, true, (item, info) => {
+          H.flattenParams(numbers2, Types3.NUMBER, true, (item, info) => {
             if (typeof item === "number") {
               filterArr.push(item);
             }
@@ -11096,12 +11096,12 @@ ${e.toString()}`);
           return jStat2.geomean(filterArr);
         },
         GROWTH: (knownY, knownX, newX, useConst) => {
-          knownY = H.accept(knownY, Types.ARRAY, void 0, true, true);
+          knownY = H.accept(knownY, Types3.ARRAY, void 0, true, true);
           for (let i3 = 0; i3 < knownY.length; i3++) {
             if (typeof knownY[i3] !== "number")
               throw FormulaError.VALUE;
           }
-          knownX = H.accept(knownX, Types.ARRAY, null, true, true);
+          knownX = H.accept(knownX, Types3.ARRAY, null, true, true);
           const isKnownXOmitted = knownX == null;
           if (knownX == null) {
             knownX = [];
@@ -11116,7 +11116,7 @@ ${e.toString()}`);
                 throw FormulaError.VALUE;
             }
           }
-          newX = H.accept(newX, Types.ARRAY, null, false, true);
+          newX = H.accept(newX, Types3.ARRAY, null, false, true);
           if (newX == null && isKnownXOmitted) {
             newX = [];
             for (let i3 = 1; i3 <= knownY.length; i3++) {
@@ -11126,7 +11126,7 @@ ${e.toString()}`);
           } else if (newX == null) {
             newX = Array.isArray(knownX[0]) ? knownX : [knownX];
           }
-          useConst = H.accept(useConst, Types.BOOLEAN, true);
+          useConst = H.accept(useConst, Types3.BOOLEAN, true);
           const n = knownY.length;
           let avg_x = 0, avg_y = 0, avg_xy = 0, avg_xx = 0;
           for (let i3 = 0; i3 < n; i3++) {
@@ -11163,7 +11163,7 @@ ${e.toString()}`);
         },
         HARMEAN: (...numbers2) => {
           let cnt = 0, denominator = 0;
-          H.flattenParams(numbers2, Types.NUMBER, true, (item, info) => {
+          H.flattenParams(numbers2, Types3.NUMBER, true, (item, info) => {
             if (typeof item === "number") {
               denominator += 1 / item;
               cnt++;
@@ -11172,11 +11172,11 @@ ${e.toString()}`);
           return cnt / denominator;
         },
         "HYPGEOM.DIST": (sample_s, number_sample, population_s, number_pop, cumulative) => {
-          sample_s = H.accept(sample_s, Types.NUMBER);
-          number_sample = H.accept(number_sample, Types.NUMBER);
-          population_s = H.accept(population_s, Types.NUMBER);
-          number_pop = H.accept(number_pop, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          sample_s = H.accept(sample_s, Types3.NUMBER);
+          number_sample = H.accept(number_sample, Types3.NUMBER);
+          population_s = H.accept(population_s, Types3.NUMBER);
+          number_pop = H.accept(number_pop, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           sample_s = Math.trunc(sample_s);
           number_sample = Math.trunc(number_sample);
           population_s = Math.trunc(population_s);
@@ -11209,8 +11209,8 @@ ${e.toString()}`);
           return cumulative ? cdf(sample_s, number_sample, population_s, number_pop) : pdf(sample_s, number_sample, population_s, number_pop);
         },
         INTERCEPT: (knownYs, knownXs) => {
-          knownYs = H.accept(knownYs, Types.ARRAY, void 0, true, true);
-          knownXs = H.accept(knownXs, Types.ARRAY, void 0, true, true);
+          knownYs = H.accept(knownYs, Types3.ARRAY, void 0, true, true);
+          knownXs = H.accept(knownXs, Types3.ARRAY, void 0, true, true);
           if (knownXs.length !== knownYs.length)
             throw FormulaError.NA;
           const filteredY = [], filteredX = [];
@@ -11234,7 +11234,7 @@ ${e.toString()}`);
         },
         KURT: (...numbers2) => {
           let mean = 0, range = [];
-          H.flattenParams(numbers2, Types.NUMBER, true, (item, info) => {
+          H.flattenParams(numbers2, Types3.NUMBER, true, (item, info) => {
             if (typeof item === "number") {
               mean += item;
               range.push(item);
@@ -11254,19 +11254,19 @@ ${e.toString()}`);
         LOGEST: () => {
         },
         "LOGNORM.DIST": (x2, mean, standard_dev, cumulative) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          mean = H.accept(mean, Types.NUMBER);
-          standard_dev = H.accept(standard_dev, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER);
+          mean = H.accept(mean, Types3.NUMBER);
+          standard_dev = H.accept(standard_dev, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           if (x2 <= 0 || standard_dev <= 0) {
             throw FormulaError.NUM;
           }
           return cumulative ? jStat2.lognormal.cdf(x2, mean, standard_dev) : jStat2.lognormal.pdf(x2, mean, standard_dev);
         },
         "LOGNORM.INV": (probability, mean, standard_dev) => {
-          probability = H.accept(probability, Types.NUMBER);
-          mean = H.accept(mean, Types.NUMBER);
-          standard_dev = H.accept(standard_dev, Types.NUMBER);
+          probability = H.accept(probability, Types3.NUMBER);
+          mean = H.accept(mean, Types3.NUMBER);
+          standard_dev = H.accept(standard_dev, Types3.NUMBER);
           if (probability <= 0 || probability >= 1) {
             throw FormulaError.NUM;
           }
@@ -11280,10 +11280,10 @@ ${e.toString()}`);
         "MODE.SNGL": () => {
         },
         "NEGBINOM.DIST": (number_f, number_s, probability_s, cumulative) => {
-          number_f = H.accept(number_f, Types.NUMBER);
-          number_s = H.accept(number_s, Types.NUMBER);
-          probability_s = H.accept(probability_s, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          number_f = H.accept(number_f, Types3.NUMBER);
+          number_s = H.accept(number_s, Types3.NUMBER);
+          probability_s = H.accept(probability_s, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           number_f = Math.trunc(number_f);
           number_s = Math.trunc(number_s);
           if (probability_s < 0 || probability_s > 1) {
@@ -11295,19 +11295,19 @@ ${e.toString()}`);
           return cumulative ? jStat2.negbin.cdf(number_f, number_s, probability_s) : jStat2.negbin.pdf(number_f, number_s, probability_s);
         },
         "NORM.DIST": (x2, mean, standard_dev, cumulative) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          mean = H.accept(mean, Types.NUMBER);
-          standard_dev = H.accept(standard_dev, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER);
+          mean = H.accept(mean, Types3.NUMBER);
+          standard_dev = H.accept(standard_dev, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           if (standard_dev <= 0) {
             throw FormulaError.NUM;
           }
           return cumulative ? jStat2.normal.cdf(x2, mean, standard_dev) : jStat2.normal.pdf(x2, mean, standard_dev);
         },
         "NORM.INV": (probability, mean, standard_dev) => {
-          probability = H.accept(probability, Types.NUMBER);
-          mean = H.accept(mean, Types.NUMBER);
-          standard_dev = H.accept(standard_dev, Types.NUMBER);
+          probability = H.accept(probability, Types3.NUMBER);
+          mean = H.accept(mean, Types3.NUMBER);
+          standard_dev = H.accept(standard_dev, Types3.NUMBER);
           if (probability <= 0 || probability >= 1) {
             throw FormulaError.NUM;
           }
@@ -11317,12 +11317,12 @@ ${e.toString()}`);
           return jStat2.normal.inv(probability, mean, standard_dev);
         },
         "NORM.S.DIST": (z, cumulative) => {
-          z = H.accept(z, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          z = H.accept(z, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           return cumulative ? jStat2.normal.cdf(z, 0, 1) : jStat2.normal.pdf(z, 0, 1);
         },
         "NORM.S.INV": (probability) => {
-          probability = H.accept(probability, Types.NUMBER);
+          probability = H.accept(probability, Types3.NUMBER);
           if (probability <= 0 || probability >= 1) {
             throw FormulaError.NUM;
           }
@@ -11341,13 +11341,13 @@ ${e.toString()}`);
         PERMUTATIONA: () => {
         },
         PHI: (x2) => {
-          x2 = H.accept(x2, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
           return Math.exp(-0.5 * x2 * x2) / SQRT2PI2;
         },
         "POISSON.DIST": (x2, mean, cumulative) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          mean = H.accept(mean, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER);
+          mean = H.accept(mean, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           if (x2 < 0 || mean < 0) {
             throw FormulaError.NUM;
           }
@@ -11373,9 +11373,9 @@ ${e.toString()}`);
         SLOPE: () => {
         },
         STANDARDIZE: (x2, mean, standard_dev) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          mean = H.accept(mean, Types.NUMBER);
-          standard_dev = H.accept(standard_dev, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
+          mean = H.accept(mean, Types3.NUMBER);
+          standard_dev = H.accept(standard_dev, Types3.NUMBER);
           if (standard_dev <= 0) {
             throw FormulaError.NUM;
           }
@@ -11392,33 +11392,33 @@ ${e.toString()}`);
         STEYX: () => {
         },
         "T.DIST": (x2, deg_freedom, cumulative) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          deg_freedom = H.accept(deg_freedom, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER);
+          deg_freedom = H.accept(deg_freedom, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           if (deg_freedom < 1) {
             throw FormulaError.NUM;
           }
           return cumulative ? jStat2.studentt.cdf(x2, deg_freedom) : jStat2.studentt.pdf(x2, deg_freedom);
         },
         "T.DIST.2T": (x2, deg_freedom) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          deg_freedom = H.accept(deg_freedom, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
+          deg_freedom = H.accept(deg_freedom, Types3.NUMBER);
           if (deg_freedom < 1 || x2 < 0) {
             throw FormulaError.NUM;
           }
           return (1 - jStat2.studentt.cdf(x2, deg_freedom)) * 2;
         },
         "T.DIST.RT": (x2, deg_freedom) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          deg_freedom = H.accept(deg_freedom, Types.NUMBER);
+          x2 = H.accept(x2, Types3.NUMBER);
+          deg_freedom = H.accept(deg_freedom, Types3.NUMBER);
           if (deg_freedom < 1) {
             throw FormulaError.NUM;
           }
           return 1 - jStat2.studentt.cdf(x2, deg_freedom);
         },
         "T.INV": (probability, deg_freedom) => {
-          probability = H.accept(probability, Types.NUMBER);
-          deg_freedom = H.accept(deg_freedom, Types.NUMBER);
+          probability = H.accept(probability, Types3.NUMBER);
+          deg_freedom = H.accept(deg_freedom, Types3.NUMBER);
           if (probability <= 0 || probability > 1 || deg_freedom < 1) {
             throw FormulaError.NUM;
           }
@@ -11426,8 +11426,8 @@ ${e.toString()}`);
           return jStat2.studentt.inv(probability, deg_freedom);
         },
         "T.INV.2T": (probability, deg_freedom) => {
-          probability = H.accept(probability, Types.NUMBER);
-          deg_freedom = H.accept(deg_freedom, Types.NUMBER);
+          probability = H.accept(probability, Types3.NUMBER);
+          deg_freedom = H.accept(deg_freedom, Types3.NUMBER);
           if (probability <= 0 || probability > 1 || deg_freedom < 1) {
             throw FormulaError.NUM;
           }
@@ -11449,10 +11449,10 @@ ${e.toString()}`);
         "VARPA": () => {
         },
         "WEIBULL.DIST": (x2, alpha, beta, cumulative) => {
-          x2 = H.accept(x2, Types.NUMBER);
-          alpha = H.accept(alpha, Types.NUMBER);
-          beta = H.accept(beta, Types.NUMBER);
-          cumulative = H.accept(cumulative, Types.BOOLEAN);
+          x2 = H.accept(x2, Types3.NUMBER);
+          alpha = H.accept(alpha, Types3.NUMBER);
+          beta = H.accept(beta, Types3.NUMBER);
+          cumulative = H.accept(cumulative, Types3.BOOLEAN);
           if (x2 < 0 || alpha <= 0 || beta <= 0) {
             throw FormulaError.NUM;
           }
@@ -11471,15 +11471,15 @@ ${e.toString()}`);
   var require_statistical = __commonJS({
     "../../node_modules/fast-formula-parser/formulas/functions/statistical.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers, Types, Criteria, Address } = require_helpers();
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3, Criteria, Address } = require_helpers();
       var { Infix: Infix2 } = require_operators();
-      var H = FormulaHelpers;
+      var H = FormulaHelpers3;
       var { DistributionFunctions } = require_distribution();
       var StatisticalFunctions = {
         AVEDEV: (...numbers2) => {
           let sum = 0;
           const arr = [];
-          H.flattenParams(numbers2, Types.NUMBER, true, (item, info) => {
+          H.flattenParams(numbers2, Types3.NUMBER, true, (item, info) => {
             if (typeof item === "number") {
               sum += item;
               arr.push(item);
@@ -11494,7 +11494,7 @@ ${e.toString()}`);
         },
         AVERAGE: (...numbers2) => {
           let sum = 0, cnt = 0;
-          H.flattenParams(numbers2, Types.NUMBER, true, (item, info) => {
+          H.flattenParams(numbers2, Types3.NUMBER, true, (item, info) => {
             if (typeof item === "number") {
               sum += item;
               cnt++;
@@ -11504,7 +11504,7 @@ ${e.toString()}`);
         },
         AVERAGEA: (...numbers2) => {
           let sum = 0, cnt = 0;
-          H.flattenParams(numbers2, Types.NUMBER, true, (item, info) => {
+          H.flattenParams(numbers2, Types3.NUMBER, true, (item, info) => {
             const type = typeof item;
             if (type === "number") {
               sum += item;
@@ -11563,7 +11563,7 @@ ${e.toString()}`);
           return cnt;
         },
         COUNTIF: (range, criteria) => {
-          range = H.accept(range, Types.ARRAY, void 0, false, true);
+          range = H.accept(range, Types3.ARRAY, void 0, false, true);
           const isCriteriaArray = criteria.isArray;
           criteria = H.accept(criteria);
           let cnt = 0;
@@ -11611,8 +11611,8 @@ ${e.toString()}`);
   var require_date = __commonJS({
     "../../node_modules/fast-formula-parser/formulas/functions/date.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers, Types } = require_helpers();
-      var H = FormulaHelpers;
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3 } = require_helpers();
+      var H = FormulaHelpers3;
       var MS_PER_DAY2 = 1e3 * 60 * 60 * 24;
       var d1900 = new Date(Date.UTC(1900, 0, 1));
       var WEEK_STARTS2 = [
@@ -11764,9 +11764,9 @@ ${e.toString()}`);
       }
       var DateFunctions = {
         DATE: (year, month, day) => {
-          year = H.accept(year, Types.NUMBER);
-          month = H.accept(month, Types.NUMBER);
-          day = H.accept(day, Types.NUMBER);
+          year = H.accept(year, Types3.NUMBER);
+          month = H.accept(month, Types3.NUMBER);
+          day = H.accept(day, Types3.NUMBER);
           if (year < 0 || year >= 1e4)
             throw FormulaError.NUM;
           if (year < 1900) {
@@ -11777,7 +11777,7 @@ ${e.toString()}`);
         DATEDIF: (startDate, endDate, unit) => {
           startDate = parseDate2(startDate);
           endDate = parseDate2(endDate);
-          unit = H.accept(unit, Types.STRING).toLowerCase();
+          unit = H.accept(unit, Types3.STRING).toLowerCase();
           if (startDate > endDate)
             throw FormulaError.NUM;
           const yearDiff = endDate.getUTCFullYear() - startDate.getUTCFullYear();
@@ -11819,7 +11819,7 @@ ${e.toString()}`);
          * @param {string} dateText
          */
         DATEVALUE: (dateText) => {
-          dateText = H.accept(dateText, Types.STRING);
+          dateText = H.accept(dateText, Types3.STRING);
           const { date: date2, isDateGiven } = parseDateWithExtra(dateText);
           if (!isDateGiven) return 0;
           const serial = toSerial(date2);
@@ -11843,7 +11843,7 @@ ${e.toString()}`);
         DAYS360: (startDate, endDate, method) => {
           startDate = parseDate2(startDate);
           endDate = parseDate2(endDate);
-          method = H.accept(method, Types.BOOLEAN, false);
+          method = H.accept(method, Types3.BOOLEAN, false);
           if (startDate.getUTCDate() === 31) {
             startDate.setUTCDate(30);
           }
@@ -11861,13 +11861,13 @@ ${e.toString()}`);
         },
         EDATE: (startDate, months) => {
           startDate = parseDate2(startDate);
-          months = H.accept(months, Types.NUMBER);
+          months = H.accept(months, Types3.NUMBER);
           startDate.setUTCMonth(startDate.getUTCMonth() + months);
           return toSerial(startDate);
         },
         EOMONTH: (startDate, months) => {
           startDate = parseDate2(startDate);
-          months = H.accept(months, Types.NUMBER);
+          months = H.accept(months, Types3.NUMBER);
           startDate.setUTCMonth(startDate.getUTCMonth() + months + 1, 0);
           return toSerial(startDate);
         },
@@ -11903,7 +11903,7 @@ ${e.toString()}`);
           }
           const holidaysArr = [];
           if (holidays != null) {
-            H.flattenParams([holidays], Types.NUMBER, false, (item) => {
+            H.flattenParams([holidays], Types3.NUMBER, false, (item) => {
               holidaysArr.push(parseDate2(item));
             });
           }
@@ -11952,7 +11952,7 @@ ${e.toString()}`);
           }
           const holidaysArr = [];
           if (holidays != null) {
-            H.flattenParams([holidays], Types.NUMBER, false, (item) => {
+            H.flattenParams([holidays], Types3.NUMBER, false, (item) => {
               holidaysArr.push(parseDate2(item));
             });
           }
@@ -11996,9 +11996,9 @@ ${e.toString()}`);
           return date2.getUTCSeconds();
         },
         TIME: (hour, minute, second) => {
-          hour = H.accept(hour, Types.NUMBER);
-          minute = H.accept(minute, Types.NUMBER);
-          second = H.accept(second, Types.NUMBER);
+          hour = H.accept(hour, Types3.NUMBER);
+          minute = H.accept(minute, Types3.NUMBER);
+          second = H.accept(second, Types3.NUMBER);
           if (hour < 0 || hour > 32767 || minute < 0 || minute > 32767 || second < 0 || second > 32767)
             throw FormulaError.NUM;
           return (3600 * hour + 60 * minute + second) / 86400;
@@ -12013,7 +12013,7 @@ ${e.toString()}`);
         },
         WEEKDAY: (serialOrString, returnType) => {
           const date2 = parseDate2(serialOrString);
-          returnType = H.accept(returnType, Types.NUMBER, 1);
+          returnType = H.accept(returnType, Types3.NUMBER, 1);
           const day = date2.getUTCDay();
           const weekTypes = WEEK_TYPES2[returnType];
           if (!weekTypes)
@@ -12022,7 +12022,7 @@ ${e.toString()}`);
         },
         WEEKNUM: (serialOrString, returnType) => {
           const date2 = parseDate2(serialOrString);
-          returnType = H.accept(returnType, Types.NUMBER, 1);
+          returnType = H.accept(returnType, Types3.NUMBER, 1);
           if (returnType === 21) {
             return DateFunctions.ISOWEEKNUM(serialOrString);
           }
@@ -12036,7 +12036,7 @@ ${e.toString()}`);
         },
         "WORKDAY.INTL": (startDate, days, weekend, holidays) => {
           startDate = parseDate2(startDate);
-          days = H.accept(days, Types.NUMBER);
+          days = H.accept(days, Types3.NUMBER);
           weekend = H.accept(weekend, null, 1);
           if (weekend === "1111111")
             throw FormulaError.VALUE;
@@ -12059,7 +12059,7 @@ ${e.toString()}`);
           }
           const holidaysArr = [];
           if (holidays != null) {
-            H.flattenParams([holidays], Types.NUMBER, false, (item) => {
+            H.flattenParams([holidays], Types3.NUMBER, false, (item) => {
               holidaysArr.push(parseDate2(item));
             });
           }
@@ -12100,7 +12100,7 @@ ${e.toString()}`);
             startDate = endDate;
             endDate = temp;
           }
-          basis = H.accept(basis, Types.NUMBER, 0);
+          basis = H.accept(basis, Types3.NUMBER, 0);
           basis = Math.trunc(basis);
           if (basis < 0 || basis > 4)
             throw FormulaError.VALUE;
@@ -12149,18 +12149,18 @@ ${e.toString()}`);
   var require_web = __commonJS({
     "../../node_modules/fast-formula-parser/formulas/functions/web.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers, Types } = require_helpers();
-      var H = FormulaHelpers;
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3 } = require_helpers();
+      var H = FormulaHelpers3;
       var WebFunctions = {
         ENCODEURL: (text) => {
-          return encodeURIComponent(H.accept(text, Types.STRING));
+          return encodeURIComponent(H.accept(text, Types3.STRING));
         },
         FILTERXML: () => {
         },
         WEBSERVICE: (context, url) => {
           throw FormulaError.ERROR("WEBSERVICE is not supported in sync mode.");
           if (typeof fetch === "function") {
-            url = H.accept(url, Types.STRING);
+            url = H.accept(url, Types3.STRING);
             return fetch(url).then((res) => res.text());
           } else {
             throw FormulaError.ERROR("WEBSERVICE only available to browser with fetch.If you want to use WEBSERVICE in Node.js, please override this function: \nnew FormulaParser({\n    functionsNeedContext: {\n        WEBSERVICE: (context, url) => {...}}\n})");
@@ -21488,7 +21488,7 @@ ${e.toString()}`);
       var DateFunctions = require_date();
       var WebFunctions = require_web();
       var FormulaError = require_error();
-      var { FormulaHelpers } = require_helpers();
+      var { FormulaHelpers: FormulaHelpers3 } = require_helpers();
       var { Parser, allTokens } = require_parsing();
       var lexer = require_lexing();
       var Utils = require_utils2();
@@ -21586,10 +21586,10 @@ ${e.toString()}`);
          * @return {*}
          */
         retrieveRef(valueOrRef) {
-          if (FormulaHelpers.isRangeRef(valueOrRef)) {
+          if (FormulaHelpers3.isRangeRef(valueOrRef)) {
             return this.getRange(valueOrRef.ref);
           }
-          if (FormulaHelpers.isCellRef(valueOrRef)) {
+          if (FormulaHelpers3.isCellRef(valueOrRef)) {
             return this.getCell(valueOrRef.ref);
           }
           return valueOrRef;
@@ -21616,8 +21616,8 @@ ${e.toString()}`);
               return {
                 value: res.val,
                 isArray: res.isArray,
-                isRangeRef: !!FormulaHelpers.isRangeRef(arg),
-                isCellRef: !!FormulaHelpers.isCellRef(arg)
+                isRangeRef: !!FormulaHelpers3.isRangeRef(arg),
+                isCellRef: !!FormulaHelpers3.isCellRef(arg)
               };
             });
           }
@@ -21657,14 +21657,14 @@ ${e.toString()}`);
             awaitedArgs.push(await arg);
           }
           const res = await this._callFunction(name2, awaitedArgs);
-          return FormulaHelpers.checkFunctionResult(res);
+          return FormulaHelpers3.checkFunctionResult(res);
         }
         callFunction(name2, args) {
           if (this.async) {
             return this.callFunctionAsync(name2, args);
           } else {
             const res = this._callFunction(name2, args);
-            return FormulaHelpers.checkFunctionResult(res);
+            return FormulaHelpers3.checkFunctionResult(res);
           }
         }
         /**
@@ -21796,7 +21796,7 @@ ${e.toString()}`);
       };
       module2.exports = {
         FormulaParser: FormulaParser2,
-        FormulaHelpers
+        FormulaHelpers: FormulaHelpers3
       };
     }
   });
@@ -21805,7 +21805,7 @@ ${e.toString()}`);
   var require_utils3 = __commonJS({
     "../../node_modules/fast-formula-parser/grammar/dependency/utils.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers, Types, Address } = require_helpers();
+      var { FormulaHelpers: FormulaHelpers3, Types: Types3, Address } = require_helpers();
       var { Prefix, Postfix, Infix: Infix2, Operators } = require_operators();
       var Collection = require_collection();
       var MAX_ROW = 1048576;
@@ -22057,7 +22057,7 @@ ${e.toString()}`);
   var require_hooks2 = __commonJS({
     "../../node_modules/fast-formula-parser/grammar/dependency/hooks.js"(exports2, module2) {
       var FormulaError = require_error();
-      var { FormulaHelpers } = require_helpers();
+      var { FormulaHelpers: FormulaHelpers3 } = require_helpers();
       var { Parser } = require_parsing();
       var lexer = require_lexing();
       var Utils = require_utils3();
@@ -22122,7 +22122,7 @@ ${e.toString()}`);
           const res = { ref: this.onVariable(name2, this.position.sheet) };
           if (res.ref == null)
             return FormulaError.NAME;
-          if (FormulaHelpers.isCellRef(res))
+          if (FormulaHelpers3.isCellRef(res))
             this.getCell(res.ref);
           else {
             this.getRange(res.ref);
@@ -22135,10 +22135,10 @@ ${e.toString()}`);
          * @return {*}
          */
         retrieveRef(valueOrRef) {
-          if (FormulaHelpers.isRangeRef(valueOrRef)) {
+          if (FormulaHelpers3.isRangeRef(valueOrRef)) {
             return this.getRange(valueOrRef.ref);
           }
-          if (FormulaHelpers.isCellRef(valueOrRef)) {
+          if (FormulaHelpers3.isCellRef(valueOrRef)) {
             return this.getCell(valueOrRef.ref);
           }
           return valueOrRef;
@@ -62024,6 +62024,90 @@ ${e.toString()}`);
       }
       return result;
     }
+    /**
+     * Every cell that participates in a circular reference, in one pass.
+     *
+     * `detectCycle` answers the same question for ONE cell, which is what an edit
+     * needs; asking it per cell to check a whole workbook is worse than quadratic
+     * — 512 ms at 1,000 formula cells and it does not finish at 10,000, so a batch
+     * recompute would hang. This is Tarjan's strongly-connected-components
+     * algorithm over the same precedents graph: O(V+E), one pass, every cycle at
+     * once. A cell is circular if it sits in an SCC larger than one, or if it
+     * references itself directly.
+     *
+     * Iterative rather than recursive on purpose: a cascading column is an
+     * ordinary shape and a 10,000-deep chain would overflow the stack.
+     *
+     * **Coarse nodes are deliberately not expanded.** A whole-column node stands
+     * for a range that may have been over-approximated (a bounded `A1:A15000`
+     * collapses to all of column A), so following it could report a cycle that
+     * does not exist — and the one thing worse than a wrong number here is
+     * `#CIRC!` written into a correct customer document. The cost is that
+     * `A1 = SUM(A:A)` is not caught in a batch recompute; it still is on an edit,
+     * where `detectCycle` compares against the origin's own coarse nodes.
+     */
+    findCycles() {
+      const circular = /* @__PURE__ */ new Set();
+      let nextIndex = 0;
+      const index = /* @__PURE__ */ new Map();
+      const lowLink = /* @__PURE__ */ new Map();
+      const onStack = /* @__PURE__ */ new Set();
+      const stack = [];
+      for (const root of this.precedents.keys()) {
+        if (index.has(root)) continue;
+        const frames = [{ node: root, prec: this.exactPrecedents(root), i: 0 }];
+        index.set(root, nextIndex);
+        lowLink.set(root, nextIndex);
+        nextIndex++;
+        stack.push(root);
+        onStack.add(root);
+        while (frames.length > 0) {
+          const frame = frames[frames.length - 1];
+          if (frame.i < frame.prec.length) {
+            const next = frame.prec[frame.i++];
+            if (next === frame.node) {
+              circular.add(next);
+              continue;
+            }
+            if (!index.has(next)) {
+              index.set(next, nextIndex);
+              lowLink.set(next, nextIndex);
+              nextIndex++;
+              stack.push(next);
+              onStack.add(next);
+              frames.push({ node: next, prec: this.exactPrecedents(next), i: 0 });
+            } else if (onStack.has(next)) {
+              lowLink.set(frame.node, Math.min(lowLink.get(frame.node), index.get(next)));
+            }
+            continue;
+          }
+          frames.pop();
+          const parent = frames[frames.length - 1];
+          if (parent) {
+            lowLink.set(parent.node, Math.min(lowLink.get(parent.node), lowLink.get(frame.node)));
+          }
+          if (lowLink.get(frame.node) === index.get(frame.node)) {
+            const component = [];
+            for (; ; ) {
+              const member = stack.pop();
+              onStack.delete(member);
+              component.push(member);
+              if (member === frame.node) break;
+            }
+            if (component.length > 1) for (const member of component) circular.add(member);
+          }
+        }
+      }
+      return circular;
+    }
+    /** Precedents that are real cells — coarse nodes are skipped (see `findCycles`). */
+    exactPrecedents(cell) {
+      const prec = this.precedents.get(cell);
+      if (!prec) return [];
+      const out = [];
+      for (const p of prec) if (!isCoarseKey(p)) out.push(p);
+      return out;
+    }
     /** Detect if `cell` appears in its own transitive precedent chain (circular reference). */
     detectCycle(cell) {
       const visited = /* @__PURE__ */ new Set();
@@ -62149,12 +62233,17 @@ ${e.toString()}`);
     };
   }
 
-  // ../xlsx/src/blank_comparison.ts
+  // ../xlsx/src/blank_semantics.ts
   var import_operators = __toESM(require_operators(), 1);
+  var import_helpers = __toESM(require_helpers(), 1);
   var patched = false;
   function applyExcelBlankSemantics() {
     if (patched) return;
     patched = true;
+    patchComparison();
+    patchArgumentCoercion();
+  }
+  function patchComparison() {
     const original = import_operators.Infix.compareOp;
     import_operators.Infix.compareOp = (value1, infix, value2, isArray1, isArray2) => {
       if (value1 == null && typeof value2 === "string") value1 = "";
@@ -62162,8 +62251,27 @@ ${e.toString()}`);
       return original(value1, infix, value2, isArray1, isArray2);
     };
   }
+  function isBlankCell(param) {
+    if (typeof param !== "object" || param === null || Array.isArray(param)) return false;
+    if (!("value" in param) || param.value != null) return false;
+    return !("omitted" in param) || !param.omitted;
+  }
+  function patchArgumentCoercion() {
+    const original = import_helpers.FormulaHelpers.accept.bind(import_helpers.FormulaHelpers);
+    import_helpers.FormulaHelpers.accept = (param, type, defValue, flat, allowSingleValue) => {
+      const want = Array.isArray(type) ? type[0] : type;
+      if (isBlankCell(param)) {
+        if (want === import_helpers.Types.STRING) return "";
+        if (want === import_helpers.Types.NUMBER || want === import_helpers.Types.NUMBER_NO_BOOLEAN) return 0;
+        if (want === import_helpers.Types.BOOLEAN) return false;
+        if (want == null) return null;
+      }
+      return original(param, want, defValue, flat, allowSingleValue);
+    };
+  }
 
   // ../xlsx/src/formula_engine.ts
+  var import_helpers2 = __toESM(require_helpers(), 1);
   var unwrapArg = (a) => a !== null && typeof a === "object" && "value" in a ? a.value : a;
   function adaptFormulajs(fn) {
     return (...args) => fn(...args.map(unwrapArg));
@@ -62222,20 +62330,84 @@ ${e.toString()}`);
        * cannot draw, refuse what you cannot read.
        */
       this.unreadableFormulas = /* @__PURE__ */ new Set();
+      /**
+       * Cells found to be circular by the batch pass, held so evaluation refuses
+       * them.
+       *
+       * Leaving them out of the seed list is NOT enough: `getRecalcOrder` pulls in
+       * transitive dependents, so any cycle fed by another FORMULA gets evaluated
+       * anyway and overwrites its `#CIRC!` with the parser's generic `#ERROR!` —
+       * which sends a reader hunting a broken formula instead of the cycle that is
+       * actually there. A cycle fed by a formula rather than a constant is the
+       * ordinary case, so the guard has to sit at evaluation.
+       */
+      this.circularFormulas = /* @__PURE__ */ new Set();
       applyExcelBlankSemantics();
       this.workbook = workbook;
       this.parser = new import_fast_formula_parser.default({
         onCell: (ref2) => this.resolveCell(ref2),
         onRange: (ref2) => this.resolveRange(ref2),
-        onVariable: (name2) => this.resolveVariable(name2),
+        onVariable: (name2, sheet) => this.resolveVariable(name2, sheet),
         functions: formulajsBridge(),
         // A handful of names (CHOOSE among them) are dispatched through the
         // context-aware path, where a plain `functions` entry is never consulted.
         // Register there too, dropping the context argument the parser prepends —
         // formulajs has no use for it.
-        functionsNeedContext: formulajsBridgeWithContext()
+        functionsNeedContext: {
+          ...formulajsBridgeWithContext(),
+          // INDEX is the one bridged function the parser hands a RAW REFERENCE
+          // rather than values, because it sits in the parser's
+          // `funsNeedContextAndNoDataRetrieve` set. The generic bridge unwraps an
+          // argument by reading `.value`; a `{ref}` has none, so the descriptor
+          // itself reached formulajs, which wants a 2D array — every INDEX in
+          // every workbook returned `#VALUE!`. One real file lost 10 of its 13
+          // formulas to it, 8 of them cascading from 2 roots.
+          //
+          // It resolves here rather than in the bridge because the bridge is
+          // memoized per PROCESS and knows no workbook, so it structurally cannot
+          // resolve a reference. `lazy_ref_arguments.test.ts` pins that INDEX is
+          // still the only name in that position — if upstream ever adds another,
+          // that test fails instead of the function silently returning `#VALUE!`.
+          INDEX: (_context, ref2, ...rest2) => INDEX(
+            this.resolveRefAsGrid(ref2),
+            ...rest2.map((a) => this.resolveRefOrValue(a))
+          ),
+          // IF sits in that same `noDataRetrieve` set, and the parser's own
+          // implementation forgets to resolve the one argument that needs it:
+          // the condition arrives as a raw `{ref}` and is handed straight to
+          // `accept(_, Types.BOOLEAN)`, which has no branch for a reference and
+          // returns the descriptor unchanged. A descriptor is an object, and
+          // every object is truthy — so `IF(<any cell>, a, b)` returns `a`
+          // unconditionally, including when the cell holds 0, FALSE, or nothing.
+          // Verified against the unconfigured library, so it is upstream's bug
+          // and not a consequence of this engine's configuration.
+          //
+          // It stays quiet in most workbooks because the common form is
+          // `IF(A1="", …)` — a comparison, which evaluates to a real boolean
+          // before IF ever sees it. Only a bare cell reference as the condition
+          // is affected, which is exactly how a boolean or checkbox column gets
+          // tested.
+          //
+          // The condition is coerced by handing the resolved value back to the
+          // library's own `accept`, so blank/0/text/error all keep Excel's
+          // answers rather than a second opinion invented here.
+          IF: (_context, condition, whenTrue, whenFalse) => {
+            const resolved = this.resolveRefOrValue(condition);
+            const test = import_helpers2.FormulaHelpers.accept(
+              { value: resolved, isArray: Array.isArray(resolved) },
+              import_helpers2.Types.BOOLEAN
+            );
+            const branch = test ? whenTrue : whenFalse;
+            if (branch === null) return 0;
+            if (branch === void 0) return false;
+            const taken = this.resolveRefOrValue(branch);
+            return taken ?? 0;
+          }
+        }
+      });
+      this.depParser = new import_fast_formula_parser.default.DepParser({
+        onVariable: (name2, sheet) => this.resolveVariable(name2, sheet)
       });
-      this.depParser = new import_fast_formula_parser.default.DepParser();
     }
     // ===========================================================================
     // Initialization — build graph and evaluate missing values
@@ -62279,12 +62451,14 @@ ${e.toString()}`);
      * show stale values.
      */
     evaluateAll() {
+      this.circularFormulas = this.graph.findCycles();
+      for (const key of this.circularFormulas) this.setCellError(key, "#CIRC!");
       const all = [];
       for (const sheet of this.workbook.sheets) {
         for (const [ref2, cell] of sheet.cells) {
-          if (cell.formula) {
-            all.push(cellKey({ sheet: sheet.name, ref: ref2 }));
-          }
+          if (!cell.formula) continue;
+          const key = cellKey({ sheet: sheet.name, ref: ref2 });
+          if (!this.circularFormulas.has(key)) all.push(key);
         }
       }
       this.evaluateSet(all);
@@ -62308,6 +62482,7 @@ ${e.toString()}`);
         const { deps, readable } = this.analyzeFormula(formula, sheetName);
         this.graph.setDependencies(key, deps);
         this.unreadableFormulas.delete(key);
+        this.circularFormulas.delete(key);
         if (!readable) {
           this.setCellError(key, "#ERROR!");
           return;
@@ -62321,6 +62496,7 @@ ${e.toString()}`);
       } else {
         this.graph.removeCell(key);
         this.unreadableFormulas.delete(key);
+        this.circularFormulas.delete(key);
       }
       const order = this.graph.getRecalcOrder([key]);
       for (const depKey of order) {
@@ -62338,6 +62514,7 @@ ${e.toString()}`);
     /** Evaluate a single formula cell and update its value. */
     evaluateCell(key) {
       if (this.unreadableFormulas.has(key)) return;
+      if (this.circularFormulas.has(key)) return;
       const { sheet: sheetName, ref: ref2 } = parseCellKey(key);
       const sheetIndex = this.workbook.sheets.findIndex((s) => s.name === sheetName);
       if (sheetIndex < 0) return;
@@ -62348,11 +62525,7 @@ ${e.toString()}`);
       if (!rc) return;
       const expandedFormula = expandStructuredRefs(cell.formula, sheet.tables, rc.row);
       try {
-        const raw = this.parser.parse(expandedFormula, {
-          sheet: sheetName,
-          row: rc.row,
-          col: rc.col
-        });
+        const raw = this.parse(expandedFormula, sheetName, rc.row, rc.col);
         const result = normalizeResult(raw);
         cell.value = result.value;
         cell.error = result.error;
@@ -62437,6 +62610,10 @@ ${e.toString()}`);
       }
       return { deps: refs, readable: true };
     }
+    /** Cells in a circular reference, by key. Exposed so the cost can be measured. */
+    graphCycles() {
+      return this.graph.findCycles();
+    }
     /** Formula cells the parser could not read, by key. Read by the recompute report. */
     unreadable() {
       return this.unreadableFormulas;
@@ -62445,17 +62622,54 @@ ${e.toString()}`);
     // Cell value resolution callbacks
     // ===========================================================================
     resolveCell(ref2) {
-      const sheetName = ref2.sheet ?? this.workbook.sheets[0]?.name ?? "Sheet1";
+      const sheetName = ref2.sheet ?? this.evaluatingSheet ?? this.workbook.sheets[0]?.name ?? "Sheet1";
       const sheet = this.workbook.sheets.find((s) => s.name === sheetName);
       if (!sheet) return null;
       const cellRef = rowColToRef(ref2.row, ref2.col);
       const cell = sheet.getCell(cellRef);
       if (!cell) return null;
-      if (cell.error) throw new Error(cell.error);
+      if (cell.error) return new import_fast_formula_parser.default.FormulaError(cell.error);
       return cell.value;
     }
+    /**
+     * Resolve a parser reference descriptor to the value behind it — a 2D grid
+     * for a range, a scalar for a single cell.
+     *
+     * The descriptor shapes are exactly what `resolveRange` and `resolveCell`
+     * already take (`{from, to, sheet?}` and `{row, col, sheet?}`), so this reuses
+     * them rather than re-deriving anything, and the whole-column clamp comes
+     * along unchanged.
+     *
+     * Needed for EVERY argument, not just the array: a function in the parser's
+     * `noDataRetrieve` set gets none of its arguments materialized, so
+     * `INDEX(range, A1, A2)` — the form the real workbook used — arrives with the
+     * row and column as references too.
+     */
+    resolveRefOrValue(arg) {
+      const ref2 = arg?.ref;
+      if (ref2 && typeof ref2 === "object") {
+        if ("from" in ref2 && "to" in ref2) {
+          return this.resolveRange(ref2);
+        }
+        if ("row" in ref2 && "col" in ref2) {
+          return this.resolveCell(ref2);
+        }
+      }
+      return unwrapArg(arg);
+    }
+    /**
+     * The same, forced to the 2D shape an array argument must have.
+     *
+     * Deliberately not `CellValue[][]`: a cell holding an error resolves to a
+     * `FormulaError`, which the receiving function is expected to propagate. A
+     * cast narrowing that away would be a false promise, not a safe one.
+     */
+    resolveRefAsGrid(arg) {
+      const value2 = this.resolveRefOrValue(arg);
+      return Array.isArray(value2) ? value2 : [[value2]];
+    }
     resolveRange(ref2) {
-      const sheetName = ref2.sheet ?? this.workbook.sheets[0]?.name ?? "Sheet1";
+      const sheetName = ref2.sheet ?? this.evaluatingSheet ?? this.workbook.sheets[0]?.name ?? "Sheet1";
       const sheet = this.workbook.sheets.find((s) => s.name === sheetName);
       if (!sheet) return [[]];
       let lastRow = ref2.to.row;
@@ -62478,34 +62692,42 @@ ${e.toString()}`);
     // ===========================================================================
     // Named range resolution
     // ===========================================================================
-    resolveVariable(name2) {
+    /**
+     * Resolve a defined name to the REFERENCE it stands for.
+     *
+     * A reference, not a value: the parser wraps whatever comes back as
+     * `{ref: …}` and materializes it itself through `onCell`/`onRange`. Returning
+     * the resolved value instead — which this used to do — produced `{ref: 11}`,
+     * whose `.row` is undefined, so **every** formula naming a range answered
+     * `#VALUE!`. Same value-vs-reference confusion as INDEX and IF above, in the
+     * one callback where the library documents the contract the other way round.
+     *
+     * Returning `null` is the "no such name" signal the parser turns into
+     * `#NAME?`, which is also Excel's answer for a name that resolves to a
+     * constant or a formula rather than a reference — unsupported, and loud.
+     *
+     * `sheetName` is the position the parser is evaluating at, which is what an
+     * unqualified expression is relative to.
+     */
+    resolveVariable(name2, sheetName) {
       const rangeExpr = this.workbook.namedRanges.get(name2);
       if (rangeExpr === void 0) return null;
       const cleaned = rangeExpr.replace(/\$/g, "");
       const sheetMatch = cleaned.match(/^(.+?)!(.+)$/);
-      const sheetName = sheetMatch ? sheetMatch[1].replace(/^'|'$/g, "") : this.workbook.sheets[0]?.name ?? "Sheet1";
+      const sheet = sheetMatch ? sheetMatch[1].replace(/^'|'$/g, "") : sheetName;
       const rangeStr = sheetMatch ? sheetMatch[2] : cleaned;
-      const sheet = this.workbook.sheets.find((s) => s.name === sheetName);
-      if (!sheet) return null;
+      if (!this.workbook.sheets.some((s) => s.name === sheet)) return null;
       const rangeMatch = rangeStr.match(/^([A-Z]+)(\d+):([A-Z]+)(\d+)$/);
       if (rangeMatch) {
-        const fromRow = parseInt(rangeMatch[2], 10);
-        const fromCol = colLettersToNum(rangeMatch[1]);
-        const toRow = parseInt(rangeMatch[4], 10);
-        const toCol = colLettersToNum(rangeMatch[3]);
-        return this.resolveRange({
-          from: { row: fromRow, col: fromCol },
-          to: { row: toRow, col: toCol },
-          sheet: sheetName
-        });
+        return {
+          from: { row: parseInt(rangeMatch[2], 10), col: colLettersToNum(rangeMatch[1]) },
+          to: { row: parseInt(rangeMatch[4], 10), col: colLettersToNum(rangeMatch[3]) },
+          sheet
+        };
       }
       const cellMatch = rangeStr.match(/^([A-Z]+)(\d+)$/);
       if (cellMatch) {
-        return this.resolveCell({
-          row: parseInt(cellMatch[2], 10),
-          col: colLettersToNum(cellMatch[1]),
-          sheet: sheetName
-        });
+        return { row: parseInt(cellMatch[2], 10), col: colLettersToNum(cellMatch[1]), sheet };
       }
       return null;
     }
@@ -62515,12 +62737,33 @@ ${e.toString()}`);
     /** Evaluate an arbitrary formula expression. Used by CF expression rules. */
     evaluateExpression(formula, sheetName, row, col) {
       try {
-        return this.parser.parse(formula, { sheet: sheetName, row, col });
+        return this.parse(formula, sheetName, row, col);
       } catch (err2) {
         if (isFormulaError(err2)) return null;
         throw err2;
       }
     }
+    /**
+     * The one place a formula is handed to the parser, so the sheet it belongs to
+     * is recorded for the duration.
+     *
+     * An UNQUALIFIED reference means "this formula's sheet", and for the ordinary
+     * `onCell`/`onRange` path the parser fills that in from the position below.
+     * The functions in its `noDataRetrieve` set are the exception: their arguments
+     * arrive as raw descriptors that were never resolved, and those carry only
+     * `{address, row, col}` — no sheet at all. Resolving one against the first
+     * sheet in the workbook reads a different sheet's cell, silently, and a blank
+     * there is indistinguishable from a real empty one.
+     */
+    parse(formula, sheetName, row, col) {
+      const previous = this.evaluatingSheet;
+      this.evaluatingSheet = sheetName;
+      try {
+        return this.parser.parse(formula, { sheet: sheetName, row, col });
+      } finally {
+        this.evaluatingSheet = previous;
+      }
+    }
     /** Get the dependency graph (for testing/debugging). */
     get deps() {
       return this.graph;
@@ -62536,7 +62779,7 @@ ${e.toString()}`);
     return v instanceof Error && typeof v.name === "string" && v.name.startsWith("#");
   }
   function normalizeResult(result) {
-    if (result === null || result === void 0) return { value: null };
+    if (result === null || result === void 0) return { value: 0 };
     if (typeof result === "number") return { value: result };
     if (typeof result === "boolean") return { value: result };
     if (typeof result === "string") return { value: result };
@@ -62573,7 +62816,7 @@ ${e.toString()}`);
           continue;
         }
         if (cell.value === null) {
-          unevaluated.push({ sheet: sheet.name, ref: ref2, formula: cell.formula, error: cell.error ?? "#ERROR!" });
+          unevaluated.push({ sheet: sheet.name, ref: ref2, formula: cell.formula, error: cell.error ?? "#NO_VALUE!" });
         }
       }
     }