@particle-academy/fancy-sheets 0.1.2 → 0.3.0

package/dist/index.js

@@ -121,12 +121,41 @@ function lexFormula(input) {
     if (ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch === "_") {
       const pos = i;
       i++;
-      while (i < len && (input[i] >= "A" && input[i] <= "Z" || input[i] >= "a" && input[i] <= "z" || input[i] >= "0" && input[i] <= "9" || input[i] === "_")) i++;
-      const word = input.slice(pos, i);
+      while (i < len && (input[i] >= "A" && input[i] <= "Z" || input[i] >= "a" && input[i] <= "z" || input[i] >= "0" && input[i] <= "9" || input[i] === "_" || input[i] === " ")) {
+        if (input[i] === " ") {
+          let lookAhead = i + 1;
+          while (lookAhead < len && input[lookAhead] === " ") lookAhead++;
+          if (lookAhead < len && (input[lookAhead] >= "A" && input[lookAhead] <= "Z" || input[lookAhead] >= "a" && input[lookAhead] <= "z" || input[lookAhead] >= "0" && input[lookAhead] <= "9" || input[lookAhead] === "!")) {
+            i++;
+            continue;
+          }
+          break;
+        }
+        i++;
+      }
+      let word = input.slice(pos, i).trimEnd();
+      i = pos + word.length;
       if (word.toUpperCase() === "TRUE" || word.toUpperCase() === "FALSE") {
         tokens.push({ type: "boolean", value: word.toUpperCase(), position: pos });
         continue;
       }
+      if (i < len && input[i] === "!") {
+        const sheetName = word;
+        i++;
+        const refStart = i;
+        while (i < len && (input[i] >= "A" && input[i] <= "Z" || input[i] >= "a" && input[i] <= "z" || input[i] >= "0" && input[i] <= "9")) i++;
+        const ref1 = input.slice(refStart, i);
+        if (i < len && input[i] === ":") {
+          i++;
+          const ref2Start = i;
+          while (i < len && (input[i] >= "A" && input[i] <= "Z" || input[i] >= "a" && input[i] <= "z" || input[i] >= "0" && input[i] <= "9")) i++;
+          const ref2 = input.slice(ref2Start, i);
+          tokens.push({ type: "sheetRangeRef", value: sheetName + "!" + ref1 + ":" + ref2, position: pos });
+        } else {
+          tokens.push({ type: "sheetCellRef", value: sheetName + "!" + ref1.toUpperCase(), position: pos });
+        }
+        continue;
+      }
       if (i < len && input[i] === ":") {
         const colonPos = i;
         i++;
@@ -270,6 +299,19 @@ function parseFormula(tokens) {
       const parts = t.value.split(":");
       return { type: "rangeRef", start: parts[0], end: parts[1] };
     }
+    if (t.type === "sheetCellRef") {
+      advance();
+      const bangIdx = t.value.indexOf("!");
+      return { type: "sheetCellRef", sheet: t.value.slice(0, bangIdx), address: t.value.slice(bangIdx + 1).toUpperCase() };
+    }
+    if (t.type === "sheetRangeRef") {
+      advance();
+      const bangIdx = t.value.indexOf("!");
+      const sheetName = t.value.slice(0, bangIdx);
+      const rangePart = t.value.slice(bangIdx + 1);
+      const parts = rangePart.split(":");
+      return { type: "sheetRangeRef", sheet: sheetName, start: parts[0].toUpperCase(), end: parts[1].toUpperCase() };
+    }
     if (t.type === "function") {
       const name = advance().value;
       expect("paren", "(");
@@ -354,6 +396,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) => {
@@ -375,6 +516,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) {
@@ -399,9 +642,410 @@ 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) {
+function evaluateAST(node, getCellValue, getRangeValues, ctx) {
   switch (node.type) {
     case "number":
       return node.value;
@@ -411,9 +1055,19 @@ function evaluateAST(node, getCellValue, getRangeValues) {
       return node.value;
     case "cellRef":
       return getCellValue(node.address);
-    case "rangeRef":
+    case "rangeRef": {
       const vals = getRangeValues(node.start, node.end);
       return vals[0] ?? null;
+    }
+    case "sheetCellRef": {
+      if (!ctx?.getSheetCellValue) return "#REF!";
+      return ctx.getSheetCellValue(node.sheet, node.address);
+    }
+    case "sheetRangeRef": {
+      if (!ctx?.getSheetRangeValues) return "#REF!";
+      const vals = ctx.getSheetRangeValues(node.sheet, node.start, node.end);
+      return vals[0] ?? null;
+    }
     case "functionCall": {
       const entry = getFunction(node.name);
       if (!entry) return `#NAME?`;
@@ -421,7 +1075,11 @@ function evaluateAST(node, getCellValue, getRangeValues) {
         if (arg.type === "rangeRef") {
           return getRangeValues(arg.start, arg.end);
         }
-        const val = evaluateAST(arg, getCellValue, getRangeValues);
+        if (arg.type === "sheetRangeRef") {
+          if (!ctx?.getSheetRangeValues) return ["#REF!"];
+          return ctx.getSheetRangeValues(arg.sheet, arg.start, arg.end);
+        }
+        const val = evaluateAST(arg, getCellValue, getRangeValues, ctx);
         return [val];
       });
       try {
@@ -431,8 +1089,8 @@ function evaluateAST(node, getCellValue, getRangeValues) {
       }
     }
     case "binaryOp": {
-      const left = evaluateAST(node.left, getCellValue, getRangeValues);
-      const right = evaluateAST(node.right, getCellValue, getRangeValues);
+      const left = evaluateAST(node.left, getCellValue, getRangeValues, ctx);
+      const right = evaluateAST(node.right, getCellValue, getRangeValues, ctx);
       const lNum = typeof left === "number" ? left : Number(left);
       const rNum = typeof right === "number" ? right : Number(right);
       switch (node.operator) {
@@ -465,7 +1123,7 @@ function evaluateAST(node, getCellValue, getRangeValues) {
       }
     }
     case "unaryOp": {
-      const operand = evaluateAST(node.operand, getCellValue, getRangeValues);
+      const operand = evaluateAST(node.operand, getCellValue, getRangeValues, ctx);
       const num = typeof operand === "number" ? operand : Number(operand);
       if (isNaN(num)) return "#VALUE!";
       return node.operator === "-" ? -num : num;
@@ -579,7 +1237,7 @@ function getRecalculationOrder(graph) {
 function recalculateWorkbook(workbook) {
   return {
     ...workbook,
-    sheets: workbook.sheets.map(recalculateSheet)
+    sheets: workbook.sheets.map((s) => recalculateSheet(s, workbook.sheets))
   };
 }
 function createInitialState(data) {
@@ -609,7 +1267,7 @@ function pushUndo(state) {
   if (stack.length > 50) stack.shift();
   return { undoStack: stack, redoStack: [] };
 }
-function recalculateSheet(sheet) {
+function recalculateSheet(sheet, allSheets) {
   const graph = buildDependencyGraph(sheet.cells);
   if (graph.size === 0) return sheet;
   const circular = detectCircularRefs(graph);
@@ -625,6 +1283,28 @@ function recalculateSheet(sheet) {
     const addresses = expandRange(startAddr, endAddr);
     return addresses.map(getCellValue);
   };
+  const getSheetCellValue = (sheetName, addr) => {
+    if (!allSheets) return "#REF!";
+    const target = allSheets.find((s) => s.name === sheetName || s.id === sheetName);
+    if (!target) return "#REF!";
+    const c = target.cells[addr];
+    if (!c) return null;
+    if (c.formula && c.computedValue !== void 0) return c.computedValue;
+    return c.value;
+  };
+  const getSheetRangeValues = (sheetName, startAddr, endAddr) => {
+    if (!allSheets) return [];
+    const target = allSheets.find((s) => s.name === sheetName || s.id === sheetName);
+    if (!target) return [];
+    const addresses = expandRange(startAddr, endAddr);
+    return addresses.map((a) => {
+      const c = target.cells[a];
+      if (!c) return null;
+      if (c.formula && c.computedValue !== void 0) return c.computedValue;
+      return c.value;
+    });
+  };
+  const ctx = { getSheetCellValue, getSheetRangeValues };
   for (const addr of order) {
     const cell = cells[addr];
     if (!cell?.formula) continue;
@@ -635,7 +1315,7 @@ function recalculateSheet(sheet) {
     try {
       const tokens = lexFormula(cell.formula);
       const ast = parseFormula(tokens);
-      const result = evaluateAST(ast, getCellValue, getRangeValues);
+      const result = evaluateAST(ast, getCellValue, getRangeValues, ctx);
       cells[addr] = { ...cell, computedValue: result };
     } catch {
       cells[addr] = { ...cell, computedValue: "#ERROR!" };
@@ -660,7 +1340,7 @@ function reducer(state, action) {
       if (existing?.format) cellData.format = existing.format;
       const workbook = updateActiveSheet(state, (s) => {
         const updated = { ...s, cells: { ...s.cells, [action.address]: cellData } };
-        return recalculateSheet(updated);
+        return recalculateSheet(updated, state.workbook.sheets);
       });
       return { ...state, workbook, ...history };
     }
@@ -816,6 +1496,20 @@ function reducer(state, action) {
         selection: { activeCell: "A1", ranges: [{ start: "A1", end: "A1" }] },
         editingCell: null
       };
+    case "SET_FROZEN_ROWS": {
+      const workbook = updateActiveSheet(state, (s) => ({
+        ...s,
+        frozenRows: Math.max(0, action.count)
+      }));
+      return { ...state, workbook };
+    }
+    case "SET_FROZEN_COLS": {
+      const workbook = updateActiveSheet(state, (s) => ({
+        ...s,
+        frozenCols: Math.max(0, action.count)
+      }));
+      return { ...state, workbook };
+    }
     case "UNDO": {
       if (state.undoStack.length === 0) return state;
       const prev = state.undoStack[state.undoStack.length - 1];
@@ -860,6 +1554,8 @@ function useSpreadsheetStore(initialData) {
     addSheet: () => dispatch({ type: "ADD_SHEET" }),
     renameSheet: (sheetId, name) => dispatch({ type: "RENAME_SHEET", sheetId, name }),
     deleteSheet: (sheetId) => dispatch({ type: "DELETE_SHEET", sheetId }),
+    setFrozenRows: (count) => dispatch({ type: "SET_FROZEN_ROWS", count }),
+    setFrozenCols: (count) => dispatch({ type: "SET_FROZEN_COLS", count }),
     setActiveSheet: (sheetId) => dispatch({ type: "SET_ACTIVE_SHEET", sheetId }),
     undo: () => dispatch({ type: "UNDO" }),
     redo: () => dispatch({ type: "REDO" }),
@@ -948,11 +1644,49 @@ function RowHeader({ rowIndex }) {
   );
 }
 RowHeader.displayName = "RowHeader";
+var EXCEL_EPOCH2 = new Date(1899, 11, 30).getTime();
+function serialToDateStr(serial) {
+  const d = new Date(EXCEL_EPOCH2 + Math.floor(serial) * 864e5);
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function serialToDateTimeStr(serial) {
+  const date = serialToDateStr(serial);
+  const fraction = serial % 1;
+  const totalSeconds = Math.round(fraction * 86400);
+  const h = String(Math.floor(totalSeconds / 3600)).padStart(2, "0");
+  const min = String(Math.floor(totalSeconds % 3600 / 60)).padStart(2, "0");
+  const s = String(totalSeconds % 60).padStart(2, "0");
+  return `${date} ${h}:${min}:${s}`;
+}
+function isDateFormula(formula) {
+  if (!formula) return false;
+  const f = formula.toUpperCase();
+  return /^(TODAY|NOW|DATE|EDATE)\b/.test(f) || /\b(TODAY|NOW|DATE|EDATE)\s*\(/.test(f);
+}
+function formatCellValue(val, cell) {
+  if (val === null || val === void 0) return "";
+  const fmt = cell?.format?.displayFormat;
+  if (typeof val === "number") {
+    if (fmt === "date") return serialToDateStr(val);
+    if (fmt === "datetime") return serialToDateTimeStr(val);
+    if (fmt === "percentage") return (val * 100).toFixed(1) + "%";
+    if (fmt === "currency") return "$" + val.toFixed(2);
+    if (fmt === "auto" || !fmt) {
+      if (cell?.formula && isDateFormula(cell.formula)) {
+        return val % 1 === 0 ? serialToDateStr(val) : serialToDateTimeStr(val);
+      }
+    }
+  }
+  if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
+  return String(val);
+}
 function getCellDisplayValue2(cell) {
   if (!cell) return "";
-  if (cell.formula && cell.computedValue !== void 0) return String(cell.computedValue ?? "");
-  if (cell.value === null) return "";
-  return String(cell.value);
+  const val = cell.formula && cell.computedValue !== void 0 ? cell.computedValue : cell.value;
+  return formatCellValue(val, cell);
 }
 var Cell = memo(function Cell2({ address, row, col }) {
   const {
@@ -1248,13 +1982,42 @@ function SpreadsheetGrid({ className }) {
       children: [
         /* @__PURE__ */ jsx("div", { className: "sticky top-0 z-10", children: /* @__PURE__ */ jsx(ColumnHeaders, {}) }),
         /* @__PURE__ */ jsxs("div", { className: "relative", children: [
-          Array.from({ length: rowCount }, (_, rowIdx) => /* @__PURE__ */ jsxs("div", { className: "flex", children: [
-            /* @__PURE__ */ jsx("div", { className: "sticky left-0 z-[5]", children: /* @__PURE__ */ jsx(RowHeader, { rowIndex: rowIdx }) }),
-            Array.from({ length: columnCount }, (_2, colIdx) => {
-              const addr = toAddress(rowIdx, colIdx);
-              return /* @__PURE__ */ jsx(Cell, { address: addr, row: rowIdx, col: colIdx }, addr);
-            })
-          ] }, rowIdx)),
+          Array.from({ length: rowCount }, (_, rowIdx) => {
+            const isFrozenRow = rowIdx < activeSheet.frozenRows;
+            return /* @__PURE__ */ jsxs(
+              "div",
+              {
+                className: "flex",
+                style: isFrozenRow ? {
+                  position: "sticky",
+                  top: rowHeight + rowIdx * rowHeight,
+                  zIndex: 8,
+                  backgroundColor: "inherit"
+                } : void 0,
+                children: [
+                  /* @__PURE__ */ jsx("div", { className: "sticky left-0 z-[5]", children: /* @__PURE__ */ jsx(RowHeader, { rowIndex: rowIdx }) }),
+                  Array.from({ length: columnCount }, (_2, colIdx) => {
+                    const addr = toAddress(rowIdx, colIdx);
+                    const isFrozenCol = colIdx < activeSheet.frozenCols;
+                    return /* @__PURE__ */ jsx(
+                      "div",
+                      {
+                        style: isFrozenCol ? {
+                          position: "sticky",
+                          left: 48 + Array.from({ length: colIdx }, (_3, c) => getColumnWidth(c)).reduce((a, b) => a + b, 0),
+                          zIndex: isFrozenRow ? 9 : 6,
+                          backgroundColor: "inherit"
+                        } : void 0,
+                        children: /* @__PURE__ */ jsx(Cell, { address: addr, row: rowIdx, col: colIdx })
+                      },
+                      addr
+                    );
+                  })
+                ]
+              },
+              rowIdx
+            );
+          }),
           /* @__PURE__ */ jsx(SelectionOverlay, {}),
           editorPosition && /* @__PURE__ */ jsx(
             "div",