@pixerate/editor 0.21.0 → 0.22.0

package/dist/{chunk-JYRIOFEN.cjs → chunk-SAZRENEZ.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);
@@ -430,6 +442,11 @@ function normalizeValue(value) {
   return num === null ? value : num;
 }
 function compareValues(left, right) {
+  if (typeof left === "string" && typeof right === "string") {
+    const a = isoDateTime(left);
+    const b = a === null ? null : isoDateTime(right);
+    if (a !== null && b !== null) return a - b;
+  }
   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;
@@ -505,6 +522,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(),
@@ -762,8 +793,8 @@ function formatDate(date, format) {
       return lower.length >= 2 ? pad2(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());
     }
@@ -1606,11 +1637,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, " ");
     }
   },
   {
@@ -2241,6 +2272,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 +2610,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 +2737,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 +2786,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 +2847,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 +2862,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 +2901,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 +3046,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 +3070,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 +3225,6 @@ 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.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.MAX_FORMULA_ARRAY_SIZE = MAX_FORMULA_ARRAY_SIZE; exports.FormulaEvaluator = FormulaEvaluator;
+//# sourceMappingURL=chunk-SAZRENEZ.cjs.map