@particle-academy/fancy-sheets 0.1.2 → 0.2.0

package/dist/index.cjs

@@ -356,6 +356,105 @@ registerFunction("ABS", (args) => {
   if (isNaN(num)) return "#VALUE!";
   return Math.abs(num);
 });
+function toNum(args) {
+  const val = args.flat()[0];
+  const n = typeof val === "number" ? val : Number(val);
+  return isNaN(n) ? NaN : n;
+}
+registerFunction("SQRT", (args) => {
+  const n = toNum(args);
+  return isNaN(n) ? "#VALUE!" : n < 0 ? "#NUM!" : Math.sqrt(n);
+});
+registerFunction("POWER", (args) => {
+  const flat = args.flat();
+  const base = typeof flat[0] === "number" ? flat[0] : Number(flat[0]);
+  const exp = typeof flat[1] === "number" ? flat[1] : Number(flat[1]);
+  if (isNaN(base) || isNaN(exp)) return "#VALUE!";
+  return Math.pow(base, exp);
+});
+registerFunction("MOD", (args) => {
+  const flat = args.flat();
+  const num = typeof flat[0] === "number" ? flat[0] : Number(flat[0]);
+  const div = typeof flat[1] === "number" ? flat[1] : Number(flat[1]);
+  if (isNaN(num) || isNaN(div) || div === 0) return "#VALUE!";
+  return num % div;
+});
+registerFunction("INT", (args) => {
+  const n = toNum(args);
+  return isNaN(n) ? "#VALUE!" : Math.floor(n);
+});
+registerFunction("TRUNC", (args) => {
+  const flat = args.flat();
+  const num = typeof flat[0] === "number" ? flat[0] : Number(flat[0]);
+  const decimals = flat[1] != null ? typeof flat[1] === "number" ? flat[1] : Number(flat[1]) : 0;
+  if (isNaN(num)) return "#VALUE!";
+  const factor = Math.pow(10, decimals);
+  return Math.trunc(num * factor) / factor;
+});
+registerFunction("FLOOR", (args) => {
+  const flat = args.flat();
+  const num = typeof flat[0] === "number" ? flat[0] : Number(flat[0]);
+  const sig = typeof flat[1] === "number" ? flat[1] : Number(flat[1]);
+  if (isNaN(num) || isNaN(sig) || sig === 0) return "#VALUE!";
+  return Math.floor(num / sig) * sig;
+});
+registerFunction("CEILING", (args) => {
+  const flat = args.flat();
+  const num = typeof flat[0] === "number" ? flat[0] : Number(flat[0]);
+  const sig = typeof flat[1] === "number" ? flat[1] : Number(flat[1]);
+  if (isNaN(num) || isNaN(sig) || sig === 0) return "#VALUE!";
+  return Math.ceil(num / sig) * sig;
+});
+registerFunction("SIGN", (args) => {
+  const n = toNum(args);
+  return isNaN(n) ? "#VALUE!" : Math.sign(n);
+});
+registerFunction("PRODUCT", (args) => {
+  const nums = toNumbers(args);
+  if (nums.length === 0) return 0;
+  return nums.reduce((a, b) => a * b, 1);
+});
+registerFunction("PI", () => Math.PI);
+registerFunction("EXP", (args) => {
+  const n = toNum(args);
+  return isNaN(n) ? "#VALUE!" : Math.exp(n);
+});
+registerFunction("LN", (args) => {
+  const n = toNum(args);
+  return isNaN(n) || n <= 0 ? "#NUM!" : Math.log(n);
+});
+registerFunction("LOG", (args) => {
+  const flat = args.flat();
+  const num = typeof flat[0] === "number" ? flat[0] : Number(flat[0]);
+  const base = flat[1] != null ? typeof flat[1] === "number" ? flat[1] : Number(flat[1]) : 10;
+  if (isNaN(num) || num <= 0 || isNaN(base) || base <= 0 || base === 1) return "#NUM!";
+  return Math.log(num) / Math.log(base);
+});
+registerFunction("LOG10", (args) => {
+  const n = toNum(args);
+  return isNaN(n) || n <= 0 ? "#NUM!" : Math.log10(n);
+});
+registerFunction("RAND", () => Math.random());
+registerFunction("RANDBETWEEN", (args) => {
+  const flat = args.flat();
+  const low = typeof flat[0] === "number" ? flat[0] : Number(flat[0]);
+  const high = typeof flat[1] === "number" ? flat[1] : Number(flat[1]);
+  if (isNaN(low) || isNaN(high)) return "#VALUE!";
+  return Math.floor(Math.random() * (high - low + 1)) + low;
+});
+registerFunction("MEDIAN", (args) => {
+  const nums = toNumbers(args).sort((a, b) => a - b);
+  if (nums.length === 0) return 0;
+  const mid = Math.floor(nums.length / 2);
+  return nums.length % 2 === 0 ? (nums[mid - 1] + nums[mid]) / 2 : nums[mid];
+});
+registerFunction("FACT", (args) => {
+  const n = toNum(args);
+  if (isNaN(n) || n < 0 || n !== Math.floor(n)) return "#VALUE!";
+  let result = 1;
+  for (let i = 2; i <= n; i++) result *= i;
+  return result;
+});
 
 // src/engine/formula/functions/text.ts
 registerFunction("UPPER", (args) => {
@@ -377,6 +476,108 @@ registerFunction("TRIM", (args) => {
 registerFunction("CONCAT", (args) => {
   return args.flat().map((v) => v != null ? String(v) : "").join("");
 });
+registerFunction("LEFT", (args) => {
+  const flat = args.flat();
+  const text = flat[0] != null ? String(flat[0]) : "";
+  const chars = flat[1] != null ? Number(flat[1]) : 1;
+  return text.slice(0, chars);
+});
+registerFunction("RIGHT", (args) => {
+  const flat = args.flat();
+  const text = flat[0] != null ? String(flat[0]) : "";
+  const chars = flat[1] != null ? Number(flat[1]) : 1;
+  return text.slice(-chars);
+});
+registerFunction("MID", (args) => {
+  const flat = args.flat();
+  const text = flat[0] != null ? String(flat[0]) : "";
+  const start = Number(flat[1]) - 1;
+  const chars = Number(flat[2]);
+  if (isNaN(start) || isNaN(chars)) return "#VALUE!";
+  return text.slice(start, start + chars);
+});
+registerFunction("FIND", (args) => {
+  const flat = args.flat();
+  const search = flat[0] != null ? String(flat[0]) : "";
+  const text = flat[1] != null ? String(flat[1]) : "";
+  const startPos = flat[2] != null ? Number(flat[2]) - 1 : 0;
+  const idx = text.indexOf(search, startPos);
+  return idx === -1 ? "#VALUE!" : idx + 1;
+});
+registerFunction("SEARCH", (args) => {
+  const flat = args.flat();
+  const search = flat[0] != null ? String(flat[0]).toLowerCase() : "";
+  const text = flat[1] != null ? String(flat[1]).toLowerCase() : "";
+  const startPos = flat[2] != null ? Number(flat[2]) - 1 : 0;
+  const idx = text.indexOf(search, startPos);
+  return idx === -1 ? "#VALUE!" : idx + 1;
+});
+registerFunction("SUBSTITUTE", (args) => {
+  const flat = args.flat();
+  const text = flat[0] != null ? String(flat[0]) : "";
+  const oldText = flat[1] != null ? String(flat[1]) : "";
+  const newText = flat[2] != null ? String(flat[2]) : "";
+  const nth = flat[3] != null ? Number(flat[3]) : 0;
+  if (nth === 0) return text.split(oldText).join(newText);
+  let count = 0;
+  return text.replace(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), (match) => {
+    count++;
+    return count === nth ? newText : match;
+  });
+});
+registerFunction("REPLACE", (args) => {
+  const flat = args.flat();
+  const text = flat[0] != null ? String(flat[0]) : "";
+  const start = Number(flat[1]) - 1;
+  const chars = Number(flat[2]);
+  const newText = flat[3] != null ? String(flat[3]) : "";
+  if (isNaN(start) || isNaN(chars)) return "#VALUE!";
+  return text.slice(0, start) + newText + text.slice(start + chars);
+});
+registerFunction("REPT", (args) => {
+  const flat = args.flat();
+  const text = flat[0] != null ? String(flat[0]) : "";
+  const times = Number(flat[1]);
+  if (isNaN(times) || times < 0) return "#VALUE!";
+  return text.repeat(times);
+});
+registerFunction("EXACT", (args) => {
+  const flat = args.flat();
+  return String(flat[0] ?? "") === String(flat[1] ?? "");
+});
+registerFunction("PROPER", (args) => {
+  const val = args.flat()[0];
+  const text = val != null ? String(val) : "";
+  return text.replace(/\w\S*/g, (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase());
+});
+registerFunction("VALUE", (args) => {
+  const val = args.flat()[0];
+  const num = Number(val);
+  return isNaN(num) ? "#VALUE!" : num;
+});
+registerFunction("TEXT", (args) => {
+  const flat = args.flat();
+  const val = flat[0];
+  const fmt = flat[1] != null ? String(flat[1]) : "";
+  if (val == null) return "";
+  const num = Number(val);
+  if (isNaN(num)) return String(val);
+  if (fmt.includes("%")) return (num * 100).toFixed(fmt.split(".")[1]?.length ?? 0) + "%";
+  if (fmt.includes(".")) {
+    const decimals = fmt.split(".")[1]?.replace(/[^0#]/g, "").length ?? 0;
+    return num.toFixed(decimals);
+  }
+  return String(num);
+});
+registerFunction("CHAR", (args) => {
+  const code = Number(args.flat()[0]);
+  if (isNaN(code)) return "#VALUE!";
+  return String.fromCharCode(code);
+});
+registerFunction("CODE", (args) => {
+  const text = String(args.flat()[0] ?? "");
+  return text.length > 0 ? text.charCodeAt(0) : "#VALUE!";
+});
 
 // src/engine/formula/functions/logic.ts
 function toBool(v) {
@@ -401,6 +602,407 @@ registerFunction("OR", (args) => {
 registerFunction("NOT", (args) => {
   return !toBool(args.flat()[0]);
 });
+registerFunction("IFERROR", (args) => {
+  const flat = args.flat();
+  const val = flat[0];
+  if (typeof val === "string" && val.startsWith("#")) return flat[1] ?? "";
+  return val;
+});
+registerFunction("IFBLANK", (args) => {
+  const flat = args.flat();
+  const val = flat[0];
+  if (val === null || val === void 0 || val === "") return flat[1] ?? "";
+  return val;
+});
+registerFunction("SWITCH", (args) => {
+  const flat = args.flat();
+  const expr = flat[0];
+  for (let i = 1; i < flat.length - 1; i += 2) {
+    if (flat[i] === expr) return flat[i + 1];
+  }
+  return flat.length % 2 === 0 ? flat[flat.length - 1] : "#N/A";
+});
+registerFunction("CHOOSE", (args) => {
+  const flat = args.flat();
+  const index = Number(flat[0]);
+  if (isNaN(index) || index < 1 || index >= flat.length) return "#VALUE!";
+  return flat[index];
+});
+
+// src/engine/formula/functions/conditional.ts
+function matchesCriteria(value, criteria) {
+  if (criteria === null || criteria === void 0) return false;
+  const critStr = String(criteria);
+  if (critStr.startsWith("<>")) {
+    const target = critStr.slice(2);
+    const num2 = Number(target);
+    if (!isNaN(num2) && typeof value === "number") return value !== num2;
+    return String(value) !== target;
+  }
+  if (critStr.startsWith(">=")) {
+    const num2 = Number(critStr.slice(2));
+    return typeof value === "number" && value >= num2;
+  }
+  if (critStr.startsWith("<=")) {
+    const num2 = Number(critStr.slice(2));
+    return typeof value === "number" && value <= num2;
+  }
+  if (critStr.startsWith(">")) {
+    const num2 = Number(critStr.slice(1));
+    return typeof value === "number" && value > num2;
+  }
+  if (critStr.startsWith("<")) {
+    const num2 = Number(critStr.slice(1));
+    return typeof value === "number" && value < num2;
+  }
+  if (critStr.startsWith("=")) {
+    const target = critStr.slice(1);
+    const num2 = Number(target);
+    if (!isNaN(num2) && typeof value === "number") return value === num2;
+    return String(value).toLowerCase() === target.toLowerCase();
+  }
+  if (critStr.includes("*") || critStr.includes("?")) {
+    const pattern = critStr.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp("^" + pattern + "$", "i").test(String(value));
+  }
+  if (typeof criteria === "number") return value === criteria;
+  const num = Number(critStr);
+  if (!isNaN(num) && typeof value === "number") return value === num;
+  return String(value).toLowerCase() === critStr.toLowerCase();
+}
+registerFunction("SUMIF", (args) => {
+  const range = args[0] ?? [];
+  const criteria = (args[1] ?? [])[0];
+  const sumRange = args[2] ?? range;
+  let total = 0;
+  for (let i = 0; i < range.length; i++) {
+    if (matchesCriteria(range[i], criteria)) {
+      const val = Number(sumRange[i] ?? 0);
+      if (!isNaN(val)) total += val;
+    }
+  }
+  return total;
+});
+registerFunction("SUMIFS", (args) => {
+  const sumRange = args[0] ?? [];
+  let total = 0;
+  for (let i = 0; i < sumRange.length; i++) {
+    let allMatch = true;
+    for (let p = 1; p < args.length - 1; p += 2) {
+      const criteriaRange = args[p] ?? [];
+      const criteria = (args[p + 1] ?? [])[0];
+      if (!matchesCriteria(criteriaRange[i], criteria)) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      const val = Number(sumRange[i] ?? 0);
+      if (!isNaN(val)) total += val;
+    }
+  }
+  return total;
+});
+registerFunction("COUNTIF", (args) => {
+  const range = args[0] ?? [];
+  const criteria = (args[1] ?? [])[0];
+  let count = 0;
+  for (const val of range) {
+    if (matchesCriteria(val, criteria)) count++;
+  }
+  return count;
+});
+registerFunction("COUNTIFS", (args) => {
+  if (args.length < 2) return 0;
+  const len = (args[0] ?? []).length;
+  let count = 0;
+  for (let i = 0; i < len; i++) {
+    let allMatch = true;
+    for (let p = 0; p < args.length - 1; p += 2) {
+      const range = args[p] ?? [];
+      const criteria = (args[p + 1] ?? [])[0];
+      if (!matchesCriteria(range[i], criteria)) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) count++;
+  }
+  return count;
+});
+registerFunction("AVERAGEIF", (args) => {
+  const range = args[0] ?? [];
+  const criteria = (args[1] ?? [])[0];
+  const avgRange = args[2] ?? range;
+  let total = 0;
+  let count = 0;
+  for (let i = 0; i < range.length; i++) {
+    if (matchesCriteria(range[i], criteria)) {
+      const val = Number(avgRange[i] ?? 0);
+      if (!isNaN(val)) {
+        total += val;
+        count++;
+      }
+    }
+  }
+  return count === 0 ? "#DIV/0!" : total / count;
+});
+registerFunction("AVERAGEIFS", (args) => {
+  const avgRange = args[0] ?? [];
+  let total = 0;
+  let count = 0;
+  for (let i = 0; i < avgRange.length; i++) {
+    let allMatch = true;
+    for (let p = 1; p < args.length - 1; p += 2) {
+      const criteriaRange = args[p] ?? [];
+      const criteria = (args[p + 1] ?? [])[0];
+      if (!matchesCriteria(criteriaRange[i], criteria)) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      const val = Number(avgRange[i] ?? 0);
+      if (!isNaN(val)) {
+        total += val;
+        count++;
+      }
+    }
+  }
+  return count === 0 ? "#DIV/0!" : total / count;
+});
+registerFunction("MINIFS", (args) => {
+  const minRange = args[0] ?? [];
+  let result = Infinity;
+  for (let i = 0; i < minRange.length; i++) {
+    let allMatch = true;
+    for (let p = 1; p < args.length - 1; p += 2) {
+      const criteriaRange = args[p] ?? [];
+      const criteria = (args[p + 1] ?? [])[0];
+      if (!matchesCriteria(criteriaRange[i], criteria)) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      const val = Number(minRange[i]);
+      if (!isNaN(val) && val < result) result = val;
+    }
+  }
+  return result === Infinity ? 0 : result;
+});
+registerFunction("MAXIFS", (args) => {
+  const maxRange = args[0] ?? [];
+  let result = -Infinity;
+  for (let i = 0; i < maxRange.length; i++) {
+    let allMatch = true;
+    for (let p = 1; p < args.length - 1; p += 2) {
+      const criteriaRange = args[p] ?? [];
+      const criteria = (args[p + 1] ?? [])[0];
+      if (!matchesCriteria(criteriaRange[i], criteria)) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      const val = Number(maxRange[i]);
+      if (!isNaN(val) && val > result) result = val;
+    }
+  }
+  return result === -Infinity ? 0 : result;
+});
+
+// src/engine/formula/functions/lookup.ts
+registerFunction("VLOOKUP", (args) => {
+  const flat = args.flat();
+  const key = flat[0];
+  const range = args[1] ?? [];
+  const colIdx = Number(flat[2] ?? flat[args[1]?.length ?? 0]);
+  if (key === null || isNaN(colIdx)) return "#VALUE!";
+  for (let i = 0; i < range.length; i++) {
+    if (range[i] === key || typeof range[i] === "string" && typeof key === "string" && range[i].toLowerCase() === key.toLowerCase()) {
+      return range[i] ?? "#N/A";
+    }
+  }
+  return "#N/A";
+});
+registerFunction("HLOOKUP", (args) => {
+  const flat = args.flat();
+  const key = flat[0];
+  const range = args[1] ?? [];
+  for (let i = 0; i < range.length; i++) {
+    if (range[i] === key || typeof range[i] === "string" && typeof key === "string" && range[i].toLowerCase() === key.toLowerCase()) {
+      return range[i] ?? "#N/A";
+    }
+  }
+  return "#N/A";
+});
+registerFunction("INDEX", (args) => {
+  const range = args[0] ?? [];
+  const flat = args.flat();
+  const row = Number(flat[range.length] ?? flat[1]);
+  if (isNaN(row) || row < 1 || row > range.length) return "#REF!";
+  return range[row - 1] ?? null;
+});
+registerFunction("MATCH", (args) => {
+  const flat = args.flat();
+  const key = flat[0];
+  const range = args[1] ?? [];
+  for (let i = 0; i < range.length; i++) {
+    if (range[i] === key || typeof range[i] === "number" && typeof key === "number" && range[i] === key) {
+      return i + 1;
+    }
+    if (typeof range[i] === "string" && typeof key === "string" && range[i].toLowerCase() === key.toLowerCase()) {
+      return i + 1;
+    }
+  }
+  return "#N/A";
+});
+registerFunction("ROWS", (args) => {
+  return (args[0] ?? []).length;
+});
+registerFunction("COLUMNS", (args) => {
+  return 1;
+});
+registerFunction("ROW", (args) => {
+  const val = args.flat()[0];
+  if (typeof val === "number") return val;
+  return "#VALUE!";
+});
+registerFunction("COLUMN", (args) => {
+  const val = args.flat()[0];
+  if (typeof val === "number") return val;
+  return "#VALUE!";
+});
+
+// src/engine/formula/functions/datetime.ts
+var EXCEL_EPOCH = new Date(1899, 11, 30).getTime();
+function dateToSerial(d) {
+  const ms = d.getTime() - EXCEL_EPOCH;
+  return Math.floor(ms / 864e5);
+}
+function serialToDate(serial) {
+  return new Date(EXCEL_EPOCH + serial * 864e5);
+}
+function toSerial(val) {
+  if (typeof val === "number") return val;
+  if (typeof val === "string") {
+    const d = new Date(val);
+    if (!isNaN(d.getTime())) return dateToSerial(d);
+  }
+  return NaN;
+}
+registerFunction("TODAY", () => {
+  return dateToSerial(/* @__PURE__ */ new Date());
+});
+registerFunction("NOW", () => {
+  const now = /* @__PURE__ */ new Date();
+  const serial = dateToSerial(now);
+  const fraction = (now.getHours() * 3600 + now.getMinutes() * 60 + now.getSeconds()) / 86400;
+  return serial + fraction;
+});
+registerFunction("DATE", (args) => {
+  const flat = args.flat();
+  const year = Number(flat[0]);
+  const month = Number(flat[1]) - 1;
+  const day = Number(flat[2]);
+  if (isNaN(year) || isNaN(month) || isNaN(day)) return "#VALUE!";
+  return dateToSerial(new Date(year, month, day));
+});
+registerFunction("YEAR", (args) => {
+  const serial = toSerial(args.flat()[0]);
+  if (isNaN(serial)) return "#VALUE!";
+  return serialToDate(serial).getFullYear();
+});
+registerFunction("MONTH", (args) => {
+  const serial = toSerial(args.flat()[0]);
+  if (isNaN(serial)) return "#VALUE!";
+  return serialToDate(serial).getMonth() + 1;
+});
+registerFunction("DAY", (args) => {
+  const serial = toSerial(args.flat()[0]);
+  if (isNaN(serial)) return "#VALUE!";
+  return serialToDate(serial).getDate();
+});
+registerFunction("HOUR", (args) => {
+  const val = Number(args.flat()[0]);
+  if (isNaN(val)) return "#VALUE!";
+  const fraction = val % 1;
+  return Math.floor(fraction * 24);
+});
+registerFunction("MINUTE", (args) => {
+  const val = Number(args.flat()[0]);
+  if (isNaN(val)) return "#VALUE!";
+  const fraction = val % 1;
+  return Math.floor(fraction * 24 * 60 % 60);
+});
+registerFunction("SECOND", (args) => {
+  const val = Number(args.flat()[0]);
+  if (isNaN(val)) return "#VALUE!";
+  const fraction = val % 1;
+  return Math.floor(fraction * 24 * 3600 % 60);
+});
+registerFunction("WEEKDAY", (args) => {
+  const flat = args.flat();
+  const serial = toSerial(flat[0]);
+  if (isNaN(serial)) return "#VALUE!";
+  const day = serialToDate(serial).getDay();
+  const type = Number(flat[1] ?? 1);
+  if (type === 1) return day + 1;
+  if (type === 2) return day === 0 ? 7 : day;
+  return day;
+});
+registerFunction("DATEDIF", (args) => {
+  const flat = args.flat();
+  const startSerial = toSerial(flat[0]);
+  const endSerial = toSerial(flat[1]);
+  const unit = String(flat[2] ?? "D").toUpperCase();
+  if (isNaN(startSerial) || isNaN(endSerial)) return "#VALUE!";
+  const startDate = serialToDate(startSerial);
+  const endDate = serialToDate(endSerial);
+  if (unit === "D") return Math.floor(endSerial - startSerial);
+  if (unit === "M") {
+    return (endDate.getFullYear() - startDate.getFullYear()) * 12 + (endDate.getMonth() - startDate.getMonth());
+  }
+  if (unit === "Y") return endDate.getFullYear() - startDate.getFullYear();
+  return "#VALUE!";
+});
+registerFunction("EDATE", (args) => {
+  const flat = args.flat();
+  const serial = toSerial(flat[0]);
+  const months = Number(flat[1]);
+  if (isNaN(serial) || isNaN(months)) return "#VALUE!";
+  const d = serialToDate(serial);
+  d.setMonth(d.getMonth() + months);
+  return dateToSerial(d);
+});
+
+// src/engine/formula/functions/info.ts
+registerFunction("ISBLANK", (args) => {
+  const val = args.flat()[0];
+  return val === null || val === void 0 || val === "";
+});
+registerFunction("ISNUMBER", (args) => {
+  return typeof args.flat()[0] === "number";
+});
+registerFunction("ISTEXT", (args) => {
+  const val = args.flat()[0];
+  return typeof val === "string" && !val.startsWith("#");
+});
+registerFunction("ISERROR", (args) => {
+  const val = args.flat()[0];
+  return typeof val === "string" && val.startsWith("#");
+});
+registerFunction("ISLOGICAL", (args) => {
+  return typeof args.flat()[0] === "boolean";
+});
+registerFunction("TYPE", (args) => {
+  const val = args.flat()[0];
+  if (typeof val === "number") return 1;
+  if (typeof val === "string") return val.startsWith("#") ? 16 : 2;
+  if (typeof val === "boolean") return 4;
+  return 1;
+});
 
 // src/engine/formula/evaluator.ts
 function evaluateAST(node, getCellValue, getRangeValues) {