@pixerate/editor 0.21.0 → 0.23.0

package/dist/{chunk-JYRIOFEN.cjs → chunk-RIKBJLS2.cjs}

@@ -53,7 +53,7 @@ function tokenizeFormula(formula) {
       continue;
     }
     if (char === "#") {
-      const match = /^#(?:REF!|DIV\/0!|VALUE!|NAME\?|N\/A|NUM!|CYCLE!|ERROR!)/.exec(input.slice(i));
+      const match = /^#(?:REF!|DIV\/0!|VALUE!|NAME\?|N\/A|NUM!|CYCLE!|ERROR!|SPILL!|CALC!)/.exec(input.slice(i));
       if (!match) {
         throw new Error(`Unexpected character '#' at position ${i + offset}`);
       }
@@ -104,7 +104,7 @@ function tokenizeFormula(formula) {
       i += 2;
       continue;
     }
-    if (["+", "-", "*", "/", "^", "&", "=", "<", ">"].includes(char)) {
+    if (["+", "-", "*", "/", "^", "&", "=", "<", ">", "@"].includes(char)) {
       tokens.push({ type: "OPERATOR", value: char, position: i + offset });
       i++;
       continue;
@@ -144,6 +144,11 @@ function tokenizeFormula(formula) {
         continue;
       }
       if (/^\$?[A-Za-z]+\$?[0-9]+$/.test(rawWord)) {
+        if (input[i] === "#") {
+          i++;
+          tokens.push({ type: "SPILL_REF", value: upper.replace(/\$/g, ""), position: start + offset });
+          continue;
+        }
         tokens.push({
           type: "CELL_REF",
           value: upper.replace(/\$/g, ""),
@@ -265,7 +270,7 @@ var FormulaParser = (_class = class {
     return expr;
   }
   unary() {
-    if (this.matchOperator("-", "+")) {
+    if (this.matchOperator("-", "+", "@")) {
       const op = this.previous().value;
       const argument = this.unary();
       return { type: "UnaryOp", op, argument };
@@ -304,6 +309,11 @@ var FormulaParser = (_class = class {
       this.advance();
       return parseRange(token.value);
     }
+    if (token.type === "SPILL_REF") {
+      this.advance();
+      const parsed = parseCellReference(token.value);
+      return { type: "SpillRef", ref: token.value, col: parsed.col, row: parsed.row };
+    }
     if (token.type === "PROPERTY_REF") {
       this.advance();
       return {
@@ -329,7 +339,7 @@ var FormulaParser = (_class = class {
           args
         };
       }
-      return { type: "Literal", value: "#NAME?" };
+      return { type: "Name", name };
     }
     if (this.match("LPAREN")) {
       const expr = this.expression();
@@ -391,7 +401,9 @@ var FORMULA_ERRORS = /* @__PURE__ */ new Set([
   "#N/A",
   "#NUM!",
   "#CYCLE!",
-  "#ERROR!"
+  "#ERROR!",
+  "#SPILL!",
+  "#CALC!"
 ]);
 function isFormulaError(value) {
   return typeof value === "string" && FORMULA_ERRORS.has(value);
@@ -402,9 +414,7 @@ function toNumber(value) {
   if (isBlank(value)) return 0;
   if (typeof value === "boolean") return value ? 1 : 0;
   if (typeof value === "number") return value;
-  const trimmed = String(value).trim();
-  const num = trimmed === "" ? NaN : Number(trimmed);
-  return isNaN(num) ? "#VALUE!" : num;
+  return _nullishCoalesce(parseNumberText(String(value)), () => ( "#VALUE!"));
 }
 function toBoolean(value) {
   if (isFormulaError(value)) return value;
@@ -416,7 +426,26 @@ function toBoolean(value) {
   if (upper === "FALSE") return false;
   return "#VALUE!";
 }
-var toText = (value) => isBlank(value) ? "" : typeof value === "boolean" ? value ? "TRUE" : "FALSE" : String(value);
+var toText = (value) => isBlank(value) ? "" : typeof value === "boolean" ? value ? "TRUE" : "FALSE" : typeof value === "number" ? numberToText(value) : String(value);
+function numberToText(n) {
+  if (n === 0 || !Number.isFinite(n)) return "0";
+  const a = Math.abs(n);
+  if ((a < 1e-9 || a >= 1e15) && Math.round(a) !== a || a >= 1e15) return sciText(n, 15);
+  let mag = Math.floor(Math.log10(a));
+  if (a >= Math.pow(10, mag + 1)) mag++;
+  const decimals = Math.min(Math.max(14 - mag, 0), 30);
+  return trimDecimal(n.toFixed(decimals));
+}
+function trimDecimal(s) {
+  if (!s.includes(".")) return s;
+  const t = s.replace(/0+$/, "").replace(/\.$/, "");
+  return t === "-0" ? "0" : t;
+}
+function sciText(n, sig) {
+  const [mantissa, exp] = n.toExponential(Math.max(sig - 1, 0)).split("e");
+  const e = Number(exp);
+  return `${trimDecimal(mantissa)}E${e < 0 ? "-" : "+"}${String(Math.abs(e)).padStart(2, "0")}`;
+}
 function numericValue(value) {
   if (typeof value === "number") return Number.isFinite(value) ? value : null;
   if (typeof value !== "string" || FORMULA_ERRORS.has(value)) return null;
@@ -429,17 +458,68 @@ function normalizeValue(value) {
   const num = typeof value === "string" ? numericValue(value) : null;
   return num === null ? value : num;
 }
+var ERROR_ORDER = ["#NULL!", "#DIV/0!", "#VALUE!", "#REF!", "#NAME?", "#NUM!", "#N/A", "#SPILL!", "#CALC!", "#CYCLE!", "#ERROR!"];
+function valueRank(value) {
+  if (isBlank(value)) return 4;
+  if (typeof value === "number") return 0;
+  if (typeof value === "boolean") return 2;
+  if (typeof value === "string" && FORMULA_ERRORS.has(value)) return 3;
+  return 1;
+}
+function compareNumbers(a, b) {
+  if (a === b) return 0;
+  if (Math.abs(a - b) > Math.max(Math.abs(a), Math.abs(b)) * 1e-13) return a < b ? -1 : 1;
+  const round15 = (x2) => !Number.isFinite(x2) || x2 === 0 ? x2 : Number(x2.toExponential(14));
+  const x = round15(a);
+  const y = round15(b);
+  return x < y ? -1 : x > y ? 1 : 0;
+}
+function compareText(a, b) {
+  const x = a.toLowerCase();
+  const y = b.toLowerCase();
+  return x < y ? -1 : x > y ? 1 : 0;
+}
 function compareValues(left, right) {
-  const rank = (v) => typeof v === "boolean" ? 2 : typeof v === "string" ? 1 : 0;
-  const l = isBlank(left) ? typeof right === "string" ? "" : 0 : left;
-  const r = isBlank(right) ? typeof l === "string" ? "" : 0 : right;
-  if (rank(l) !== rank(r)) return rank(l) - rank(r);
-  if (typeof l === "string") {
-    const a = l.toLowerCase();
-    const b = r.toLowerCase();
-    return a < b ? -1 : a > b ? 1 : 0;
-  }
-  return Number(l) - Number(r);
+  const lRank = valueRank(left);
+  const rRank = valueRank(right);
+  if (lRank === 4 || rRank === 4) {
+    if (lRank === rRank) return 0;
+    const blankFirst = lRank === 4;
+    const other = blankFirst ? right : left;
+    const otherRank = blankFirst ? rRank : lRank;
+    let cmp;
+    if (otherRank === 0) cmp = compareNumbers(0, other);
+    else if (otherRank === 1) cmp = String(other) === "" ? 0 : -1;
+    else if (otherRank === 2) cmp = other ? -1 : 0;
+    else return lRank - rRank;
+    return blankFirst ? cmp : -cmp;
+  }
+  if (lRank === 1 && rRank === 1) {
+    const a = String(left);
+    const b = String(right);
+    const ta = isoDateTime(a);
+    const tb = ta === null ? null : isoDateTime(b);
+    if (ta !== null && tb !== null) return Math.sign(ta - tb);
+    return compareText(a, b);
+  }
+  if (lRank === 0 && rRank === 1 || lRank === 1 && rRank === 0) {
+    const date = parseIsoDate(lRank === 1 ? left : right);
+    if (date) {
+      const serial = dateToSerial(date);
+      return lRank === 0 ? compareNumbers(left, serial) : compareNumbers(serial, right);
+    }
+  }
+  if (lRank !== rRank) return lRank - rRank;
+  if (lRank === 0) return compareNumbers(left, right);
+  if (lRank === 2) return Number(left) - Number(right);
+  return Math.sign(ERROR_ORDER.indexOf(left) - ERROR_ORDER.indexOf(right));
+}
+function sortCompareValues(left, right) {
+  const lBlank = isBlank(left);
+  const rBlank = isBlank(right);
+  if (lBlank || rBlank) return lBlank === rBlank ? 0 : lBlank ? 1 : -1;
+  if (isFormulaError(left) && isFormulaError(right)) return 0;
+  return compareValues(left, right);
 }
 function roundHalfAwayFromZero(value, decimals) {
   const factor = Math.pow(10, decimals);
@@ -505,6 +585,20 @@ function toDate(value) {
   }
   return null;
 }
+var ISO_DATE = /^(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T](\d{1,2}):(\d{2})(?::(\d{2}))?)?$/;
+function parseIsoDate(value) {
+  if (typeof value !== "string" || value.length < 8 || value.length > 19) return null;
+  const iso = ISO_DATE.exec(value.trim());
+  if (!iso) return null;
+  const [, y, m, d, hh = "0", mm = "0", ss = "0"] = iso;
+  const date = new Date(Number(y), Number(m) - 1, Number(d), Number(hh), Number(mm), Number(ss));
+  return date.getMonth() === Number(m) - 1 && date.getDate() === Number(d) ? date : null;
+}
+var isoDateHasTime = (value) => /[ T]\d/.test(value.trim());
+function isoDateTime(value) {
+  if (value.length < 8 || value.charCodeAt(4) !== 45) return null;
+  return _nullishCoalesce(_optionalChain([parseIsoDate, 'call', _2 => _2(value), 'optionalAccess', _3 => _3.getTime, 'call', _4 => _4()]), () => ( null));
+}
 function dateToSerial(date) {
   const utc = Date.UTC(
     date.getFullYear(),
@@ -534,6 +628,282 @@ var daysBetween = (start, end) => Math.round(
   (Date.UTC(end.getFullYear(), end.getMonth(), end.getDate()) - Date.UTC(start.getFullYear(), start.getMonth(), start.getDate())) / MS_PER_DAY
 );
 
+// src/spreadsheet/formula/parse-input.ts
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function daysFromCivil(year, month, day) {
+  const y = month <= 2 ? year - 1 : year;
+  const era = Math.floor((y >= 0 ? y : y - 399) / 400);
+  const yoe = y - era * 400;
+  const doy = Math.floor((153 * (month > 2 ? month - 3 : month + 9) + 2) / 5) + day - 1;
+  const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+  return era * 146097 + doe - 719468;
+}
+var isLeapYear = (y) => y % 4 === 0 && y % 100 !== 0 || y % 400 === 0;
+function daysInMonth(year, month) {
+  if (month === 2) return isLeapYear(year) ? 29 : 28;
+  if ([4, 6, 9, 11].includes(month)) return 30;
+  return month >= 1 && month <= 12 ? 31 : 0;
+}
+var daysInMonth1900 = (year, month) => year === 1900 && month === 2 ? 29 : daysInMonth(year, month);
+var UNIX_1899_12_30 = -25569;
+var MAX_SERIAL_1900 = 2958465;
+function serialFromYmd(year, month, day) {
+  if (![year, month, day].every(Number.isSafeInteger)) return null;
+  let y = year >= 0 && year < 1900 ? year + 1900 : year;
+  const m0 = month - 1;
+  y += Math.floor(m0 / 12);
+  const m = (m0 % 12 + 12) % 12 + 1;
+  if (y < 1900 || y > 9999) return null;
+  const first = daysFromCivil(y, m, 1) - UNIX_1899_12_30 - (y === 1900 && m <= 2 ? 1 : 0);
+  const serial = first + day - 1;
+  return serial >= 0 && serial <= MAX_SERIAL_1900 ? serial : null;
+}
+var timeFraction = (h, m, s) => (h * 3600 + m * 60 + s) / 86400;
+var currentYear = () => (/* @__PURE__ */ new Date()).getFullYear();
+function parseCellInput(input) {
+  if (input === "") return { value: "", type: "empty" };
+  if (input.startsWith("'")) return { value: input.slice(1), type: "text" };
+  const t = input.trim();
+  const upper = t.toUpperCase();
+  if (upper === "TRUE") return { value: true, type: "boolean" };
+  if (upper === "FALSE") return { value: false, type: "boolean" };
+  if (FORMULA_ERRORS.has(upper)) return { value: upper, type: "error" };
+  const numeric = parseNumeric(t);
+  if (numeric) {
+    if (numeric.kind === "date") {
+      const iso = isoText(numeric.date);
+      if (iso !== null) {
+        return { value: iso, type: "date", numberFormat: numeric.format, formatKind: "date", cellFormat: "date" };
+      }
+    } else {
+      const formatKind = numeric.kind === "time" ? "time" : formatKindOf(numeric.format);
+      return {
+        value: normalizeZero(numeric.value),
+        type: "number",
+        ...numeric.format ? { numberFormat: numeric.format } : {},
+        ...formatKind ? { formatKind } : {},
+        ...formatKind && formatKind !== "time" ? { cellFormat: formatKind } : {}
+      };
+    }
+  }
+  return { value: input, type: "text" };
+}
+function parseNumberText(text) {
+  const numeric = parseNumeric(text.trim());
+  if (!numeric) return null;
+  if (numeric.kind !== "date") return normalizeZero(numeric.value);
+  const { year, month, day, time = 0 } = numeric.date;
+  const serial = serialFromYmd(year, month, day);
+  return serial === null ? null : serial + time;
+}
+var normalizeZero = (n) => n === 0 ? 0 : n;
+function formatKindOf(format) {
+  if (!format) return void 0;
+  if (format.includes("$")) return "currency";
+  if (format.includes("%")) return "percentage";
+  return "number";
+}
+var pad2 = (n, width = 2) => String(n).padStart(width, "0");
+function isoText({ year, month, day, time }) {
+  if (day > daysInMonth(year, month)) return null;
+  const date = `${pad2(year, 4)}-${pad2(month)}-${pad2(day)}`;
+  if (time === void 0) return date;
+  let seconds = Math.round(time * 86400);
+  if (seconds >= 86400) seconds = 86399;
+  return `${date} ${pad2(Math.floor(seconds / 3600))}:${pad2(Math.floor(seconds / 60) % 60)}:${pad2(seconds % 60)}`;
+}
+function parseNumeric(t) {
+  if (t === "") return null;
+  if (t.startsWith("(") && t.endsWith(")") && t.length >= 2) {
+    const inner = parseNumeric(t.slice(1, -1).trim());
+    if (!inner || inner.kind === "date") return null;
+    return { ...inner, value: -inner.value };
+  }
+  const plain = parsePlain(t);
+  if (plain) return plain;
+  const fraction = parseFraction(t);
+  if (fraction !== null) return { kind: "number", value: fraction, format: "# ?/?" };
+  return parseDateTime(t);
+}
+var startsWithDigitOrDot = (s) => /^[0-9.]/.test(s);
+function parsePlain(t) {
+  let s = t;
+  let neg = false;
+  let currency = false;
+  let percent = false;
+  if (s.startsWith("-")) {
+    neg = true;
+    s = s.slice(1).trimStart();
+  } else if (s.startsWith("+")) {
+    s = s.slice(1).trimStart();
+  }
+  if (s.startsWith("$")) {
+    currency = true;
+    s = s.slice(1).trimStart();
+    if (!neg && s.startsWith("-")) {
+      neg = true;
+      s = s.slice(1);
+    }
+  }
+  if (s.endsWith("%")) {
+    percent = true;
+    s = s.slice(0, -1).trimEnd();
+  }
+  if (s === "") return null;
+  const hasSep = s.includes(",");
+  let digits;
+  if (hasSep) {
+    const dot = s.indexOf(".");
+    const int = dot === -1 ? s : s.slice(0, dot);
+    const frac = dot === -1 ? null : s.slice(dot + 1);
+    const groups = int.split(",");
+    const first = groups[0];
+    if (first === "" || first.length > 3 || groups.slice(1).some((g) => g.length !== 3)) return null;
+    digits = groups.join("") + (frac !== null ? `.${frac}` : "");
+  } else {
+    digits = s;
+  }
+  if (!/^[0-9.eE+-]+$/.test(digits) || !startsWithDigitOrDot(digits)) return null;
+  if (!/^(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(digits)) return null;
+  let n = Number(digits);
+  if (!Number.isFinite(n)) return null;
+  const sci = /[eE]/.test(digits);
+  if (percent) n /= 100;
+  if (neg) n = -n;
+  const hasDot = digits.includes(".");
+  const format = currency ? hasDot ? '"$"#,##0.00' : '"$"#,##0' : percent ? hasDot ? "0.00%" : "0%" : sci ? "0.00E+00" : hasSep ? hasDot ? "#,##0.00" : "#,##0" : void 0;
+  return { kind: "number", value: n, ...format ? { format } : {} };
+}
+var parseDecimal = (s) => /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(s) ? Number(s) : null;
+function parseFraction(t) {
+  const space = t.indexOf(" ");
+  if (space === -1) return null;
+  const whole = t.slice(0, space);
+  const frac = t.slice(space + 1).trim();
+  const neg = whole.startsWith("-");
+  const w = parseDecimal(whole.replace(/^-+/, ""));
+  const slash = frac.indexOf("/");
+  if (w === null || slash === -1) return null;
+  const a = parseDecimal(frac.slice(0, slash));
+  const b = parseDecimal(frac.slice(slash + 1));
+  if (a === null || b === null || b === 0 || !Number.isFinite(w)) return null;
+  const v = w + a / b;
+  return neg ? -v : v;
+}
+function monthFromName(s) {
+  const l = s.toLowerCase();
+  if (l.length < 3) return null;
+  const index = MONTH_NAMES.findIndex((m) => m.toLowerCase().startsWith(l));
+  return index === -1 ? null : index + 1;
+}
+function parseTime(input) {
+  const lower = input.trim().toLowerCase();
+  let body = lower;
+  let pm = null;
+  for (const [suffix, isPm] of [["am", false], ["a", false], ["pm", true], ["p", true]]) {
+    if (lower.endsWith(suffix)) {
+      body = lower.slice(0, -suffix.length).trim();
+      pm = isPm;
+      break;
+    }
+  }
+  const parts = body.split(":");
+  if (parts.length === 1 && pm === null) return null;
+  if (parts.length > 3 || parts.some((p) => p === "")) return null;
+  const num = (p) => p === void 0 ? 0 : parseDecimal(p);
+  let h = num(parts[0]);
+  const m = num(parts[1]);
+  const s = num(parts[2]);
+  if (h === null || m === null || s === null) return null;
+  if (m >= 60 || s >= 60 || h < 0 || m < 0 || s < 0) return null;
+  if (pm !== null) {
+    if (h > 12) return null;
+    if (h === 12) h = 0;
+    if (pm) h += 12;
+  } else if (h >= 1e4) {
+    return null;
+  }
+  return { fraction: timeFraction(h, m, s), seconds: parts.length === 3, ampm: pm !== null };
+}
+var expandYear = (text, y) => text.length <= 2 ? y < 30 ? 2e3 + y : 1900 + y : y;
+function validYmd(year, month, day) {
+  if (month < 1 || month > 12 || day < 1 || year < 1900 || year > 9999) return null;
+  if (day > daysInMonth1900(year, month)) return null;
+  return { year, month, day };
+}
+function parseDate(input) {
+  const t = input.trim().replace(/,+$/, "");
+  const num = (s) => /^[+-]?\d+$/.test(s.trim()) ? Number(s.trim()) : null;
+  const withFormat = (date, format) => date ? { date, format } : null;
+  const parts = t.split(/[/.-]/);
+  if (parts.length === 3) {
+    const [a, b, c] = parts.map((p) => p.trim());
+    if (a.length === 4) {
+      const [y2, m2, d2] = [num(a), num(b), num(c)];
+      if (y2 !== null && m2 !== null && d2 !== null) return withFormat(validYmd(y2, m2, d2), "yyyy-mm-dd");
+    }
+    {
+      const [m2, d2, y2] = [num(a), num(b), num(c)];
+      if (m2 !== null && d2 !== null && y2 !== null) return withFormat(validYmd(expandYear(c, y2), m2, d2), "m/d/yyyy");
+    }
+    const [d, m, y] = [num(a), monthFromName(b), num(c)];
+    if (d !== null && m !== null && y !== null) return withFormat(validYmd(expandYear(c, y), m, d), "d-mmm-yy");
+  }
+  if (parts.length === 2) {
+    const [a, b] = parts.map((p) => p.trim());
+    const [x, y] = [num(a), num(b)];
+    if (x !== null && y !== null) {
+      if (x >= 1 && x <= 12 && y >= 1 && y <= 31) return withFormat(validYmd(currentYear(), x, y), "d-mmm");
+      if (x >= 1 && x <= 12 && b.length === 4) return withFormat(validYmd(y, x, 1), "mmm-yy");
+    }
+    const dayA = num(a);
+    const monthB = monthFromName(b);
+    if (dayA !== null && monthB !== null) return withFormat(validYmd(currentYear(), monthB, dayA), "d-mmm");
+    const monthA = monthFromName(a);
+    const yearB = num(b);
+    if (monthA !== null && yearB !== null) return withFormat(validYmd(expandYear(b, yearB), monthA, 1), "mmm-yy");
+  }
+  const words = t.split(/[ ,]/).filter((w) => w !== "");
+  if (words.length === 3) {
+    const [w0, w1, w2] = words;
+    let [m, d, y] = [monthFromName(w0), num(w1), num(w2)];
+    if (m !== null && d !== null && y !== null) return withFormat(validYmd(expandYear(w2, y), m, d), "d-mmm-yy");
+    [d, m, y] = [num(w0), monthFromName(w1), num(w2)];
+    if (d !== null && m !== null && y !== null) return withFormat(validYmd(expandYear(w2, y), m, d), "d-mmm-yy");
+  }
+  return null;
+}
+function parseDateTime(t) {
+  const time = parseTime(t);
+  if (time) {
+    const format = time.fraction >= 1 ? "[h]:mm:ss" : time.seconds ? time.ampm ? "h:mm:ss AM/PM" : "h:mm:ss" : time.ampm ? "h:mm AM/PM" : "h:mm";
+    return { kind: "time", value: time.fraction, format };
+  }
+  const date = parseDate(t);
+  if (date) return { kind: "date", date: date.date, format: date.format };
+  for (let i = t.indexOf(" "); i !== -1; i = t.indexOf(" ", i + 1)) {
+    const d = parseDate(t.slice(0, i));
+    const tm = d ? parseTime(t.slice(i + 1)) : null;
+    if (d && tm && tm.fraction < 1) {
+      return { kind: "date", date: { ...d.date, time: tm.fraction }, format: "m/d/yyyy h:mm" };
+    }
+  }
+  return null;
+}
+
 // src/spreadsheet/formula/criteria.ts
 function wildcardToRegExp(pattern) {
   let source = "";
@@ -570,12 +940,17 @@ function parseCriteria(criterion) {
     if (op === "<>") return (value) => !isBlank(value);
     return () => false;
   }
-  const operandNumber = numericValue(operand);
+  const parsed = parseCellInput(operand.trim());
+  const operandNumber = _nullishCoalesce(numericValue(operand), () => ( (parsed.type === "number" ? parsed.value : null)));
+  const operandDate = parsed.type === "date" ? parsed.value : null;
+  const isDateValue = (value) => typeof value === "number" || parseIsoDate(value) !== null;
   const operandUpper = operand.trim().toUpperCase();
   const operandBoolean = operandUpper === "TRUE" ? true : operandUpper === "FALSE" ? false : null;
   if (op === "=" || op === "<>") {
     let equals;
-    if (operandNumber !== null) {
+    if (operandDate !== null) {
+      equals = (value) => isDateValue(value) && compareValues(value, operandDate) === 0;
+    } else if (operandNumber !== null) {
       equals = (value) => numericValue(value) === operandNumber;
     } else if (operandBoolean !== null) {
       equals = (value) => value === operandBoolean || typeof value === "string" && value.trim().toUpperCase() === operandUpper;
@@ -588,6 +963,9 @@ function parseCriteria(criterion) {
     return op === "=" ? (value) => !isFormulaError(value) && equals(value) : (value) => !isFormulaError(value) && !equals(value);
   }
   const test = (cmp) => op === "<" ? cmp < 0 : op === "<=" ? cmp <= 0 : op === ">" ? cmp > 0 : cmp >= 0;
+  if (operandDate !== null) {
+    return (value) => isDateValue(value) && test(compareValues(value, operandDate));
+  }
   if (operandNumber !== null) {
     return (value) => {
       const num = numericValue(value);
@@ -605,6 +983,42 @@ function parseCriteria(criterion) {
 }
 
 // src/spreadsheet/formula/format.ts
+function formatCellDisplay(cell) {
+  if (!cell) return "";
+  if (cell.error) return cell.error;
+  const { value, numberFormat } = cell;
+  if (numberFormat && value !== "" && value !== null && value !== void 0 && typeof value !== "boolean") {
+    if (/^\[h\]/i.test(numberFormat) && typeof value === "number") return formatElapsedHours(value);
+    if (numberFormat === "# ?/?" && typeof value === "number") return formatFraction(value);
+    const formatted = formatValueWithCode(value, numberFormat);
+    if (formatted !== null) return formatted;
+  }
+  return toText(value);
+}
+function formatFraction(value) {
+  const sign = value < 0 ? "-" : "";
+  const abs = Math.abs(value);
+  let whole = Math.floor(abs);
+  const frac = abs - whole;
+  let best = { num: 0, den: 1, err: frac };
+  for (let den = 2; den <= 9; den++) {
+    const num = Math.round(frac * den);
+    const err = Math.abs(frac - num / den);
+    if (err < best.err - 1e-12) best = { num, den, err };
+  }
+  if (best.num === best.den) {
+    whole += 1;
+    best = { num: 0, den: 1, err: 0 };
+  }
+  if (best.num === 0) return `${sign}${whole}`;
+  return `${sign}${whole === 0 ? "" : `${whole} `}${best.num}/${best.den}`;
+}
+function formatElapsedHours(days) {
+  const total = Math.round(Math.abs(days) * 86400);
+  const p = (n) => String(n).padStart(2, "0");
+  const text = `${Math.floor(total / 3600)}:${p(Math.floor(total / 60) % 60)}:${p(total % 60)}`;
+  return days < 0 ? `-${text}` : text;
+}
 function formatValueWithCode(value, format) {
   if (isDateFormat(format)) {
     const date = toDate(value);
@@ -719,7 +1133,7 @@ function splitSections(format) {
 }
 var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
 var DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
-var pad2 = (n) => String(n).padStart(2, "0");
+var pad3 = (n) => String(n).padStart(2, "0");
 function formatDate(date, format) {
   const parts = [];
   for (const token of tokenize(format)) {
@@ -746,30 +1160,30 @@ function formatDate(date, format) {
       return code[0] === code[0].toLowerCase() ? text.toLowerCase() : text;
     }
     if (lower.startsWith("y")) {
-      return lower.length <= 2 ? pad2(date.getFullYear() % 100) : String(date.getFullYear());
+      return lower.length <= 2 ? pad3(date.getFullYear() % 100) : String(date.getFullYear());
     }
     if (lower.startsWith("d")) {
       if (lower.length >= 4) return DAYS[date.getDay()];
       if (lower.length === 3) return DAYS[date.getDay()].slice(0, 3);
-      return lower.length === 2 ? pad2(date.getDate()) : String(date.getDate());
+      return lower.length === 2 ? pad3(date.getDate()) : String(date.getDate());
     }
     if (lower.startsWith("h")) {
       let hours = date.getHours();
       if (twelveHour) hours = hours % 12 || 12;
-      return lower.length >= 2 ? pad2(hours) : String(hours);
+      return lower.length >= 2 ? pad3(hours) : String(hours);
     }
     if (lower.startsWith("s")) {
-      return lower.length >= 2 ? pad2(date.getSeconds()) : String(date.getSeconds());
+      return lower.length >= 2 ? pad3(date.getSeconds()) : String(date.getSeconds());
     }
     const position = codes.findIndex((c) => c.i === index);
-    const prev = _nullishCoalesce(_optionalChain([codes, 'access', _2 => _2[position - 1], 'optionalAccess', _3 => _3.text, 'access', _4 => _4.toLowerCase, 'call', _5 => _5()]), () => ( ""));
-    const next = _nullishCoalesce(_optionalChain([codes, 'access', _6 => _6[position + 1], 'optionalAccess', _7 => _7.text, 'access', _8 => _8.toLowerCase, 'call', _9 => _9()]), () => ( ""));
+    const prev = _nullishCoalesce(_optionalChain([codes, 'access', _5 => _5[position - 1], 'optionalAccess', _6 => _6.text, 'access', _7 => _7.toLowerCase, 'call', _8 => _8()]), () => ( ""));
+    const next = _nullishCoalesce(_optionalChain([codes, 'access', _9 => _9[position + 1], 'optionalAccess', _10 => _10.text, 'access', _11 => _11.toLowerCase, 'call', _12 => _12()]), () => ( ""));
     if (lower.length <= 2 && (prev.startsWith("h") || next.startsWith("s"))) {
-      return lower.length === 2 ? pad2(date.getMinutes()) : String(date.getMinutes());
+      return lower.length === 2 ? pad3(date.getMinutes()) : String(date.getMinutes());
     }
     if (lower.length >= 4) return MONTHS[date.getMonth()];
     if (lower.length === 3) return MONTHS[date.getMonth()].slice(0, 3);
-    return lower.length === 2 ? pad2(date.getMonth() + 1) : String(date.getMonth() + 1);
+    return lower.length === 2 ? pad3(date.getMonth() + 1) : String(date.getMonth() + 1);
   }).join("");
 }
 
@@ -1606,11 +2020,11 @@ var TEXT_FUNCTIONS = [
   {
     name: "TRIM",
     category: "text",
-    description: "Removes leading and trailing spaces.",
+    description: "Removes leading and trailing spaces and collapses runs of inner spaces to one, like Excel.",
     args: [TEXT],
     evaluate: (ctx) => {
       const text = ctx.text(0);
-      return failed(text) ? text : text.trim();
+      return failed(text) ? text : text.trim().replace(/ {2,}/g, " ");
     }
   },
   {
@@ -1775,7 +2189,7 @@ var TEXT_FUNCTIONS = [
       if (isFormulaError(value)) return value;
       if (typeof value === "number") return value;
       if (isBlank(value)) return 0;
-      const num = parseNumericText(toText(value));
+      const num = _nullishCoalesce(parseNumericText(toText(value)), () => ( parseNumberText(toText(value))));
       if (num === null) return ctx.argError(0, "#VALUE!", `("${toText(value)}") can't be converted to a number.`);
       return num;
     }
@@ -2241,6 +2655,335 @@ var INFORMATION_FUNCTIONS = [
   }
 ];
 
+// src/spreadsheet/formula/functions/array.ts
+var MAX_ARRAY_CELLS = 1e6;
+function rangeArg(ctx, index) {
+  const value = ctx.value(index);
+  if (Array.isArray(value)) return toFormulaRange(value);
+  if (isFormulaError(value)) return value;
+  return { rows: 1, cols: 1, values: [value] };
+}
+function fromRows(rows, cols) {
+  const out = [];
+  for (let c = 0; c < cols; c++) {
+    for (const row of rows) out.push(row[c]);
+  }
+  return withRangeShape(out, rows.length, cols);
+}
+var rowOf = (range, r) => {
+  const row = [];
+  for (let c = 0; c < range.cols; c++) row.push(rangeGet(range, r, c));
+  return row;
+};
+var colOf = (range, c) => {
+  const col = [];
+  for (let r = 0; r < range.rows; r++) col.push(rangeGet(range, r, c));
+  return col;
+};
+var linesOf = (range, byCol) => byCol ? Array.from({ length: range.cols }, (_, c) => colOf(range, c)) : Array.from({ length: range.rows }, (_, r) => rowOf(range, r));
+function fromLines(lines, byCol, width) {
+  if (!byCol) return fromRows(lines, width);
+  const out = [];
+  for (const line of lines) for (const v of line) out.push(v);
+  return withRangeShape(out, width, lines.length);
+}
+function compareForSort(a, b, order) {
+  const blankA = isBlank(a);
+  const blankB = isBlank(b);
+  if (blankA || blankB) return blankA === blankB ? 0 : blankA ? 1 : -1;
+  return compareValues(normalizeValue(a), normalizeValue(b)) * order;
+}
+var sortOrder = (ctx, index) => {
+  const order = ctx.integer(index, 1);
+  if (failed(order)) return order;
+  return order === 1 || order === -1 ? order : ctx.argError(index, "#VALUE!", "must be 1 (ascending) or -1 (descending).");
+};
+function includeFlag(value) {
+  if (isFormulaError(value)) return value;
+  const flag = toBoolean(value);
+  return isFormulaError(flag) ? "#VALUE!" : flag;
+}
+var ARRAY_FUNCTIONS = [
+  {
+    name: "FILTER",
+    category: "lookup",
+    description: "Returns the rows (or columns) of an array whose include value is TRUE. The result spills.",
+    args: [
+      arg("array", "The range or array to filter.", "range"),
+      arg("include", "TRUE/FALSE for each row (a column as tall as array) or each column (a row as wide as array)."),
+      optional("if_empty", "Returned when nothing matches (default #CALC!).")
+    ],
+    evaluate: (ctx) => {
+      const range = rangeArg(ctx, 0);
+      if (failed(range)) return range;
+      const include = rangeArg(ctx, 1);
+      if (failed(include)) return include;
+      let byCol;
+      if (include.cols === 1 && include.rows === range.rows) byCol = false;
+      else if (include.rows === 1 && include.cols === range.cols) byCol = true;
+      else {
+        return ctx.argError(1, "#VALUE!", "must be a single column as tall as argument 1 (or a single row as wide).");
+      }
+      const lines = linesOf(range, byCol);
+      const kept = [];
+      for (let i = 0; i < lines.length; i++) {
+        const flag = includeFlag(include.values[i]);
+        if (typeof flag === "string") {
+          return flag === "#VALUE!" ? ctx.argError(1, "#VALUE!", `has a value that isn't TRUE or FALSE (${include.values[i]}).`) : flag;
+        }
+        if (flag) kept.push(lines[i]);
+      }
+      if (kept.length === 0) {
+        return ctx.has(2) ? ctx.value(2) : ctx.error("#CALC!", "FILTER found no matching values.");
+      }
+      return fromLines(kept, byCol, byCol ? range.rows : range.cols);
+    }
+  },
+  {
+    name: "SORT",
+    category: "lookup",
+    description: "Sorts the rows (or columns) of an array by one of its columns (or rows). The result spills.",
+    args: [
+      arg("array", "The range or array to sort.", "range"),
+      optional("sort_index", "The column (or row, with by_col) to sort by; 1 = first (default).", "number"),
+      optional("sort_order", "1 = ascending (default), -1 = descending.", "number"),
+      optional("by_col", "TRUE sorts columns by a row; FALSE (default) sorts rows by a column.", "logical")
+    ],
+    evaluate: (ctx) => {
+      const range = rangeArg(ctx, 0);
+      if (failed(range)) return range;
+      const index = ctx.integer(1, 1);
+      if (failed(index)) return index;
+      const order = sortOrder(ctx, 2);
+      if (failed(order)) return order;
+      const byCol = ctx.boolean(3, false);
+      if (failed(byCol)) return byCol;
+      const width = byCol ? range.rows : range.cols;
+      if (index < 1 || index > width) {
+        return ctx.argError(1, "#VALUE!", `must be between 1 and ${width}.`);
+      }
+      const lines = linesOf(range, byCol).map((line, position) => ({ line, position })).sort((a, b) => compareForSort(a.line[index - 1], b.line[index - 1], order) || a.position - b.position).map((entry) => entry.line);
+      return fromLines(lines, byCol, width);
+    }
+  },
+  {
+    name: "SORTBY",
+    category: "lookup",
+    description: "Sorts an array by the values in other ranges (one value per row or column). The result spills.",
+    args: [
+      arg("array", "The range or array to sort.", "range"),
+      arg("by_array", "A column as tall as array (or a row as wide) to sort by.", "range"),
+      optional("sort_order", "1 = ascending (default), -1 = descending.", "number"),
+      arg("by_array", "Another range to sort by, for ties.", "range", { repeating: true, optional: true }),
+      arg("sort_order", "Its order: 1 = ascending (default), -1 = descending.", "number", { repeating: true, optional: true })
+    ],
+    allowTrailingArgument: true,
+    evaluate: (ctx) => {
+      const range = rangeArg(ctx, 0);
+      if (failed(range)) return range;
+      const keys = [];
+      let byCol = null;
+      for (let i = 1; i < ctx.args.length; i += 2) {
+        const by = rangeArg(ctx, i);
+        if (failed(by)) return by;
+        let keyByCol;
+        if (by.cols === 1 && by.rows === range.rows) keyByCol = false;
+        else if (by.rows === 1 && by.cols === range.cols) keyByCol = true;
+        else {
+          return ctx.argError(i, "#VALUE!", "must be a single column as tall as argument 1 (or a single row as wide).");
+        }
+        if (byCol !== null && byCol !== keyByCol) {
+          return ctx.argError(i, "#VALUE!", "must have the same orientation as the other sort ranges.");
+        }
+        byCol = keyByCol;
+        const order = sortOrder(ctx, i + 1);
+        if (failed(order)) return order;
+        keys.push({ values: by.values, order });
+      }
+      const sortByCol = _nullishCoalesce(byCol, () => ( false));
+      const lines = linesOf(range, sortByCol).map((line, position) => ({ line, position })).sort((a, b) => {
+        for (const key of keys) {
+          const result = compareForSort(key.values[a.position], key.values[b.position], key.order);
+          if (result !== 0) return result;
+        }
+        return a.position - b.position;
+      }).map((entry) => entry.line);
+      return fromLines(lines, sortByCol, sortByCol ? range.rows : range.cols);
+    }
+  },
+  {
+    name: "UNIQUE",
+    category: "lookup",
+    description: "Returns the distinct rows (or columns) of an array, in order of first appearance. The result spills.",
+    args: [
+      arg("array", "The range or array.", "range"),
+      optional("by_col", "TRUE compares columns; FALSE (default) compares rows.", "logical"),
+      optional("exactly_once", "TRUE returns only the rows that appear exactly once (default FALSE).", "logical")
+    ],
+    evaluate: (ctx) => {
+      const range = rangeArg(ctx, 0);
+      if (failed(range)) return range;
+      const byCol = ctx.boolean(1, false);
+      if (failed(byCol)) return byCol;
+      const exactlyOnce = ctx.boolean(2, false);
+      if (failed(exactlyOnce)) return exactlyOnce;
+      const keyOf = (line) => JSON.stringify(
+        line.map((v) => {
+          const n = normalizeValue(v);
+          return typeof n === "string" ? `s:${n.toLowerCase()}` : isBlank(n) ? "blank" : `${typeof n}:${String(n)}`;
+        })
+      );
+      const counts = /* @__PURE__ */ new Map();
+      for (const line of linesOf(range, byCol)) {
+        const key = keyOf(line);
+        const entry = counts.get(key);
+        if (entry) entry.count++;
+        else counts.set(key, { line, count: 1 });
+      }
+      const lines = Array.from(counts.values()).filter((entry) => !exactlyOnce || entry.count === 1).map((entry) => entry.line);
+      if (lines.length === 0) return ctx.error("#CALC!", "UNIQUE found no values that appear exactly once.");
+      return fromLines(lines, byCol, byCol ? range.rows : range.cols);
+    }
+  },
+  {
+    name: "SEQUENCE",
+    category: "math",
+    description: "Returns a grid of sequential numbers, filled row by row. The result spills.",
+    args: [
+      arg("rows", "The number of rows.", "number"),
+      optional("columns", "The number of columns (default 1).", "number"),
+      optional("start", "The first number (default 1).", "number"),
+      optional("step", "The increment (default 1).", "number")
+    ],
+    evaluate: (ctx) => {
+      const rows = ctx.integer(0);
+      if (failed(rows)) return rows;
+      const cols = ctx.integer(1, 1);
+      if (failed(cols)) return cols;
+      const start = ctx.number(2, 1);
+      if (failed(start)) return start;
+      const step = ctx.number(3, 1);
+      if (failed(step)) return step;
+      if (rows < 1 || cols < 1) return ctx.error("#CALC!", "SEQUENCE needs at least one row and one column.");
+      if (rows * cols > MAX_ARRAY_CELLS) return ctx.error("#NUM!", `SEQUENCE can return at most ${MAX_ARRAY_CELLS} values.`);
+      const out = [];
+      for (let c = 0; c < cols; c++) {
+        for (let r = 0; r < rows; r++) out.push(start + step * (r * cols + c));
+      }
+      return rows * cols === 1 ? out[0] : withRangeShape(out, rows, cols);
+    }
+  },
+  {
+    name: "TRANSPOSE",
+    category: "lookup",
+    description: "Swaps the rows and columns of an array. The result spills.",
+    args: [arg("array", "The range or array to transpose.", "range")],
+    evaluate: (ctx) => {
+      const range = rangeArg(ctx, 0);
+      if (failed(range)) return range;
+      if (range.rows * range.cols === 1) return range.values[0];
+      const out = [];
+      for (let r = 0; r < range.rows; r++) {
+        for (let c = 0; c < range.cols; c++) out.push(rangeGet(range, r, c));
+      }
+      return withRangeShape(out, range.cols, range.rows);
+    }
+  },
+  {
+    name: "RANDARRAY",
+    category: "math",
+    description: "Returns a grid of random numbers. Changes on every recalculation. The result spills.",
+    args: [
+      optional("rows", "The number of rows (default 1).", "number"),
+      optional("columns", "The number of columns (default 1).", "number"),
+      optional("min", "The smallest number (default 0).", "number"),
+      optional("max", "The largest number (default 1).", "number"),
+      optional("integer", "TRUE returns whole numbers; FALSE (default) decimals.", "logical")
+    ],
+    volatile: true,
+    evaluate: (ctx) => {
+      const rows = ctx.integer(0, 1);
+      if (failed(rows)) return rows;
+      const cols = ctx.integer(1, 1);
+      if (failed(cols)) return cols;
+      const min2 = ctx.number(2, 0);
+      if (failed(min2)) return min2;
+      const max2 = ctx.number(3, 1);
+      if (failed(max2)) return max2;
+      const integer = ctx.boolean(4, false);
+      if (failed(integer)) return integer;
+      if (rows < 1 || cols < 1) return ctx.error("#CALC!", "RANDARRAY needs at least one row and one column.");
+      if (rows * cols > MAX_ARRAY_CELLS) return ctx.error("#NUM!", `RANDARRAY can return at most ${MAX_ARRAY_CELLS} values.`);
+      if (min2 > max2) return ctx.argError(2, "#VALUE!", "can't be larger than max.");
+      if (integer && (!Number.isInteger(min2) || !Number.isInteger(max2))) {
+        return ctx.error("#VALUE!", "RANDARRAY needs whole min and max values when integer is TRUE.");
+      }
+      const next = () => integer ? min2 + Math.floor(Math.random() * (max2 - min2 + 1)) : min2 + Math.random() * (max2 - min2);
+      const out = [];
+      for (let i = 0; i < rows * cols; i++) out.push(next());
+      return rows * cols === 1 ? out[0] : withRangeShape(out, rows, cols);
+    }
+  },
+  {
+    // Evaluated by the evaluator itself (it defines names); listed here for
+    // autocomplete, signatures and argument-count checks.
+    name: "LET",
+    category: "logical",
+    description: "Names the results of calculations so a formula can reuse them: LET(x, A1*2, x+x). The last argument is the calculation that uses the names.",
+    args: [
+      repeating("name", "A name to define (letters, not a cell reference)."),
+      repeating("name_value", "The value of the name.")
+    ],
+    allowTrailingArgument: true,
+    evaluate: (ctx) => ctx.error("#ERROR!", "LET must be evaluated by the formula evaluator.")
+  }
+];
+var ELEMENTWISE_BUILTINS = {
+  ABS: true,
+  ROUND: true,
+  ROUNDUP: true,
+  ROUNDDOWN: true,
+  INT: true,
+  MOD: true,
+  POWER: true,
+  SQRT: true,
+  SIGN: true,
+  CEILING: true,
+  FLOOR: true,
+  LEN: true,
+  UPPER: true,
+  LOWER: true,
+  TRIM: true,
+  PROPER: true,
+  LEFT: true,
+  RIGHT: true,
+  MID: true,
+  FIND: true,
+  SEARCH: true,
+  SUBSTITUTE: true,
+  REPLACE: true,
+  REPT: true,
+  EXACT: true,
+  VALUE: true,
+  TEXT: true,
+  YEAR: true,
+  MONTH: true,
+  DAY: true,
+  WEEKDAY: true,
+  EDATE: true,
+  EOMONTH: true,
+  DATE: true,
+  NOT: true,
+  ISBLANK: true,
+  ISNUMBER: true,
+  ISTEXT: true,
+  ISERROR: true,
+  ISNA: true,
+  IF: [0],
+  IFERROR: [0],
+  IFNA: [0]
+};
+
 // src/spreadsheet/formula/functions/index.ts
 var BUILTIN_FORMULA_FUNCTIONS = [
   ...MATH_FUNCTIONS,
@@ -2250,8 +2993,12 @@ var BUILTIN_FORMULA_FUNCTIONS = [
   ...TEXT_FUNCTIONS,
   ...LOOKUP_FUNCTIONS,
   ...DATE_FUNCTIONS,
-  ...INFORMATION_FUNCTIONS
-];
+  ...INFORMATION_FUNCTIONS,
+  ...ARRAY_FUNCTIONS
+].map((def) => {
+  const elementwise = ELEMENTWISE_BUILTINS[def.name];
+  return elementwise && def.elementwise === void 0 ? { ...def, elementwise } : def;
+});
 
 // src/spreadsheet/formula/registry.ts
 var registry = /* @__PURE__ */ new Map();
@@ -2373,16 +3120,43 @@ var DEFAULT_MESSAGES = {
   "#N/A": "A value is not available.",
   "#NUM!": "The formula produced an invalid number.",
   "#CYCLE!": "This formula is part of a circular reference.",
-  "#ERROR!": "The formula could not be evaluated."
+  "#ERROR!": "The formula could not be evaluated.",
+  "#SPILL!": "The formula's array result can't spill into the cells it needs.",
+  "#CALC!": "The formula produced an empty array."
 };
 function describeFormulaError(code) {
   return _nullishCoalesce(DEFAULT_MESSAGES[code], () => ( "The formula could not be evaluated."));
 }
 var quote = (value) => typeof value === "string" ? `"${value}"` : String(value);
+var MAX_FORMULA_ARRAY_SIZE = 1e6;
+function shapeOf(value) {
+  if (!Array.isArray(value)) return { rows: 1, cols: 1 };
+  const range = toFormulaRange(value);
+  return { rows: range.rows, cols: range.cols };
+}
+function broadcastGet(value, row, col) {
+  if (!Array.isArray(value)) return value;
+  const range = toFormulaRange(value);
+  const r = range.rows === 1 ? 0 : row;
+  const c = range.cols === 1 ? 0 : col;
+  if (r >= range.rows || c >= range.cols) return "#N/A";
+  return range.values[c * range.rows + r];
+}
+function buildArray(rows, cols, fn) {
+  const out = [];
+  for (let c = 0; c < cols; c++) {
+    for (let r = 0; r < rows; r++) out.push(fn(r, c));
+  }
+  return withRangeShape(out, rows, cols);
+}
+var isMultiArray = (value) => Array.isArray(value) && value.length > 1;
+var firstValue = (value) => Array.isArray(value) ? value.length ? value[0] : "" : value;
 var FormulaEvaluator = (_class2 = class {
   
   __init3() {this.diagnostics = []}
-  constructor(context = {}) {;_class2.prototype.__init3.call(this);
+  // LET variables, innermost scope last.
+  __init4() {this.scopes = []}
+  constructor(context = {}) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
     this.context = context;
   }
   /**
@@ -2395,25 +3169,39 @@ var FormulaEvaluator = (_class2 = class {
   }
   /**
    * Evaluates a formula and explains errors. Never throws: malformed formulas
-   * return `#ERROR!` with the parser's message. A result that is a whole range
-   * (no dynamic-array spilling) is reduced to its first value.
+   * return `#ERROR!` with the parser's message. A result with several values
+   * (a range or a dynamic array) is returned in `array`, with its top-left
+   * value as `value`; a one-value array is just that value.
    */
   evaluateWithDiagnostics(astOrFormula) {
     const saved = this.diagnostics;
+    const savedScopes = this.scopes;
     this.diagnostics = [];
+    this.scopes = [];
     try {
       let value = this.evaluate(astOrFormula);
-      if (Array.isArray(value)) value = value.length > 0 ? value[0] : "";
+      let array;
+      if (Array.isArray(value)) {
+        if (value.length > 1) array = toFormulaRange(value);
+        value = firstValue(value);
+      }
       if (isFormulaError(value)) {
         const code = value;
         const diagnostic = this.diagnostics.find((d) => d.code === code);
-        return { value, error: code, message: _nullishCoalesce(_optionalChain([diagnostic, 'optionalAccess', _10 => _10.message]), () => ( describeFormulaError(code))) };
+        const result = {
+          value,
+          error: code,
+          message: _nullishCoalesce(_optionalChain([diagnostic, 'optionalAccess', _13 => _13.message]), () => ( describeFormulaError(code)))
+        };
+        if (array) result.array = array;
+        return result;
       }
-      return { value };
+      return array ? { value, array } : { value };
     } catch (err) {
-      return { value: "#ERROR!", error: "#ERROR!", message: _optionalChain([err, 'optionalAccess', _11 => _11.message]) || "Formula error" };
+      return { value: "#ERROR!", error: "#ERROR!", message: _optionalChain([err, 'optionalAccess', _14 => _14.message]) || "Formula error" };
     } finally {
       this.diagnostics = saved;
+      this.scopes = savedScopes;
     }
   }
   /** Records why an error happened and returns the error code. */
@@ -2442,6 +3230,14 @@ var FormulaEvaluator = (_class2 = class {
       }
       case "Range":
         return this.evaluateRange(node);
+      case "SpillRef":
+        return this.evaluateSpillRef(node);
+      case "Name": {
+        for (let i = this.scopes.length - 1; i >= 0; i--) {
+          if (this.scopes[i].has(node.name)) return this.scopes[i].get(node.name);
+        }
+        return this.fail("#NAME?", "This formula contains an unknown name.");
+      }
       case "PropertyRef": {
         if (!this.context.resolveProperty) {
           throw new Error(`Cannot resolve property [${node.property}]: no property resolver provided`);
@@ -2449,65 +3245,38 @@ var FormulaEvaluator = (_class2 = class {
         return this.context.resolveProperty(node.property);
       }
       case "UnaryOp": {
+        if (node.op === "@") return this.implicitIntersection(node.argument);
         const raw = this.evaluateNode(node.argument);
-        const val = toNumber(raw);
-        if (isFormulaError(val)) {
-          return isFormulaError(raw) ? raw : this.fail("#VALUE!", `The ${node.op} operator can't use text (${quote(raw)}).`);
+        if (isMultiArray(raw)) {
+          const { rows, cols } = shapeOf(raw);
+          return buildArray(rows, cols, (r, c) => this.unary(node.op, broadcastGet(raw, r, c)));
         }
-        if (node.op === "-") return -val;
-        if (node.op === "+") return val;
-        throw new Error(`Unsupported unary operator: ${node.op}`);
+        return this.unary(node.op, firstValue(raw));
       }
       case "BinaryOp": {
         const left = this.evaluateNode(node.left);
         if (isFormulaError(left)) return left;
         const right = this.evaluateNode(node.right);
         if (isFormulaError(right)) return right;
-        if (["+", "-", "*", "/", "^"].includes(node.op)) {
-          const a = toNumber(left);
-          if (isFormulaError(a)) return this.fail("#VALUE!", `The ${node.op} operator can't use text (${quote(left)}).`);
-          const b = toNumber(right);
-          if (isFormulaError(b)) return this.fail("#VALUE!", `The ${node.op} operator can't use text (${quote(right)}).`);
-          const x = a;
-          const y = b;
-          let result;
-          switch (node.op) {
-            case "+":
-              result = x + y;
-              break;
-            case "-":
-              result = x - y;
-              break;
-            case "*":
-              result = x * y;
-              break;
-            case "/":
-              if (y === 0) return this.fail("#DIV/0!", "The formula divides by zero.");
-              result = x / y;
-              break;
-            default:
-              result = Math.pow(x, y);
-          }
-          return Number.isFinite(result) ? result : this.fail("#NUM!", "The result is too large or not a number.");
-        }
-        switch (node.op) {
-          case "&":
-            return toText(left) + toText(right);
-          case "=":
-            return compareValues(left, right) === 0;
-          case "<>":
-            return compareValues(left, right) !== 0;
-          case "<":
-            return compareValues(left, right) < 0;
-          case "<=":
-            return compareValues(left, right) <= 0;
-          case ">":
-            return compareValues(left, right) > 0;
-          case ">=":
-            return compareValues(left, right) >= 0;
-          default:
-            throw new Error(`Unsupported binary operator: ${node.op}`);
+        if (isMultiArray(left) || isMultiArray(right)) {
+          const a = shapeOf(left);
+          const b = shapeOf(right);
+          const rows = Math.max(a.rows, b.rows);
+          const cols = Math.max(a.cols, b.cols);
+          if (rows * cols > MAX_FORMULA_ARRAY_SIZE) return this.fail("#NUM!", "The array result is too large.");
+          return buildArray(rows, cols, (r2, c) => {
+            const l2 = broadcastGet(left, r2, c);
+            if (isFormulaError(l2)) return l2;
+            const rv = broadcastGet(right, r2, c);
+            if (isFormulaError(rv)) return rv;
+            return this.binary(node.op, l2, rv);
+          });
         }
+        const l = firstValue(left);
+        if (isFormulaError(l)) return l;
+        const r = firstValue(right);
+        if (isFormulaError(r)) return r;
+        return this.binary(node.op, l, r);
       }
       case "FunctionCall":
         return this.callFunction(node);
@@ -2515,6 +3284,134 @@ var FormulaEvaluator = (_class2 = class {
         throw new Error(`Unknown AST node: ${node.type}`);
     }
   }
+  unary(op, raw) {
+    const val = toNumber(raw);
+    if (isFormulaError(val)) {
+      return isFormulaError(raw) ? raw : this.fail("#VALUE!", `The ${op} operator can't use text (${quote(raw)}).`);
+    }
+    if (op === "-") return -val;
+    if (op === "+") return val;
+    throw new Error(`Unsupported unary operator: ${op}`);
+  }
+  /** A binary operator on two single values. */
+  binary(op, left, right) {
+    if (["+", "-", "*", "/", "^"].includes(op)) {
+      if (op === "+" || op === "-") {
+        const leftDate = parseIsoDate(left);
+        const rightDate = parseIsoDate(right);
+        if (leftDate || rightDate) return this.dateArithmetic(op, left, right, leftDate, rightDate);
+      }
+      const a = toNumber(left);
+      if (isFormulaError(a)) return this.fail("#VALUE!", `The ${op} operator can't use text (${quote(left)}).`);
+      const b = toNumber(right);
+      if (isFormulaError(b)) return this.fail("#VALUE!", `The ${op} operator can't use text (${quote(right)}).`);
+      const x = a;
+      const y = b;
+      let result;
+      switch (op) {
+        case "+":
+          result = x + y;
+          break;
+        case "-":
+          result = x - y;
+          break;
+        case "*":
+          result = x * y;
+          break;
+        case "/":
+          if (y === 0) return this.fail("#DIV/0!", "The formula divides by zero.");
+          result = x / y;
+          break;
+        default:
+          result = Math.pow(x, y);
+      }
+      return Number.isFinite(result) ? result : this.fail("#NUM!", "The result is too large or not a number.");
+    }
+    switch (op) {
+      case "&":
+        return toText(left) + toText(right);
+      case "=":
+        return compareValues(left, right) === 0;
+      case "<>":
+        return compareValues(left, right) !== 0;
+      case "<":
+        return compareValues(left, right) < 0;
+      case "<=":
+        return compareValues(left, right) <= 0;
+      case ">":
+        return compareValues(left, right) > 0;
+      case ">=":
+        return compareValues(left, right) >= 0;
+      default:
+        throw new Error(`Unsupported binary operator: ${op}`);
+    }
+  }
+  /**
+   * Dates are ISO text: date +/- days is a date, date - date is a number of
+   * days (fractional when times are involved).
+   */
+  dateArithmetic(op, left, right, leftDate, rightDate) {
+    if (leftDate && rightDate) {
+      if (op === "+") return this.fail("#VALUE!", "Two dates can't be added; subtract them to count the days between.");
+      return cleanFloat(dateToSerial(leftDate) - dateToSerial(rightDate));
+    }
+    if (!leftDate && op === "-") {
+      return this.fail("#VALUE!", `A date (${quote(right)}) can't be subtracted from a number.`);
+    }
+    const date = _nullishCoalesce(leftDate, () => ( rightDate));
+    const dateText = String(leftDate ? left : right);
+    const other = leftDate ? right : left;
+    const days = toNumber(other);
+    if (isFormulaError(days)) return this.fail("#VALUE!", `The ${op} operator can't use text (${quote(other)}).`);
+    const n = days;
+    const result = serialToDate(dateToSerial(date) + (op === "+" ? n : -n));
+    if (!result || result.getFullYear() < 1 || result.getFullYear() > 9999) {
+      return this.fail("#NUM!", "The resulting date is out of range.");
+    }
+    return isoDateHasTime(dateText) || !Number.isInteger(n) ? formatIsoDateTime(result) : formatIsoDate(result);
+  }
+  /**
+   * `@` (implicit intersection): a range reference reads the cell in the
+   * formula's row (one column) or column (one row); arrays give their
+   * top-left value.
+   */
+  implicitIntersection(argument) {
+    const value = this.evaluateNode(argument);
+    if (!Array.isArray(value)) return value;
+    if (value.length <= 1) return firstValue(value);
+    const cell = _optionalChain([this, 'access', _15 => _15.context, 'access', _16 => _16.getFormulaCell, 'optionalCall', _17 => _17()]);
+    if (argument.type === "Range" && cell) {
+      const range = toFormulaRange(value);
+      const top = Math.min(argument.startRow, argument.endRow);
+      const left = Math.min(colNameToIndex(argument.startCol), colNameToIndex(argument.endCol));
+      if (range.cols === 1) {
+        const r = cell.row - top;
+        if (r >= 0 && r < range.rows) return range.values[r];
+      } else if (range.rows === 1) {
+        const c = colNameToIndex(cell.col) - left;
+        if (c >= 0 && c < range.cols) return range.values[c];
+      }
+      return this.fail("#VALUE!", `The @ operator found no cell of ${argument.raw} in the formula's row or column.`);
+    }
+    return value[0];
+  }
+  evaluateSpillRef(node) {
+    if (!this.context.resolveSpill) {
+      throw new Error(`Cannot resolve spill range ${node.ref}#: no spill resolver provided`);
+    }
+    const spill = this.context.resolveSpill(node.col, node.row);
+    if (typeof spill === "string" || !spill) {
+      const code = isFormulaError(spill) ? spill : "#REF!";
+      return this.fail(
+        code,
+        code === "#REF!" ? `${node.ref}# refers to ${node.ref}, which doesn't hold a spilled array.` : `The spill range ${node.ref}# isn't available (${code}).`
+      );
+    }
+    const values = withRangeShape(spill.values.slice(), spill.rows, spill.cols);
+    const error = values.find(isFormulaError);
+    if (error) this.fail(error, `The spill range ${node.ref}# contains an error (${error}).`);
+    return values;
+  }
   evaluateRange(node) {
     if (!this.context.resolveRange) {
       throw new Error(`Cannot resolve range ${node.raw}: no range resolver provided`);
@@ -2532,15 +3429,23 @@ var FormulaEvaluator = (_class2 = class {
     if (!def) return this.fail("#NAME?", `Unknown function "${node.name.toUpperCase()}".`);
     const countError = checkFormulaArgumentCount(def, node.args.length);
     if (countError) return this.fail("#ERROR!", countError);
-    const result = def.evaluate(this.createContext(def, node.args));
+    if (def.name === "LET") return this.evaluateLet(node);
+    const args = this.lazyArguments(node.args);
+    if (def.elementwise) {
+      const lifted = this.liftOverArrays(def, args);
+      if (lifted !== void 0) return lifted;
+    }
+    return this.finishCall(def, def.evaluate(this.createContext(def, args)));
+  }
+  finishCall(def, result) {
     if (typeof result === "number" && !Number.isFinite(result)) {
       return this.fail("#NUM!", `${def.name} produced an invalid number.`);
     }
     return result === void 0 || result === null ? "" : result;
   }
-  createContext(def, nodes) {
+  lazyArguments(nodes) {
     const cache = /* @__PURE__ */ new Map();
-    const args = nodes.map((node, index) => ({
+    return nodes.map((node, index) => ({
       index,
       node,
       value: () => {
@@ -2548,6 +3453,56 @@ var FormulaEvaluator = (_class2 = class {
         return cache.get(index);
       }
     }));
+  }
+  /**
+   * Applies a scalar function element by element when it receives arrays
+   * (`=LEN(A1:A3)`, `=IF(A1:A3>1, "y", "n")`). Arguments typed `range` are
+   * passed whole. Returns undefined when no trigger argument is a
+   * multi-value array.
+   */
+  liftOverArrays(def, args) {
+    const liftable = (index) => _optionalChain([def, 'access', _18 => _18.args, 'access', _19 => _19[getFormulaArgumentSpecIndex(def, index)], 'optionalAccess', _20 => _20.type]) !== "range";
+    const triggers = def.elementwise === true ? args.map((a) => a.index) : def.elementwise;
+    if (!triggers.some((i) => i < args.length && liftable(i) && isMultiArray(args[i].value()))) return void 0;
+    let rows = 1;
+    let cols = 1;
+    for (const a of args) {
+      if (!liftable(a.index)) continue;
+      const shape = shapeOf(a.value());
+      rows = Math.max(rows, shape.rows);
+      cols = Math.max(cols, shape.cols);
+    }
+    if (rows * cols > MAX_FORMULA_ARRAY_SIZE) return this.fail("#NUM!", "The array result is too large.");
+    return buildArray(rows, cols, (r, c) => {
+      const elementArgs = args.map((a) => {
+        if (!liftable(a.index)) return a;
+        const element = broadcastGet(a.value(), r, c);
+        return { index: a.index, node: a.node, value: () => element };
+      });
+      return firstValue(this.finishCall(def, def.evaluate(this.createContext(def, elementArgs))));
+    });
+  }
+  /** LET(name1, value1, [name2, value2, ...], calculation). */
+  evaluateLet(node) {
+    if (node.args.length % 2 === 0) {
+      return this.fail("#ERROR!", "LET needs name/value pairs followed by a calculation.");
+    }
+    const scope = /* @__PURE__ */ new Map();
+    this.scopes.push(scope);
+    try {
+      for (let i = 0; i < node.args.length - 1; i += 2) {
+        const nameNode = node.args[i];
+        if (nameNode.type !== "Name") {
+          return this.fail("#ERROR!", `Argument ${i + 1} of LET must be a name (names can't look like cell references).`);
+        }
+        scope.set(nameNode.name, this.evaluateNode(node.args[i + 1]));
+      }
+      return this.evaluateNode(node.args[node.args.length - 1]);
+    } finally {
+      this.scopes.pop();
+    }
+  }
+  createContext(def, args) {
     const has = (index) => index >= 0 && index < args.length;
     const value = (index) => has(index) ? args[index].value() : "";
     const argError = (index, code, reason) => this.fail(code, `Argument ${index + 1} of ${def.name} ${reason}`);
@@ -2653,5 +3608,16 @@ var FormulaEvaluator = (_class2 = class {
 
 
 
-exports.tokenizeFormula = tokenizeFormula; exports.WHOLE_COLUMN_END_ROW = WHOLE_COLUMN_END_ROW; exports.parseCellReference = parseCellReference; exports.parseRange = parseRange; exports.FormulaParser = FormulaParser; exports.parseFormula = parseFormula; exports.FORMULA_ERRORS = FORMULA_ERRORS; exports.isFormulaError = isFormulaError; exports.colNameToIndex = colNameToIndex; exports.indexToColName = indexToColName; exports.wildcardToRegExp = wildcardToRegExp; exports.parseCriteria = parseCriteria; exports.formatValueWithCode = formatValueWithCode; exports.registerFormulaFunction = registerFormulaFunction; exports.unregisterFormulaFunction = unregisterFormulaFunction; exports.getFormulaFunction = getFormulaFunction; exports.listFormulaFunctions = listFormulaFunctions; exports.searchFormulaFunctions = searchFormulaFunctions; exports.getFormulaArgumentSpecIndex = getFormulaArgumentSpecIndex; exports.checkFormulaArgumentCount = checkFormulaArgumentCount; exports.getFormulaSignatureParts = getFormulaSignatureParts; exports.getFormulaSignature = getFormulaSignature; exports.describeFormulaError = describeFormulaError; exports.FormulaEvaluator = FormulaEvaluator;
-//# sourceMappingURL=chunk-JYRIOFEN.cjs.map
+
+
+
+
+
+
+
+
+
+
+
+exports.tokenizeFormula = tokenizeFormula; exports.WHOLE_COLUMN_END_ROW = WHOLE_COLUMN_END_ROW; exports.parseCellReference = parseCellReference; exports.parseRange = parseRange; exports.FormulaParser = FormulaParser; exports.parseFormula = parseFormula; exports.serialFromYmd = serialFromYmd; exports.parseCellInput = parseCellInput; exports.parseNumberText = parseNumberText; exports.FORMULA_ERRORS = FORMULA_ERRORS; exports.isFormulaError = isFormulaError; exports.numberToText = numberToText; exports.numericValue = numericValue; exports.compareNumbers = compareNumbers; exports.compareValues = compareValues; exports.sortCompareValues = sortCompareValues; exports.colNameToIndex = colNameToIndex; exports.indexToColName = indexToColName; exports.parseIsoDate = parseIsoDate; exports.wildcardToRegExp = wildcardToRegExp; exports.parseCriteria = parseCriteria; exports.formatCellDisplay = formatCellDisplay; exports.formatValueWithCode = formatValueWithCode; exports.registerFormulaFunction = registerFormulaFunction; exports.unregisterFormulaFunction = unregisterFormulaFunction; exports.getFormulaFunction = getFormulaFunction; exports.listFormulaFunctions = listFormulaFunctions; exports.searchFormulaFunctions = searchFormulaFunctions; exports.getFormulaArgumentSpecIndex = getFormulaArgumentSpecIndex; exports.checkFormulaArgumentCount = checkFormulaArgumentCount; exports.getFormulaSignatureParts = getFormulaSignatureParts; exports.getFormulaSignature = getFormulaSignature; exports.describeFormulaError = describeFormulaError; exports.MAX_FORMULA_ARRAY_SIZE = MAX_FORMULA_ARRAY_SIZE; exports.FormulaEvaluator = FormulaEvaluator;
+//# sourceMappingURL=chunk-RIKBJLS2.cjs.map