@ex-grid/sheet-xlsx 0.0.0-stage → 0.2.0-beta.3

package/dist/index.js

@@ -0,0 +1,2708 @@
+// src/reader.ts
+import {
+  CellAddress,
+  CellBorders as CellBorders3,
+  CellFill as CellFill3,
+  CellFont as CellFont3,
+  CellRange,
+  Culture,
+  Entry,
+  FormulaSyntaxError,
+  NumberFormat as NumberFormat4,
+  Sheet as Sheet3,
+  SheetDocument,
+  SheetDocumentAxisFormat,
+  SheetDocumentCell,
+  SheetDocumentColumnWidth,
+  Value,
+  WorkbookDocument
+} from "@ex-grid/sheet-engine";
+import {
+  openXlsx,
+  parseCell,
+  formatCell,
+  XlsxError as XlsxError2
+} from "@ex-grid/data-xlsx";
+
+// src/column-width-unit.ts
+import { Sheet } from "@ex-grid/sheet-engine";
+var maxDigitWidth = 7;
+var padding = 5;
+var narrowest = 0.01;
+function widthToFile(characters) {
+  return Math.trunc((characters * maxDigitWidth + padding) / maxDigitWidth * 256) / 256;
+}
+function widthFromFile(width) {
+  return Math.trunc((width * maxDigitWidth - padding) / maxDigitWidth * 100 + 0.5) / 100;
+}
+function readWidth(width) {
+  if (width <= 0) return void 0;
+  const characters = Math.min(Math.max(widthFromFile(width), narrowest), Sheet.maxColumnWidth);
+  return characters === Sheet.defaultColumnWidth ? void 0 : characters;
+}
+
+// src/text-casing.ts
+function foldCase(text) {
+  let folded = "";
+  let changed = false;
+  for (const character of text) {
+    const upper = upperOf(character);
+    if (upper !== character) changed = true;
+    folded += upper;
+  }
+  return changed ? folded : text;
+}
+function upperOf(character) {
+  const code = character.charCodeAt(0);
+  if (code < 128) return code >= 97 && code <= 122 ? String.fromCharCode(code - 32) : character;
+  const upper = character.toUpperCase();
+  const point = upper.codePointAt(0);
+  const single = point !== void 0 && upper.length === (point > 65535 ? 2 : 1);
+  if (!single) return simpleUpperOf(code, character);
+  if (upper === character || point < 128) return character;
+  return upper;
+}
+function simpleUpperOf(code, character) {
+  const pairs = code >= 8064 && code <= 8071 || code >= 8080 && code <= 8087 || code >= 8096 && code <= 8103;
+  if (pairs) return String.fromCharCode(code + 8);
+  if (code === 8115 || code === 8131 || code === 8179) return String.fromCharCode(code + 9);
+  return character;
+}
+function equalsIgnoreCase(a, b) {
+  return a.length === b.length && foldCase(a) === foldCase(b);
+}
+function startsWithIgnoreCase(text, at, part) {
+  return at + part.length <= text.length && equalsIgnoreCase(text.slice(at, at + part.length), part);
+}
+var whiteSpaceEnds = /^[\t-\r \u0085\u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]+|[\t-\r \u0085\u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]+$/g;
+function trimWhiteSpace(text) {
+  return text.replace(whiteSpaceEnds, "");
+}
+
+// src/date-formats.ts
+var builtInDates = /* @__PURE__ */ new Set([14, 15, 16, 17, 22, 27, 28, 29, 30, 31, 34, 35, 36, 50, 51, 52, 53, 54, 55, 56, 57, 58]);
+function showsDate(id, code) {
+  return code === void 0 ? builtInDates.has(id) : codeShowsDate(code);
+}
+function lower(c) {
+  return c >= "A" && c <= "Z" ? c.toLowerCase() : c;
+}
+function codeShowsDate(code) {
+  let hasMonthOrMinute = false;
+  let hasTime = false;
+  for (let i = 0; i < code.length; i++) {
+    const c = code.charAt(i);
+    switch (c) {
+      case ";":
+        return !hasTime && hasMonthOrMinute;
+      case '"': {
+        const end = code.indexOf('"', i + 1);
+        i = end >= 0 ? end : code.length;
+        continue;
+      }
+      case "\\":
+      case "_":
+      case "*":
+        i++;
+        continue;
+      case "[": {
+        let close = code.indexOf("]", i + 1);
+        if (close < 0) close = code.length;
+        if (isElapsed(code.slice(i + 1, close))) hasTime = true;
+        i = close;
+        continue;
+      }
+      default:
+        break;
+    }
+    if (startsWithIgnoreCase(code, i, "General")) {
+      i += 6;
+      continue;
+    }
+    if (startsWithIgnoreCase(code, i, "AM/PM")) {
+      hasTime = true;
+      i += 4;
+      continue;
+    }
+    if (startsWithIgnoreCase(code, i, "A/P")) {
+      hasTime = true;
+      i += 2;
+      continue;
+    }
+    switch (lower(c)) {
+      case "y":
+      case "d":
+        return true;
+      case "e":
+        if (i + 1 >= code.length || code.charAt(i + 1) !== "+" && code.charAt(i + 1) !== "-") return true;
+        break;
+      case "m":
+        hasMonthOrMinute = true;
+        break;
+      case "h":
+      case "s":
+        hasTime = true;
+        break;
+      default:
+        break;
+    }
+  }
+  return !hasTime && hasMonthOrMinute;
+}
+function isElapsed(inside) {
+  if (inside.length === 0) return false;
+  const letter = lower(inside.charAt(0));
+  if (letter !== "h" && letter !== "m" && letter !== "s") return false;
+  for (const c of inside) {
+    if (lower(c) !== letter) return false;
+  }
+  return true;
+}
+
+// src/format-parts.ts
+import { CellBorders, CellFill, CellFont, CellFormat, NumberFormat } from "@ex-grid/sheet-engine";
+var defaultFormat = new CellFormat(NumberFormat.general, "general", CellFont.default, CellFill.none, CellBorders.none);
+var FormatParts = class _FormatParts {
+  static empty = new _FormatParts(void 0, void 0, void 0, void 0, void 0);
+  numberFormat;
+  alignment;
+  font;
+  fill;
+  borders;
+  constructor(numberFormat, alignment, font, fill, borders) {
+    this.numberFormat = numberFormat;
+    this.alignment = alignment;
+    this.font = font;
+    this.fill = fill;
+    this.borders = borders;
+  }
+  get isEmpty() {
+    return this.numberFormat === void 0 && this.alignment === void 0 && this.font === void 0 && this.fill === void 0 && this.borders === void 0;
+  }
+  /** This level over `under`, part by part. */
+  over(under) {
+    return new CellFormat(
+      this.numberFormat === void 0 ? under.numberFormat : this.numberFormat,
+      this.alignment === void 0 ? under.alignment : this.alignment,
+      this.font === void 0 ? under.font : this.font,
+      this.fill === void 0 ? under.fill : this.fill,
+      this.borders === void 0 ? under.borders : this.borders
+    );
+  }
+  /** The parts of `format` that differ from `under`: what a level records so that it shows `format` over it. */
+  static differing(format, under) {
+    return new _FormatParts(
+      format.numberFormat.equals(under.numberFormat) ? void 0 : format.numberFormat,
+      format.alignment === under.alignment ? void 0 : format.alignment,
+      format.font.equals(under.font) ? void 0 : format.font,
+      format.fill.equals(under.fill) ? void 0 : format.fill,
+      format.borders.equals(under.borders) ? void 0 : format.borders
+    );
+  }
+  /** Whether the two levels record the same parts alike, as the C# record compares. */
+  equals(other) {
+    return same(this.numberFormat, other.numberFormat, (a, b) => a.equals(b)) && this.alignment === other.alignment && same(this.font, other.font, (a, b) => a.equals(b)) && same(this.fill, other.fill, (a, b) => a.equals(b)) && same(this.borders, other.borders, (a, b) => a.equals(b));
+  }
+  /** The parts a level records, as a mask: Number Format, alignment, Font, Fill, borders. */
+  get mask() {
+    return (this.numberFormat === void 0 ? 0 : 1) | (this.alignment === void 0 ? 0 : 2) | (this.font === void 0 ? 0 : 4) | (this.fill === void 0 ? 0 : 8) | (this.borders === void 0 ? 0 : 16);
+  }
+};
+function same(a, b, equal) {
+  return a === void 0 || b === void 0 ? a === b : equal(a, b);
+}
+
+// src/invariant.ts
+function grouped(value) {
+  const digits = String(Math.abs(Math.trunc(value)));
+  const groups = [];
+  for (let end = digits.length; end > 0; end -= 3) groups.unshift(digits.slice(Math.max(0, end - 3), end));
+  return (value < 0 ? "-" : "") + groups.join(",");
+}
+function roundTrip(value) {
+  if (Number.isNaN(value)) return "NaN";
+  if (!Number.isFinite(value)) return value > 0 ? "Infinity" : "-Infinity";
+  if (value === 0) return Object.is(value, -0) ? "-0" : "0";
+  const match = /^(\d)(?:\.(\d+))?e([+-]\d+)$/.exec(Math.abs(value).toExponential());
+  if (match === null) throw new Error(`Internal: ${String(value)} is not written in exponent form.`);
+  const [, first = "", rest = "", exponent = ""] = match;
+  const digits = first + rest;
+  const point = Number(exponent) + 1;
+  const sign = value < 0 ? "-" : "";
+  if (point > 17 || point < -3) {
+    const e = point - 1;
+    const mantissa = digits.length > 1 ? `${digits.slice(0, 1)}.${digits.slice(1)}` : digits;
+    return `${sign}${mantissa}E${e < 0 ? "-" : "+"}${String(Math.abs(e)).padStart(2, "0")}`;
+  }
+  if (point <= 0) return `${sign}0.${"0".repeat(-point)}${digits}`;
+  if (point >= digits.length) return sign + digits + "0".repeat(point - digits.length);
+  return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+}
+function parseDouble(text) {
+  const trimmed = text.replace(/^[\t\n\v\f\r ]+|[\t\n\v\f\r ]+$/g, "");
+  if (/^[+-]?(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/.test(trimmed)) return Number(trimmed);
+  const lower2 = trimmed.toLowerCase();
+  if (lower2 === "infinity" || lower2 === "+infinity") return Number.POSITIVE_INFINITY;
+  if (lower2 === "-infinity") return Number.NEGATIVE_INFINITY;
+  if (lower2 === "nan" || lower2 === "+nan" || lower2 === "-nan") return Number.NaN;
+  return void 0;
+}
+
+// src/iso-date.ts
+import { serialFromDate } from "@ex-grid/sheet-engine";
+var shape = /^(?:(?<y>[0-9]{4})-(?<mo>[0-9]{2})-(?<d>[0-9]{2}))?(?<t>T)?(?:(?<h>[0-9]{2}):(?<mi>[0-9]{2})(?::(?<s>[0-9]{2})(?<f>\.[0-9]+)?)?)?(?<z>Z|[+-][0-9]{2}(?::?[0-9]{2})?)?$/;
+function isoDateSerial(text) {
+  const groups = shape.exec(text)?.groups;
+  if (groups === void 0) return void 0;
+  const { y, mo, d, t, h, mi, s, f } = groups;
+  const hasDate = y !== void 0;
+  const hasTime = h !== void 0;
+  if (!hasDate && !hasTime) return void 0;
+  if (t !== void 0 !== (hasDate && hasTime)) return void 0;
+  let time = 0;
+  if (hasTime) {
+    const hours = Number(h);
+    const minutes = Number(mi);
+    const seconds = s === void 0 ? 0 : Number(s);
+    const fraction = f === void 0 ? 0 : Number(`0${f}`);
+    if (hours > 23 || minutes > 59 || seconds > 59) return void 0;
+    time = (hours * 3600 + minutes * 60 + seconds + fraction) / 86400;
+  }
+  if (!hasDate) return time;
+  const serial = serialFromDate(Number(y), Number(mo), Number(d));
+  return serial === void 0 ? void 0 : serial + time;
+}
+
+// src/must.ts
+function elementAt(list, index) {
+  const value = list[index];
+  if (value === void 0) {
+    throw new Error(`Internal: index ${String(index)} is outside a list of ${String(list.length)}.`);
+  }
+  return value;
+}
+function defined(value, what) {
+  if (value === void 0) {
+    throw new Error(`Internal: ${what} is missing.`);
+  }
+  return value;
+}
+function unreachable(value) {
+  throw new Error(`Internal: ${String(value)} is not a value this switch takes.`);
+}
+
+// src/open-error.ts
+import { XlsxError } from "@ex-grid/data-xlsx";
+var XlsxOpenError = class _XlsxOpenError extends Error {
+  /** Why the workbook was refused. */
+  reason;
+  /** The name of the Sheet the refusal met, or `undefined` when it is not about one Sheet. */
+  sheet;
+  /** The cell the refusal met, as `B7`, or `undefined` when it is not about one cell. */
+  cell;
+  /** What the cell held — a Formula's text with its `=`, or a constant — or `undefined` when the refusal is not about one
+   * cell. */
+  held;
+  /**
+   * A refusal naming what it met.
+   * @param reason - Why the workbook is refused.
+   * @param message - What was wrong, as a sentence that follows the Sheet and the cell.
+   * @param where - The Sheet, the cell and what the cell held, as far as it is about one.
+   * @param options - What caused it, when it was another error.
+   */
+  constructor(reason, message, where = {}, options) {
+    super(formatted(where.sheet, where.cell, where.held, message), options);
+    this.name = "XlsxOpenError";
+    this.reason = reason;
+    this.sheet = where.sheet;
+    this.cell = where.cell;
+    this.held = where.held;
+  }
+  /** Why the file layer refused the file, when `reason` is `file`; otherwise `undefined`. */
+  get fileRefusal() {
+    return this.reason === "file" && this.cause instanceof XlsxError ? this.cause.reason : void 0;
+  }
+  /** The file layer's refusal, with its Sheet and cell. @internal */
+  static fromFile(e) {
+    const refusal = new _XlsxOpenError("file", e.message, { sheet: e.sheet, cell: e.cell }, { cause: e });
+    refusal.message = e.message;
+    return refusal;
+  }
+};
+function formatted(sheet, cell, held2, message) {
+  const at = held2 === void 0 ? cell : `${cell === void 0 ? "" : cell} (${held2})`;
+  if (sheet === void 0) return message;
+  return at === void 0 ? `Sheet '${sheet}': ${message}` : `Sheet '${sheet}', cell ${at}: ${message}`;
+}
+
+// src/open-report.ts
+var OpenReport = class {
+  /**
+   * What the file held that changes how a Sheet looks, or what else the file held, and that ExSheet did not carry
+   * (ADR-0330 §4's "Not carried"), in the workbook's order: what the workbook holds first, then each Sheet's in turn. Saving
+   * the Workbook again will not keep any of it.
+   */
+  notCarried;
+  /**
+   * The cells whose Formula names a function outside ExSheet's declared set (`DeclaredFunction`), in Sheet order and then
+   * row by row: each is carried, and shows `#NAME?` (ADR-0047, ADR-0330 §4).
+   */
+  unsupportedFunctions;
+  /** @internal */
+  constructor(notCarried, unsupportedFunctions) {
+    this.notCarried = Object.freeze(notCarried.map((n) => Object.freeze({ ...n })));
+    this.unsupportedFunctions = Object.freeze(unsupportedFunctions.map((u) => Object.freeze({ ...u, functions: Object.freeze([...u.functions]) })));
+    Object.freeze(this);
+  }
+  /** Whether the file was carried whole: nothing left behind, and every function it names supported. */
+  get isEmpty() {
+    return this.notCarried.length === 0 && this.unsupportedFunctions.length === 0;
+  }
+};
+
+// src/sheet-format-plan.ts
+import { Sheet as Sheet2 } from "@ex-grid/sheet-engine";
+var allParts = 31;
+var SheetFormatPlan = class {
+  #sheet;
+  #columnLevels = /* @__PURE__ */ new Map();
+  /** Each formatted column's parts other than the default's, as a mask. */
+  #columnParts = /* @__PURE__ */ new Map();
+  /** The formatted column runs, in order, each with the parts it records other than the default's, as a mask. */
+  #columnRuns = [];
+  /** The formatted row runs, in order, each with the parts it leaves to its columns, as a mask. */
+  #rowRuns = [];
+  /** For each mask of parts a row leaves open, the column runs it crosses and how many columns they hold. */
+  #crossed = /* @__PURE__ */ new Map();
+  /** The column ranges, in order, each with its width and its format's index; set by `build`. */
+  columns = [];
+  /** The runs of formatted rows, in order; set by `build`. */
+  rows = [];
+  /** The plan for `sheet`, its levels read; nothing is written to a styles part yet. */
+  constructor(sheet) {
+    this.#sheet = sheet;
+    for (const run of sheet.columns.toSorted((a, b) => a.first - b.first)) {
+      const level = partsOf(run);
+      const parts = FormatParts.differing(level.over(defaultFormat), defaultFormat).mask;
+      for (let c = run.first; c <= run.last; c++) {
+        this.#columnLevels.set(c, level);
+        this.#columnParts.set(c, parts);
+      }
+      this.#columnRuns.push({ first: run.first, last: run.last, level, parts });
+    }
+    for (const run of sheet.rows.toSorted((a, b) => a.first - b.first)) {
+      const level = partsOf(run);
+      this.#rowRuns.push({ first: run.first, last: run.last, level, open: ~level.mask & allParts });
+    }
+  }
+  /** The rows the row formats write, each a `<row>` element whether or not it holds a cell. */
+  get formattedRows() {
+    let rows = 0;
+    for (const run of this.#rowRuns) rows += run.last - run.first + 1;
+    return rows;
+  }
+  /**
+   * How many cells of no value the crossings write: every place a formatted row crosses a formatted column that records a
+   * part the row leaves open, less those of `recorded`, which are written as the Sheet's own cells. Counted from the runs,
+   * never cell by cell.
+   * @param recorded - The cells the Sheet writes of its own, each once.
+   */
+  crossings(recorded) {
+    let count2 = 0;
+    for (const run of this.#rowRuns) count2 += (run.last - run.first + 1) * this.#crossedBy(run.open).columns;
+    if (count2 === 0) return 0;
+    for (const at of recorded) {
+      const r = this.#rowRunAt(at.row);
+      const parts = this.#columnParts.get(at.column);
+      if (r !== void 0 && parts !== void 0 && (parts & elementAt(this.#rowRuns, r).open) !== 0) count2--;
+    }
+    return count2;
+  }
+  /** Finds every format the columns, the rows and the crossings write, adding each to `styles`. */
+  build(styles) {
+    const rows = [];
+    for (const run of this.#rowRuns) {
+      const crossings = [];
+      for (const index of this.#crossedBy(run.open).runs) {
+        const column = elementAt(this.#columnRuns, index);
+        const style = styles.index(run.level.over(column.level.over(defaultFormat)));
+        const last = crossings.at(-1);
+        if (last !== void 0 && last.last === column.first - 1 && last.style === style) crossings[crossings.length - 1] = { ...last, last: column.last };
+        else crossings.push({ first: column.first, last: column.last, style });
+      }
+      rows.push({ first: run.first, last: run.last, style: styles.index(run.level.over(defaultFormat)), crossings });
+    }
+    this.rows = rows;
+    this.columns = this.#columnRanges(styles);
+  }
+  /** The index of the format a cell element at `at` is written with: what the Sheet shows there, its own level over its row's
+   * and its column's. */
+  style(styles, own, at) {
+    const column = this.#columnLevels.get(at.column);
+    let under = column === void 0 ? defaultFormat : column.over(defaultFormat);
+    const r = this.#rowRunAt(at.row);
+    if (r !== void 0) under = elementAt(this.#rowRuns, r).level.over(under);
+    return styles.index(own.over(under));
+  }
+  /** The column runs a row that leaves `open` to its columns crosses: those that record one of those parts other than the
+   * default's. */
+  #crossedBy(open) {
+    const known = this.#crossed.get(open);
+    if (known !== void 0) return known;
+    const runs = [];
+    let columns = 0;
+    this.#columnRuns.forEach((run, i) => {
+      if ((run.parts & open) === 0) return;
+      runs.push(i);
+      columns += run.last - run.first + 1;
+    });
+    const crossed = { runs, columns };
+    this.#crossed.set(open, crossed);
+    return crossed;
+  }
+  /** The index of the formatted row run that holds `row`, or `undefined`. */
+  #rowRunAt(row) {
+    let low = 0;
+    let high = this.#rowRuns.length - 1;
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const run = elementAt(this.#rowRuns, mid);
+      if (row < run.first) high = mid - 1;
+      else if (row > run.last) low = mid + 1;
+      else return mid;
+    }
+    return void 0;
+  }
+  /** The columns' widths and formats as ranges: a range wherever both stay the same. */
+  #columnRanges(styles) {
+    const widths2 = /* @__PURE__ */ new Map();
+    for (const run of this.#sheet.columnWidths) {
+      for (let c = run.first; c <= run.last; c++) widths2.set(c, run);
+    }
+    const ranges = [];
+    for (const column of [.../* @__PURE__ */ new Set([...widths2.keys(), ...this.#columnLevels.keys()])].toSorted((a, b) => a - b)) {
+      const w = widths2.get(column);
+      const width = widthToFile(w === void 0 ? Sheet2.defaultColumnWidth : w.width);
+      const bestFit = w !== void 0 && w.kind === "widenedByEntry";
+      const level = this.#columnLevels.get(column);
+      const styleIndex = level === void 0 ? 0 : styles.index(level.over(defaultFormat));
+      const last = ranges.at(-1);
+      if (last !== void 0 && last.last === column - 1 && last.width === width && last.styleIndex === styleIndex && last.bestFit === bestFit && last.customWidth === (w !== void 0)) {
+        last.last = column;
+      } else {
+        ranges.push({ first: column, last: column, width, styleIndex, bestFit, customWidth: w !== void 0 });
+      }
+    }
+    return ranges;
+  }
+};
+function partsOf(run) {
+  return new FormatParts(run.numberFormat, run.alignment, run.font, run.fill, run.borders);
+}
+
+// src/sheet-elements.ts
+var defaultMargins = [["left", 0.7], ["right", 0.7], ["top", 0.75], ["bottom", 0.75], ["header", 0.3], ["footer", 0.3]];
+function elementNotCarried(element) {
+  const kinds = [];
+  const add2 = (kind, detail) => {
+    kinds.push({ kind, detail });
+  };
+  const attribute = (name) => element.attributes.get(name);
+  switch (element.name) {
+    // Nothing a Sheet shows or prints: the used range, the sheet's default row (judged below), phonetic settings,
+    // dismissed error marks, calculation flags.
+    case "dimension":
+    case "phoneticPr":
+    case "ignoredErrors":
+    case "sheetCalcPr":
+      break;
+    case "sheetFormatPr": {
+      if (isTrue(attribute("zeroHeight"))) add2("hiddenRows");
+      if (isTrue(attribute("customHeight"))) add2("rowHeights");
+      const base = attribute("baseColWidth");
+      if (attribute("defaultColWidth") !== void 0 || base !== void 0 && base !== "8") add2("defaultColumnWidth");
+      break;
+    }
+    case "sheetViews":
+      if (element.children.some(viewSetsAnything)) add2("view");
+      break;
+    case "sheetPr":
+      if (element.children.some((c) => c.name === "tabColor")) add2("sheetProperties");
+      if (element.children.some((c) => c.name === "pageSetUpPr" && isTrue(c.attributes.get("fitToPage")))) add2("printSettings");
+      break;
+    case "pageMargins":
+      if (defaultMargins.some(([name, inches]) => {
+        const value = attribute(name);
+        return value !== void 0 && marginInches(value) !== inches;
+      })) {
+        add2("printSettings");
+      }
+      break;
+    case "printOptions":
+      if (["horizontalCentered", "verticalCentered", "headings", "gridLines"].some((a) => isTrue(attribute(a)))) add2("printSettings");
+      break;
+    case "pageSetup":
+      if (pageSetupSetsAnything(element)) add2("printSettings");
+      break;
+    case "headerFooter":
+      if (element.children.some((c) => c.text !== null && trimWhiteSpace(c.text) !== "")) add2("printSettings");
+      break;
+    case "rowBreaks":
+    case "colBreaks":
+      if (element.children.some((c) => c.name === "brk") || element.childrenCut) add2("printSettings");
+      break;
+    case "extLst":
+      for (const extension of element.children.filter((e) => e.name === "ext")) {
+        for (const held2 of extension.children) kinds.push(...elementNotCarried(held2));
+      }
+      break;
+    case "mergeCells":
+      add2("mergedCells");
+      break;
+    case "conditionalFormatting":
+    case "conditionalFormattings":
+      add2("conditionalFormatting");
+      break;
+    case "dataValidations":
+      add2("dataValidation");
+      break;
+    case "legacyDrawing":
+      add2("notesAndComments");
+      break;
+    case "hyperlinks":
+      add2("hyperlinks");
+      break;
+    case "drawing":
+    case "picture":
+    case "oleObjects":
+    case "controls":
+    case "legacyDrawingHF":
+    case "sparklineGroups":
+      add2("picturesAndCharts");
+      break;
+    case "sheetProtection":
+    case "protectedRanges":
+      add2("protection");
+      break;
+    case "autoFilter":
+    case "sortState":
+      add2("autoFilter");
+      break;
+    case "tableParts":
+      add2("excelTable");
+      break;
+    case "slicerList":
+    case "timelineRefs":
+      add2("slicers");
+      break;
+    default:
+      add2("other", element.name);
+      break;
+  }
+  return kinds;
+}
+function viewSetsAnything(view) {
+  if (view.name !== "sheetView") return false;
+  const a = (name) => view.attributes.get(name);
+  const zoom = a("zoomScale");
+  const layout = a("view");
+  return isFalse(a("showGridLines")) || isFalse(a("showRowColHeaders")) || isFalse(a("showZeros")) || isTrue(a("showFormulas")) || isTrue(a("rightToLeft")) || zoom !== void 0 && zoom !== "100" || layout !== void 0 && layout !== "normal";
+}
+function pageSetupSetsAnything(element) {
+  for (const [name, value] of element.attributes) {
+    let sets;
+    switch (name) {
+      case "horizontalDpi":
+      case "verticalDpi":
+      case "id":
+      case "usePrinterDefaults":
+        sets = false;
+        break;
+      case "paperSize":
+        sets = value !== "1" && value !== "9";
+        break;
+      case "orientation":
+        sets = value !== "default" && value !== "portrait";
+        break;
+      case "scale":
+        sets = value !== "100";
+        break;
+      case "fitToWidth":
+      case "fitToHeight":
+      case "firstPageNumber":
+      case "copies":
+        sets = value !== "1";
+        break;
+      case "pageOrder":
+        sets = value !== "downThenOver";
+        break;
+      case "cellComments":
+        sets = value !== "none";
+        break;
+      case "errors":
+        sets = value !== "displayed";
+        break;
+      case "blackAndWhite":
+      case "draft":
+      case "useFirstPageNumber":
+        sets = isTrue(value);
+        break;
+      default:
+        sets = true;
+        break;
+    }
+    if (sets) return true;
+  }
+  return false;
+}
+function isTrue(value) {
+  return value === "1" || value === "true";
+}
+function isFalse(value) {
+  return value === "0" || value === "false";
+}
+function marginInches(value) {
+  const inches = parseDouble(value);
+  return inches === void 0 ? Number.NaN : inches;
+}
+
+// src/stored-formula.ts
+var prefixes = ["_xlfn.", "_xlws.", "_xlpm."];
+function readStoredFormula(stored) {
+  const refusal = refusalOf(stored);
+  if (refusal !== "none") return { read: `=${stored}`, problem: refusal };
+  const anchored = anchorArrays(stripPrefixes(stored));
+  return { read: `=${anchored.text}`, problem: anchored.read ? "none" : "spillRange" };
+}
+function stripPrefixes(stored) {
+  let text = "";
+  let i = 0;
+  while (i < stored.length) {
+    const c = stored.charAt(i);
+    if (c === '"' || c === "'") {
+      const end = skipQuoted(stored, i);
+      text += stored.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (c === "_" && (text.length === 0 || !isNameChar(text.charAt(text.length - 1)))) {
+      const prefix = prefixes.find((p) => startsWithIgnoreCase(stored, i, p));
+      if (prefix !== void 0) {
+        i += prefix.length;
+        continue;
+      }
+    }
+    text += c;
+    i++;
+  }
+  return text;
+}
+function refusalOf(stored) {
+  for (let i = 0; i < stored.length; i++) {
+    const c = stored.charAt(i);
+    if (c === '"') {
+      i = skipQuoted(stored, i) - 1;
+      continue;
+    }
+    if (c === "'") {
+      if (i + 1 < stored.length && stored.charAt(i + 1) === "[") return "otherWorkbook";
+      i = skipQuoted(stored, i) - 1;
+      continue;
+    }
+    if (c === "[") {
+      const before = i > 0 ? stored.charAt(i - 1) : "\0";
+      if (isNameChar(before)) return "excelTable";
+      return /^\[[0-9]+\]/.test(stored.slice(i)) ? "otherWorkbook" : "excelTable";
+    }
+    if (c === "@") return "implicitIntersection";
+    if (c === "_" && (i === 0 || !isNameChar(stored.charAt(i - 1))) && startsWithIgnoreCase(stored, i, "_xlfn.SINGLE(")) return "implicitIntersection";
+  }
+  return "none";
+}
+var cellPattern = /^(?:'(?:[^']|'')+'!|[A-Za-z0-9_.\\]+!)?\$?[A-Za-z]{1,3}\$?[0-9]+$/;
+function anchorArrays(text) {
+  const name = "ANCHORARRAY(";
+  let written = "";
+  let anchored = false;
+  let at = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charAt(i);
+    if (c === '"' || c === "'") {
+      i = skipQuoted(text, i) - 1;
+      continue;
+    }
+    if (c !== "A" && c !== "a" || i > 0 && isNameChar(text.charAt(i - 1)) || !startsWithIgnoreCase(text, i, name)) continue;
+    const open = i + name.length;
+    let close = open;
+    while (close < text.length && text.charAt(close) !== ")") {
+      close = text.charAt(close) === '"' || text.charAt(close) === "'" ? skipQuoted(text, close) : close + 1;
+    }
+    const inner = close < text.length ? trimWhiteSpace(text.slice(open, close)) : "";
+    if (!cellPattern.test(inner)) return { text, read: false };
+    written += text.slice(at, i) + inner + "#";
+    anchored = true;
+    at = close + 1;
+    i = close;
+  }
+  return anchored ? { text: written + text.slice(at), read: true } : { text, read: true };
+}
+function skipQuoted(text, start) {
+  const quote = text.charAt(start);
+  let i = start + 1;
+  while (i < text.length) {
+    if (text.charAt(i) === quote) {
+      if (i + 1 < text.length && text.charAt(i + 1) === quote) {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i++;
+  }
+  return text.length;
+}
+function isNameChar(c) {
+  return /^[\p{L}\p{Nd}_.\\?]$/u.test(c);
+}
+
+// src/style-reading.ts
+import {
+  BorderLine,
+  CellBorders as CellBorders2,
+  CellColour,
+  CellFill as CellFill2,
+  CellFont as CellFont2,
+  CellFormat as CellFormat2,
+  NumberFormat as NumberFormat3
+} from "@ex-grid/sheet-engine";
+import {
+  defaultAlignment
+} from "@ex-grid/data-xlsx";
+
+// src/number-formats.ts
+import { NumberFormat as NumberFormat2 } from "@ex-grid/sheet-engine";
+import { firstCustomNumberFormat } from "@ex-grid/data-xlsx";
+var builtIns = /* @__PURE__ */ new Map([
+  [0, "General"],
+  [1, "0"],
+  [2, "0.00"],
+  [3, "#,##0"],
+  [4, "#,##0.00"],
+  [9, "0%"],
+  [10, "0.00%"],
+  [11, "0.00E+00"],
+  [12, "# ?/?"],
+  [13, "# ??/??"],
+  [14, "m/d/yyyy"],
+  [15, "d-mmm-yy"],
+  [16, "d-mmm"],
+  [17, "mmm-yy"],
+  [18, "h:mm AM/PM"],
+  [19, "h:mm:ss AM/PM"],
+  [20, "h:mm"],
+  [21, "h:mm:ss"],
+  [22, "m/d/yyyy h:mm"],
+  [37, "#,##0 ;(#,##0)"],
+  [38, "#,##0 ;[Red](#,##0)"],
+  [39, "#,##0.00;(#,##0.00)"],
+  [40, "#,##0.00;[Red](#,##0.00)"],
+  [45, "mm:ss"],
+  [46, "[h]:mm:ss"],
+  [47, "mmss.0"],
+  [48, "##0.0E+0"],
+  [49, "@"]
+]);
+var localised = /* @__PURE__ */ new Set([14, 15, 16, 20, 22]);
+var builtInCurrencies = ["$#,##0.00_);[Red]($#,##0.00)", "$#,##0_);[Red]($#,##0)"];
+function writtenCode(format, culture) {
+  return builtInCurrencies.some((c) => equalsIgnoreCase(c, format.code)) ? format.localCode(culture) : format.code;
+}
+function readNumberFormat(id, code) {
+  const builtIn = builtIns.get(id);
+  if (builtIn !== void 0) {
+    const reading2 = NumberFormat2.tryParse(builtIn);
+    if (reading2.format !== void 0) return { format: reading2.format };
+    return { reason: `Excel's built-in Number Format ${String(id)} (${builtIn}) is not one the engine reads: ${reading2.reason}`, held: builtIn };
+  }
+  if (code === void 0) {
+    return {
+      held: `Number Format ${String(id)}`,
+      reason: id < firstCustomNumberFormat ? `The cell takes Excel's built-in Number Format ${String(id)}, whose code follows the computer's locale, and the file does not spell it out.` : `The cell takes the Number Format ${String(id)}, which the file does not hold.`
+    };
+  }
+  const reading = NumberFormat2.tryParseAsWritten(code);
+  if (reading.format !== void 0) return { format: reading.format };
+  return { reason: `The Number Format '${code}' is not one the engine reads: ${reading.reason}`, held: code };
+}
+function builtInId(format) {
+  for (const [id, code] of builtIns) {
+    const same2 = localised.has(id) ? equalsIgnoreCase(code, format.code) : code === format.code;
+    if (same2) return id;
+  }
+  return format.isGeneral ? 0 : void 0;
+}
+
+// src/style-reading.ts
+var StyleReading = class {
+  #styles;
+  #theme;
+  #read = /* @__PURE__ */ new Map();
+  #workbookFont;
+  constructor(styles, theme) {
+    this.#styles = styles;
+    this.#theme = theme;
+    this.#workbookFont = elementAt(styles.fonts, 0);
+  }
+  /** The cell format at `index` of the styles' cell formats, read once. */
+  at(index) {
+    let format = this.#read.get(index);
+    if (format === void 0) {
+      format = this.#readFormat(elementAt(this.#styles.cellFormats, index));
+      this.#read.set(index, format);
+    }
+    return format;
+  }
+  #readFormat(xf) {
+    const styles = this.#styles;
+    const notCarried = [];
+    let namesTheme = false;
+    const note = (kind) => {
+      if (!notCarried.includes(kind)) notCarried.push(kind);
+    };
+    const colour = (color2) => {
+      if (color2 === null) return CellColour.automatic;
+      const argb = this.#theme.resolve(color2, styles.indexedColors);
+      if (argb === void 0) return CellColour.automatic;
+      namesTheme ||= color2.kind === "theme";
+      return CellColour.fromRgb(argb & 16777215);
+    };
+    let refusal;
+    let held2;
+    let numberFormat = NumberFormat3.general;
+    const read = readNumberFormat(xf.numberFormatId, styles.numberFormats.get(xf.numberFormatId));
+    if (read.format !== void 0) {
+      numberFormat = read.format;
+    } else {
+      refusal = read.reason;
+      held2 = read.held;
+    }
+    const a = xf.alignment === null ? defaultAlignment : xf.alignment;
+    let alignment;
+    switch (a.horizontal) {
+      case "general":
+      case "left":
+      case "center":
+      case "right":
+        alignment = a.horizontal;
+        break;
+      case "fill":
+      case "justify":
+      case "centerContinuous":
+      case "distributed":
+        note("horizontalAlignment");
+        break;
+      default:
+        return unreachableAlignment(a.horizontal);
+    }
+    if (a.vertical !== "bottom") note("verticalAlignment");
+    if (a.wrapText || a.indent !== 0 || a.textRotation !== 0 || a.shrinkToFit) note("textLayout");
+    const f = elementAt(styles.fonts, xf.fontId);
+    if (!sameFace(f, this.#workbookFont)) note("fontNamesAndSizes");
+    if (f.underline !== "none" && f.underline !== "single") note("underline");
+    const font = new CellFont2({ colour: this.#fontColour(f.color, colour), bold: f.bold, italic: f.italic, underline: f.underline !== "none", strikethrough: f.strike });
+    let fill = CellFill2.none;
+    const x = elementAt(styles.fills, xf.fillId);
+    if (x.isGradient || x.pattern !== "none" && x.pattern !== "solid") {
+      note("patternFills");
+    } else if (x.pattern === "solid") {
+      const solid = colour(x.foreground);
+      if (solid.isAutomatic) note("patternFills");
+      else fill = CellFill2.solid(solid);
+    }
+    const b = elementAt(styles.borders, xf.borderId);
+    if ((b.diagonalUp || b.diagonalDown) && b.diagonal.style !== "none") note("diagonalBorders");
+    const line = (edge2) => edge2.style === "none" ? BorderLine.none : new BorderLine(lineStyle(edge2.style), colour(edge2.color));
+    const borders = new CellBorders2({ top: line(b.top), bottom: line(b.bottom), left: line(b.left), right: line(b.right) });
+    return {
+      format: new CellFormat2(numberFormat, alignment === void 0 ? "general" : alignment, font, fill, borders),
+      refusal,
+      held: held2,
+      notCarried,
+      namesTheme
+    };
+  }
+  /**
+   * A Font's colour: the workbook font's own colour, where it paints black, is Automatic, the Ink, as Excel's own default
+   * text (Text 1 of the Office theme) is; any other is the RGB it resolves to.
+   */
+  #fontColour(color2, colour) {
+    const own = this.#workbookFont.color;
+    if (color2 !== null && own !== null && sameColor(color2, own)) {
+      const argb = this.#theme.resolve(color2, this.#styles.indexedColors);
+      if (argb === void 0 || argb >>> 0 === 4278190080 || argb === 0) return CellColour.automatic;
+    }
+    return colour(color2);
+  }
+};
+function unreachableAlignment(value) {
+  throw new Error(`Internal: ${String(value)} is not a horizontal alignment.`);
+}
+function sameColor(a, b) {
+  return a.kind === b.kind && a.value === b.value && a.tint === b.tint;
+}
+function sameFace(font, workbook) {
+  return (font.name === null || workbook.name !== null && equalsIgnoreCase(font.name, workbook.name)) && (font.size === null || font.size === workbook.size);
+}
+var fromFile = /* @__PURE__ */ new Map([
+  ["thin", "thin"],
+  ["medium", "medium"],
+  ["dashed", "dashed"],
+  ["dotted", "dotted"],
+  ["thick", "thick"],
+  ["double", "double"],
+  ["hair", "hair"],
+  ["mediumDashed", "mediumDashed"],
+  ["dashDot", "dashDot"],
+  ["mediumDashDot", "mediumDashDot"],
+  ["dashDotDot", "dashDotDot"],
+  ["mediumDashDotDot", "mediumDashDotDot"],
+  ["slantDashDot", "slantedDashDot"]
+]);
+function lineStyle(style) {
+  const engine = fromFile.get(style);
+  return engine === void 0 ? "none" : engine;
+}
+function fileLineStyle(style) {
+  for (const [file, engine] of fromFile) {
+    if (engine === style) return file;
+  }
+  return "none";
+}
+
+// src/reader.ts
+async function openXlsxWorkbook(file, culture, options) {
+  const workbookCulture = typeof culture === "string" ? Culture.of(culture) : culture;
+  let reader;
+  try {
+    reader = await openXlsx(file, options);
+  } catch (e) {
+    if (e instanceof XlsxError2) throw XlsxOpenError.fromFile(e);
+    throw e;
+  }
+  try {
+    return await new Mapping(reader, workbookCulture, options?.signal).read();
+  } catch (e) {
+    if (e instanceof XlsxError2) throw XlsxOpenError.fromFile(e);
+    throw e;
+  }
+}
+var days1904 = 1462;
+var filterDatabase = "_xlnm._FilterDatabase";
+var printArea = "_xlnm.Print_Area";
+var printTitles = "_xlnm.Print_Titles";
+var Mapping = class {
+  #reader;
+  #culture;
+  #signal;
+  #notCarried = [];
+  #unsupported = [];
+  #definedNames;
+  #hasExcelTables;
+  #dateStyles = /* @__PURE__ */ new Map();
+  #styles;
+  #namesTheme = false;
+  constructor(reader, culture, signal) {
+    this.#reader = reader;
+    this.#culture = culture;
+    this.#signal = signal;
+    this.#definedNames = new Set(reader.definedNames.map((n) => foldCase(n.name)));
+    this.#hasExcelTables = reader.parts.some((p) => startsWithIgnoreCase(p, 0, "xl/tables/"));
+    this.#styles = new StyleReading(reader.styles, reader.theme);
+  }
+  async read() {
+    const reader = this.#reader;
+    const worksheets = [];
+    const names = /* @__PURE__ */ new Map();
+    for (let i = 0; i < reader.sheets.length; i++) {
+      const info = elementAt(reader.sheets, i);
+      if (info.kind !== "worksheet" || info.part === null) {
+        this.#notCarried.push({
+          kind: "chartSheet",
+          sheet: info.name,
+          detail: null,
+          description: `The sheet '${info.name}' is not a worksheet (a chart sheet, or another that holds no cells), and is not opened.`
+        });
+        continue;
+      }
+      const why = Sheet3.whyNotAName(info.name);
+      if (why !== void 0) throw new XlsxOpenError("sheets", `The worksheet's name is not one a Sheet can have: ${why}`, { sheet: info.name });
+      const same2 = names.get(foldCase(info.name));
+      if (same2 !== void 0) {
+        throw new XlsxOpenError(
+          "sheets",
+          `The worksheets '${same2}' and '${info.name}' have names that differ only in case, which two Sheets of one Workbook cannot have.`,
+          { sheet: info.name }
+        );
+      }
+      names.set(foldCase(info.name), info.name);
+      worksheets.push(i);
+    }
+    if (worksheets.length === 0) throw new XlsxOpenError("sheets", "The workbook holds no worksheet, so it holds no cells to open.");
+    this.#workbookParts();
+    for (const name of reader.definedNames) {
+      const local = name.localSheet;
+      if (local !== null && worksheets.includes(local)) continue;
+      const shown = builtInName(name);
+      if (shown === void 0) continue;
+      const sheet = local !== null && local >= 0 && local < reader.sheets.length ? elementAt(reader.sheets, local).name : null;
+      this.#notCarried.push({ kind: "definedName", sheet, detail: shown, description: describeName(name, shown, sheet) });
+    }
+    const workbookEntries = this.#notCarried.length;
+    const sheets = [];
+    for (const index of worksheets) {
+      const info = elementAt(reader.sheets, index);
+      if (info.visibility !== "visible") {
+        this.#notCarried.push({ kind: "hiddenSheet", sheet: info.name, detail: null, description: `The Sheet '${info.name}' is hidden in the file, and opens shown.` });
+      }
+      let printNames = false;
+      for (const name of reader.definedNames) {
+        if (name.localSheet !== index) continue;
+        if (equalsIgnoreCase(name.name, printArea) || equalsIgnoreCase(name.name, printTitles)) {
+          printNames = true;
+        } else {
+          const shown = builtInName(name);
+          if (shown !== void 0) {
+            this.#notCarried.push({ kind: "definedName", sheet: info.name, detail: shown, description: describeName(name, shown, info.name) });
+          }
+        }
+      }
+      sheets.push(await this.#readSheet(index, printNames));
+    }
+    if (this.#namesTheme) {
+      this.#notCarried.splice(workbookEntries, 0, {
+        kind: "themeColours",
+        sheet: null,
+        detail: null,
+        description: "Colours of the workbook name its theme: each is carried as the RGB value the file's theme gives it, and the link to the theme is not, so another theme will not recolour them."
+      });
+    }
+    const shownIndex = worksheets.includes(reader.activeSheet) ? reader.activeSheet : elementAt(worksheets, 0);
+    const document = WorkbookDocument.of(this.#culture, elementAt(reader.sheets, shownIndex).name, sheets);
+    return { document, report: new OpenReport(this.#notCarried, this.#unsupported) };
+  }
+  /** What the workbook as a whole holds, beside its sheets, as its parts say. */
+  #workbookParts() {
+    const parts = this.#reader.parts;
+    const has = (folder) => parts.some((p) => startsWithIgnoreCase(p, 0, folder));
+    const add2 = (kind, description) => {
+      this.#notCarried.push({ kind, sheet: null, detail: null, description });
+    };
+    if (has("xl/pivotTables/")) add2("pivotTables", "The workbook holds PivotTables: the cells they show are carried as constants, the PivotTables are not.");
+    if (has("xl/externalLinks/")) add2("externalLinks", "The workbook holds links to other workbooks, which no Formula carried reads; they are not carried.");
+    if (has("xl/connections.xml") || has("xl/queryTables/")) {
+      add2("dataConnections", "The workbook holds connections to outside data, which are not carried; the cells they filled are carried as constants.");
+    }
+    if (has("xl/slicers/") || has("xl/slicerCaches/") || has("xl/timelines/") || has("xl/timelineCaches/")) {
+      add2("slicers", "The workbook holds slicers or timelines, which are not carried.");
+    }
+  }
+  async #readSheet(index, printNames) {
+    const sheet = await this.#reader.openSheet(index);
+    try {
+      const name = sheet.sheet.name;
+      const cells = [];
+      const shared = /* @__PURE__ */ new Map();
+      let spills = [];
+      let spillRow = -1;
+      let richCells = 0;
+      let firstRich;
+      const formats = [];
+      let columns;
+      const rowRuns = [];
+      const rowLevels = /* @__PURE__ */ new Map();
+      let lastRow;
+      while (await sheet.read()) {
+        this.#signal?.throwIfAborted();
+        columns ??= this.#readColumns(name, sheet.columns, formats);
+        rowLevels.clear();
+        if (lastRow !== void 0) rowLevels.set(lastRow.row, lastRow.level);
+        for (const row of sheet.rows) {
+          const level = this.#readRow(name, row, columns, formats);
+          rowLevels.set(row.row, level);
+          lastRow = { row: row.row, level };
+          addRun(rowRuns, row.row, level);
+        }
+        for (const cell of sheet.cells) {
+          const at = formatCell(cell.row, cell.column);
+          if (cell.isRichText) {
+            richCells++;
+            firstRich ??= at;
+          }
+          if (cell.row !== spillRow) {
+            spillRow = cell.row;
+            if (spills.length > 0) spills = spills.filter((s) => s.last.row >= spillRow);
+          }
+          const address = new CellAddress(cell.row, cell.column);
+          const entry = cell.formula !== null ? this.#formulaEntry(name, cell, at, cell.formula, shared, spills) : insideSpill(spills, address) ? void 0 : this.#constant(name, cell, at);
+          const rowLevel = rowLevels.get(cell.row);
+          const own = this.#readCell(name, cell, at, columns, rowLevel === void 0 ? FormatParts.empty : rowLevel, formats);
+          if (entry !== void 0 || !own.isEmpty) {
+            cells.push(new SheetDocumentCell(address, entry, own.numberFormat, own.alignment, own.font, own.fill, own.borders));
+          }
+        }
+      }
+      columns ??= this.#readColumns(name, sheet.columns, formats);
+      this.#sheetElements(name, sheet, richCells, firstRich, printNames, formats);
+      return SheetDocument.of(this.#culture, name, cells, { columns: columns.runs, rows: rowRuns, columnWidths: widths(sheet.columns) });
+    } finally {
+      await sheet.close();
+    }
+  }
+  /** The cell format at `style`, refusing the file where a level records a Number Format that cannot cross. */
+  #format(sheet, style, place, formats) {
+    const format = this.#styles.at(style);
+    if (format.refusal !== void 0) throw new XlsxOpenError("numberFormat", format.refusal, { sheet, cell: place, held: format.held });
+    this.#namesTheme ||= format.namesTheme;
+    for (const kind of format.notCarried) {
+      if (!formats.some((f) => f.kind === kind)) formats.push({ kind, detail: place });
+    }
+    return format;
+  }
+  #readColumns(sheet, columns, formats) {
+    const byColumn = /* @__PURE__ */ new Map();
+    const runs = [];
+    for (const range of byFirst(columns)) {
+      if (range.styleIndex === 0) continue;
+      const place = `${CellAddress.columnName(range.first)}:${CellAddress.columnName(range.last)}`;
+      const level = FormatParts.differing(this.#format(sheet, range.styleIndex, place, formats).format, defaultFormat);
+      if (level.isEmpty) continue;
+      for (let c = range.first; c <= range.last; c++) byColumn.set(c, level);
+      const last = runs.at(-1);
+      if (last !== void 0 && last.last === range.first - 1 && partsOf(last).equals(level)) {
+        runs[runs.length - 1] = axisFormat(last.first, range.last, level);
+      } else {
+        runs.push(axisFormat(range.first, range.last, level));
+      }
+    }
+    const recorded = new FormatParts(
+      runs.some((r) => r.numberFormat !== void 0) ? NumberFormat4.general : void 0,
+      runs.some((r) => r.alignment !== void 0) ? "general" : void 0,
+      runs.some((r) => r.font !== void 0) ? CellFont3.default : void 0,
+      runs.some((r) => r.fill !== void 0) ? CellFill3.none : void 0,
+      runs.some((r) => r.borders !== void 0) ? CellBorders3.none : void 0
+    );
+    return { byColumn, runs, recorded };
+  }
+  /**
+   * A formatted row's level: each part that differs from the default, and each part a column records, so that the row
+   * stands in place of its columns as in the file.
+   */
+  #readRow(sheet, row, columns, formats) {
+    const number = String(row.row + 1);
+    const format = this.#format(sheet, row.styleIndex, `${number}:${number}`, formats).format;
+    const differing = FormatParts.differing(format, defaultFormat);
+    const recorded = columns.recorded;
+    return new FormatParts(
+      differing.numberFormat ?? (recorded.numberFormat === void 0 ? void 0 : format.numberFormat),
+      differing.alignment ?? (recorded.alignment === void 0 ? void 0 : format.alignment),
+      differing.font ?? (recorded.font === void 0 ? void 0 : format.font),
+      differing.fill ?? (recorded.fill === void 0 ? void 0 : format.fill),
+      differing.borders ?? (recorded.borders === void 0 ? void 0 : format.borders)
+    );
+  }
+  /** A cell's own level: the parts of its format that differ from what its row and column give it. In the file a cell's format stands alone. */
+  #readCell(sheet, cell, at, columns, row, formats) {
+    const format = this.#format(sheet, cell.styleIndex, at, formats).format;
+    const level = columns.byColumn.get(cell.column);
+    const column = level === void 0 ? FormatParts.empty : level;
+    return FormatParts.differing(format, row.over(column.over(defaultFormat)));
+  }
+  #formulaEntry(sheet, cell, at, formula, shared, spills) {
+    switch (formula.kind) {
+      case "dataTable":
+        throw new XlsxOpenError(
+          "unreadableFormula",
+          "The cell is part of a What-If data table, which the engine does not compute.",
+          { sheet, cell: at, held: held(formula.text) }
+        );
+      case "array":
+        if (!formula.isDynamicArray) {
+          throw new XlsxOpenError(
+            "legacyArrayFormula",
+            "The cell holds a legacy array formula (entered with Ctrl+Shift+Enter), which Excel computes as one over its cells and ExSheet would spill instead.",
+            { sheet, cell: at, held: `{${held(formula.text)}}` }
+          );
+        }
+        break;
+      case "shared":
+        if (formula.text.length === 0) {
+          const master = formula.sharedIndex === null ? void 0 : shared.get(formula.sharedIndex);
+          if (master === void 0) {
+            const index = formula.sharedIndex === null ? "" : String(formula.sharedIndex);
+            throw new XlsxOpenError("unreadableFormula", `The cell takes the shared formula ${index}, whose first cell does not come before it.`, { sheet, cell: at });
+          }
+          const moved = master.entry.movedBy(cell.row - master.row, cell.column - master.column);
+          this.#report(sheet, at, master.unsupported);
+          return moved;
+        }
+        break;
+      case "normal":
+        break;
+    }
+    const { entry, unsupported } = this.#readFormula(sheet, at, formula.text);
+    this.#report(sheet, at, unsupported);
+    if (formula.kind === "shared" && formula.sharedIndex !== null) {
+      shared.set(formula.sharedIndex, { entry, row: cell.row, column: cell.column, unsupported });
+    }
+    if (formula.kind === "array" && formula.reference !== null) {
+      const spill = rangeOf(formula.reference);
+      if (spill !== void 0) spills.push(spill);
+    }
+    return entry;
+  }
+  /** Reads a Formula's stored text into its Entry, refusing what would read wrongly, with the functions it names that ExSheet does not support. */
+  #readFormula(sheet, at, stored) {
+    const { read: text, problem } = readStoredFormula(stored);
+    const where = { sheet, cell: at, held: text };
+    switch (problem) {
+      case "otherWorkbook":
+        throw new XlsxOpenError("otherWorkbook", "The Formula reads another workbook, which ExSheet cannot reach.", where);
+      case "excelTable":
+        throw new XlsxOpenError("excelTable", "The Formula reads an Excel Table, which ExSheet does not read.", where);
+      case "implicitIntersection":
+        throw new XlsxOpenError("unreadableFormula", "The Formula uses the implicit intersection operator (@), which the engine does not read.", where);
+      case "spillRange":
+        throw new XlsxOpenError("unreadableFormula", "The Formula reads a Spill Range in a form the engine does not read.", where);
+      case "none":
+        break;
+    }
+    let entry;
+    try {
+      entry = defined(Entry.parse(text, Culture.invariant), "the Entry of a Formula");
+    } catch (e) {
+      if (e instanceof FormulaSyntaxError) throw new XlsxOpenError("unreadableFormula", `The engine cannot read the Formula: ${e.message}`, where, { cause: e });
+      throw e;
+    }
+    for (const name of entry.unboundNames) {
+      if (this.#definedNames.has(foldCase(name))) {
+        throw new XlsxOpenError("definedName", `The Formula reads the defined name '${name}', which ExSheet does not define.`, where);
+      }
+      if (this.#hasExcelTables) {
+        throw new XlsxOpenError(
+          "excelTable",
+          `The Formula reads the name '${name}', which the workbook does not define; it holds Excel Tables, which a name can read, and ExSheet does not read them.`,
+          where
+        );
+      }
+    }
+    const functions = entry.undeclaredFunctions;
+    const lambda = functions.find((f) => this.#definedNames.has(foldCase(f)));
+    if (lambda !== void 0) throw new XlsxOpenError("definedName", `The Formula calls the defined name '${lambda}', which ExSheet does not define.`, where);
+    return { entry, unsupported: functions };
+  }
+  #report(sheet, cell, functions) {
+    if (functions.length > 0) this.#unsupported.push({ sheet, cell, functions });
+  }
+  /** A constant's Entry, or `undefined` for a cell that holds none (a cell with a style only). */
+  #constant(sheet, cell, at) {
+    const value = cell.value;
+    switch (cell.type) {
+      case "sharedString":
+      case "inlineString":
+        return Entry.fromValue(Value.fromText(cell.text === null ? "" : cell.text));
+      case "formulaString":
+        return value === null ? void 0 : Entry.fromValue(Value.fromText(value));
+      case "number": {
+        if (value === null) return void 0;
+        let number = parseDouble(value);
+        if (number === void 0 || !Number.isFinite(number)) {
+          throw new XlsxOpenError("unreadableConstant", "The cell's number cannot be read.", { sheet, cell: at, held: value });
+        }
+        if (this.#reader.date1904 && this.#showsDate(cell.styleIndex)) number += days1904;
+        return Entry.fromValue(Value.fromNumber(number));
+      }
+      case "boolean":
+        switch (value) {
+          case "1":
+          case "true":
+            return Entry.fromValue(Value.fromBoolean(true));
+          case "0":
+          case "false":
+            return Entry.fromValue(Value.fromBoolean(false));
+          case null:
+            return void 0;
+          default:
+            throw new XlsxOpenError("unreadableConstant", "The cell's boolean cannot be read.", { sheet, cell: at, held: value });
+        }
+      case "error": {
+        if (value === null) return void 0;
+        const error = Entry.fromErrorText(value);
+        if (error !== void 0) return error;
+        throw new XlsxOpenError("unreadableConstant", "The cell holds an Error Value a cell of ExSheet cannot hold.", { sheet, cell: at, held: value });
+      }
+      case "date": {
+        if (value === null) return void 0;
+        const serial = isoDateSerial(value);
+        if (serial === void 0) {
+          throw new XlsxOpenError(
+            "unreadableConstant",
+            "The cell's date is not an ISO 8601 date or time, or lies outside the dates a serial counts.",
+            { sheet, cell: at, held: value }
+          );
+        }
+        return Entry.fromValue(Value.fromNumber(serial));
+      }
+      default:
+        return unreachable(cell.type);
+    }
+  }
+  /** Whether the cell format at `style` shows a date (its serial moves from 1904's to 1900's). */
+  #showsDate(style) {
+    const known = this.#dateStyles.get(style);
+    if (known !== void 0) return known;
+    const styles = this.#reader.styles;
+    const id = elementAt(styles.cellFormats, style).numberFormatId;
+    const shows = showsDate(id, styles.numberFormats.get(id));
+    this.#dateStyles.set(style, shows);
+    return shows;
+  }
+  /** What else a worksheet held, as the file layer reports it, said once per Sheet and kind. */
+  #sheetElements(sheet, read, richCells, firstRich, printNames, formats) {
+    const kinds = [];
+    const add2 = (kind, detail) => {
+      if (!kinds.some((k) => k.kind === kind && k.detail === detail)) kinds.push({ kind, detail });
+    };
+    if (read.customRowHeights) add2("rowHeights");
+    if (read.hiddenRows) add2("hiddenRows");
+    if (read.columns.some((c) => c.hidden || c.width !== null && c.width <= 0)) add2("hiddenColumns");
+    if (read.frozenPanes) add2("frozenPanes");
+    for (const element of read.otherElements) {
+      for (const { kind, detail } of elementNotCarried(element)) add2(kind, detail);
+    }
+    if (printNames) add2("printSettings");
+    if (richCells > 0) add2("richText", firstRich);
+    for (const { kind, detail } of formats) add2(kind, detail);
+    for (const { kind, detail } of kinds) {
+      this.#notCarried.push({ kind, sheet, detail: detail === void 0 ? null : detail, description: describe(kind, sheet, detail, richCells) });
+    }
+  }
+};
+function builtInName(name) {
+  return equalsIgnoreCase(name.name, filterDatabase) ? void 0 : name.name;
+}
+function describeName(name, shown, sheet) {
+  return sheet === null ? `The defined name '${shown}' (${name.text}) is not carried; no Formula carried reads it.` : `The defined name '${shown}' of the sheet '${sheet}' (${name.text}) is not carried; no Formula carried reads it.`;
+}
+function byFirst(columns) {
+  return columns.toSorted((a, b) => a.first - b.first);
+}
+function axisFormat(first, last, level) {
+  return new SheetDocumentAxisFormat(first, last, level.numberFormat, level.alignment, level.font, level.fill, level.borders);
+}
+function addRun(runs, row, level) {
+  if (level.isEmpty) return;
+  const last = runs.at(-1);
+  if (last !== void 0 && last.last === row - 1 && partsOf(last).equals(level)) {
+    runs[runs.length - 1] = axisFormat(last.first, row, level);
+  } else {
+    runs.push(axisFormat(row, row, level));
+  }
+}
+function widths(columns) {
+  const runs = [];
+  for (const range of byFirst(columns)) {
+    if (range.width === null) continue;
+    const characters = readWidth(range.width);
+    if (characters === void 0) continue;
+    const kind = range.bestFit ? "widenedByEntry" : "setByUser";
+    const last = runs.at(-1);
+    if (last !== void 0 && last.last === range.first - 1 && last.width === characters && last.kind === kind) {
+      runs[runs.length - 1] = new SheetDocumentColumnWidth(last.first, range.last, characters, kind);
+    } else {
+      runs.push(new SheetDocumentColumnWidth(range.first, range.last, characters, kind));
+    }
+  }
+  return runs;
+}
+function held(stored) {
+  return `=${stripPrefixes(stored)}`;
+}
+function insideSpill(spills, cell) {
+  return spills.some((s) => s.contains(cell));
+}
+function rangeOf(text) {
+  const colon = text.indexOf(":");
+  const first = parseCell(colon < 0 ? text : text.slice(0, colon));
+  const last = parseCell(colon < 0 ? text : text.slice(colon + 1));
+  if (first === void 0 || last === void 0) return void 0;
+  return new CellRange(new CellAddress(first.row, first.column), new CellAddress(last.row, last.column));
+}
+function describe(kind, sheet, detail, richCells) {
+  const at = detail === void 0 ? "" : detail;
+  switch (kind) {
+    case "rowHeights":
+      return `Rows of '${sheet}' have heights of their own, which are not carried.`;
+    case "hiddenRows":
+      return `Rows of '${sheet}' are hidden in the file, and open shown.`;
+    case "hiddenColumns":
+      return `Columns of '${sheet}' are hidden in the file, and open shown.`;
+    case "frozenPanes":
+      return `'${sheet}' has frozen panes, which are not carried.`;
+    case "mergedCells":
+      return `'${sheet}' has merged cells; each cell is carried on its own.`;
+    case "conditionalFormatting":
+      return `'${sheet}' has conditional formatting, which is not carried.`;
+    case "dataValidation":
+      return `'${sheet}' has data validation, which is not carried.`;
+    case "notesAndComments":
+      return `'${sheet}' has notes or comments, which are not carried.`;
+    case "hyperlinks":
+      return `'${sheet}' has hyperlinks; their cells' text is carried, the links are not.`;
+    case "picturesAndCharts":
+      return `'${sheet}' has pictures, charts, shapes or controls, which are not carried.`;
+    case "protection":
+      return `'${sheet}' is protected in the file; the protection is not carried.`;
+    case "printSettings":
+      return `'${sheet}' has print settings beyond Excel's defaults (margins, a header or footer, page breaks, a print area, a scale or the like), which are not carried.`;
+    case "view":
+      return `'${sheet}' has view settings (hidden gridlines, headings or zeros, Formulas shown, right to left, a zoom or a page layout), which are not carried.`;
+    case "autoFilter":
+      return `'${sheet}' has an AutoFilter, which is not carried; every row opens shown.`;
+    case "excelTable":
+      return `'${sheet}' has Excel Tables; their cells are carried, the Tables are not.`;
+    case "slicers":
+      return `'${sheet}' has slicers or timelines, which are not carried.`;
+    case "sheetProperties":
+      return `The tab colour of '${sheet}' is not carried.`;
+    case "richText":
+      return `${String(richCells)} cell(s) of '${sheet}', the first ${at}, hold rich text: the text is carried, the runs' own formatting is not.`;
+    case "defaultColumnWidth":
+      return `'${sheet}' has a default column width of its own, which is not carried; its columns without a width of their own open at the default width.`;
+    case "fontNamesAndSizes":
+      return `Cells of '${sheet}', the first at ${at}, use a typeface or a size other than the workbook's own, which is not carried; they open in the Sheet's font.`;
+    case "verticalAlignment":
+      return `Cells of '${sheet}', the first at ${at}, are aligned vertically, which is not carried.`;
+    case "textLayout":
+      return `Cells of '${sheet}', the first at ${at}, wrap, indent, rotate or shrink their text, which is not carried.`;
+    case "horizontalAlignment":
+      return `Cells of '${sheet}', the first at ${at}, are aligned to fill, justify, distribute or centre across the selection, which is not carried; they open aligned as General.`;
+    case "underline":
+      return `Cells of '${sheet}', the first at ${at}, are underlined twice or for accounting; they open with a single underline.`;
+    case "patternFills":
+      return `Cells of '${sheet}', the first at ${at}, have a pattern or gradient fill, or a solid fill of no colour, which is not carried; they open with no Fill.`;
+    case "diagonalBorders":
+      return `Cells of '${sheet}', the first at ${at}, have diagonal borders, which are not carried; their four sides are.`;
+    // Said of the workbook, never of a Sheet's elements; an element the file layer names is said by its name.
+    case "chartSheet":
+    case "dataConnections":
+    case "definedName":
+    case "externalLinks":
+    case "hiddenSheet":
+    case "other":
+    case "pivotTables":
+    case "themeColours":
+    default:
+      return `'${sheet}' holds <${at}>, which is not carried.`;
+  }
+}
+
+// src/writer.ts
+import {
+  CellAddress as CellAddress3,
+  Sheet as Sheet5
+} from "@ex-grid/sheet-engine";
+import {
+  createXlsxWriter,
+  defaultMaxCells,
+  defaultMaxUncompressedBytes,
+  formatCell as formatCell2,
+  isValidTableName,
+  maxColumns,
+  maxRows,
+  XlsxError as XlsxError3
+} from "@ex-grid/data-xlsx";
+
+// src/save-error.ts
+var XlsxSaveError = class extends Error {
+  /** Why the Workbook was not written. */
+  reason;
+  /** The name of the Sheet the refusal met, or `undefined` when it is not about one Sheet. */
+  sheet;
+  /** The cell the refusal met, as `B7`, or `undefined` when it is not about one cell. */
+  cell;
+  /** What the cell held — a Formula's text with its `=` — or `undefined`. */
+  held;
+  /**
+   * A refusal naming what it met.
+   * @param reason - Why the Workbook is not written.
+   * @param message - What was wrong, as a sentence that follows the Sheet and the cell.
+   * @param where - The Sheet, the cell and what the cell held, as far as it is about one.
+   */
+  constructor(reason, message, where = {}) {
+    super(formatted(where.sheet, where.cell, where.held, message));
+    this.name = "XlsxSaveError";
+    this.reason = reason;
+    this.sheet = where.sheet;
+    this.cell = where.cell;
+    this.held = where.held;
+  }
+};
+
+// src/save-pacer.ts
+var batch = 256;
+function macrotask() {
+  return new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+}
+var SavePacer = class {
+  #budget;
+  #yield;
+  #onProgress;
+  #signal;
+  #sliceStart = performance.now();
+  #sinceLook = 0;
+  /** The worksheets the file holds. */
+  sheets = 0;
+  /** The elements the file writes; 0 until the snapshot is planned. */
+  total = 0;
+  /** The worksheet being written; -1 while the snapshot is planned. */
+  sheet = -1;
+  /** The elements written so far. */
+  written = 0;
+  constructor(options) {
+    const budget = options.sliceBudgetMs === void 0 ? 30 : options.sliceBudgetMs;
+    if (typeof budget !== "number" || Number.isNaN(budget)) throw new TypeError(`The slice budget ${String(budget)} is not a number of milliseconds.`);
+    this.#budget = Math.max(0, budget);
+    this.#yield = options.yield === void 0 ? macrotask : options.yield;
+    this.#onProgress = options.onProgress;
+    this.#signal = options.signal;
+  }
+  /** Throws the signal's reason when the write is cancelled. */
+  cancelled() {
+    this.#signal?.throwIfAborted();
+  }
+  /**
+   * One step of work, which wrote `elements` (none while the snapshot is planned); every batch of steps answers the
+   * checkpoint to await, and every other step nothing, so a step costs no turn of the event loop.
+   */
+  step(elements = 1) {
+    this.written += elements;
+    if (++this.#sinceLook < batch) return void 0;
+    this.#sinceLook = 0;
+    return this.checkpoint();
+  }
+  /** Looks at the signal and, past the budget, reports the progress and yields. */
+  async checkpoint() {
+    this.cancelled();
+    if (performance.now() < this.#sliceStart + this.#budget) return;
+    this.report();
+    await this.#yield();
+    this.cancelled();
+    this.#sliceStart = performance.now();
+  }
+  /** Tells the progress as it stands. */
+  report() {
+    this.#onProgress?.({
+      sheet: this.sheet,
+      sheets: this.sheets,
+      elements: this.sheet < 0 ? 0 : this.written,
+      totalElements: this.sheet < 0 ? 0 : this.total
+    });
+  }
+};
+
+// src/style-table.ts
+import {
+  defaultAlignment as defaultAlignment2,
+  firstCustomNumberFormat as firstCustomNumberFormat2,
+  gray125Fill,
+  noBorder,
+  noBorderEdge,
+  noFill,
+  rgbColor,
+  solidFill
+} from "@ex-grid/data-xlsx";
+var workbookFont = Object.freeze({ name: "Calibri", size: 11, bold: false, italic: false, underline: "none", strike: false, color: null });
+var StyleTable = class {
+  #formats = /* @__PURE__ */ new Map();
+  #cellFormats = [];
+  #codes = /* @__PURE__ */ new Map();
+  #fonts = /* @__PURE__ */ new Map();
+  #fills = /* @__PURE__ */ new Map();
+  #borders = /* @__PURE__ */ new Map();
+  #culture;
+  /** A table for a Workbook of `culture`, holding the default Cell Format. */
+  constructor(culture) {
+    this.#culture = culture;
+    this.#font(workbookFont);
+    this.#fill(noFill);
+    this.#fill(gray125Fill);
+    this.#border(noBorder);
+    this.index(defaultFormat);
+  }
+  /** The index of the cell format that writes `format`, added when it is new. */
+  index(format) {
+    const known = this.#formats.get(format.key);
+    if (known !== void 0) return known;
+    const id = builtInId(format.numberFormat);
+    const numberFormat = id === void 0 ? this.#code(writtenCode(format.numberFormat, this.#culture)) : id;
+    const f = format.font;
+    const font = this.#font({
+      ...workbookFont,
+      bold: f.bold,
+      italic: f.italic,
+      underline: f.underline ? "single" : "none",
+      strike: f.strikethrough,
+      color: color(f.colour)
+    });
+    const fill = format.fill.colour === void 0 ? 0 : this.#fill(solidFill(solidColor(format.fill.colour)));
+    const b = format.borders;
+    const border = this.#border({
+      left: edge(b.left),
+      right: edge(b.right),
+      top: edge(b.top),
+      bottom: edge(b.bottom),
+      diagonal: noBorderEdge,
+      diagonalUp: false,
+      diagonalDown: false
+    });
+    let alignment;
+    switch (format.alignment) {
+      case "left":
+      case "center":
+      case "right":
+        alignment = { ...defaultAlignment2, horizontal: format.alignment };
+        break;
+      case "general":
+        alignment = null;
+        break;
+      default:
+        return unreachableAlignment2(format.alignment);
+    }
+    const index = this.#cellFormats.length;
+    this.#cellFormats.push({ numberFormatId: numberFormat, fontId: font, fillId: fill, borderId: border, alignment });
+    this.#formats.set(format.key, index);
+    return index;
+  }
+  /** The styles part, holding every format met so far. */
+  build() {
+    return {
+      numberFormats: new Map([...this.#codes].map(([code, id]) => [id, code])),
+      fonts: [...this.#fonts.values()].map(([font]) => font),
+      fills: [...this.#fills.values()].map(([fill]) => fill),
+      borders: [...this.#borders.values()].map(([border]) => border),
+      cellFormats: [...this.#cellFormats],
+      indexedColors: null
+    };
+  }
+  #code(code) {
+    let id = this.#codes.get(code);
+    if (id === void 0) {
+      id = firstCustomNumberFormat2 + this.#codes.size;
+      this.#codes.set(code, id);
+    }
+    return id;
+  }
+  #font(font) {
+    return add(this.#fonts, `${String(font.name)}|${String(font.size)}|${String(font.bold)}|${String(font.italic)}|${font.underline}|${String(font.strike)}|${colorKey(font.color)}`, font);
+  }
+  #fill(fill) {
+    return add(this.#fills, `${String(fill.pattern)}|${colorKey(fill.foreground)}|${colorKey(fill.background)}|${String(fill.isGradient)}`, fill);
+  }
+  #border(border) {
+    return add(this.#borders, `${edgeKey(border.left)}|${edgeKey(border.right)}|${edgeKey(border.top)}|${edgeKey(border.bottom)}|${edgeKey(border.diagonal)}|${String(border.diagonalUp)}|${String(border.diagonalDown)}`, border);
+  }
+};
+function add(table, key, item) {
+  const known = table.get(key);
+  if (known !== void 0) return known[1];
+  const index = table.size;
+  table.set(key, [item, index]);
+  return index;
+}
+function colorKey(c) {
+  return c === null ? "-" : `${c.kind}:${String(c.value)}:${String(c.tint)}`;
+}
+function edgeKey(side) {
+  return `${side.style}:${colorKey(side.color)}`;
+}
+function color(colour) {
+  return colour.isAutomatic ? null : rgbColor((4278190080 | colour.rgb) >>> 0);
+}
+function solidColor(colour) {
+  const written = color(colour);
+  if (written === null) throw new Error("Internal: a solid Fill has no colour.");
+  return written;
+}
+function edge(line) {
+  return line.isNone ? noBorderEdge : { style: fileLineStyle(line.style), color: color(line.colour) };
+}
+function unreachableAlignment2(value) {
+  throw new Error(`Internal: ${String(value)} is not a horizontal alignment.`);
+}
+
+// src/written-formula.ts
+import { CellAddress as CellAddress2, DeclaredFunction, Sheet as Sheet4 } from "@ex-grid/sheet-engine";
+var newerFunctions = Object.freeze([
+  "ACOT",
+  "ACOTH",
+  "AGGREGATE",
+  "ARABIC",
+  "ARRAYTOTEXT",
+  "BASE",
+  "BETA.DIST",
+  "BETA.INV",
+  "BINOM.DIST",
+  "BINOM.DIST.RANGE",
+  "BINOM.INV",
+  "BITAND",
+  "BITLSHIFT",
+  "BITOR",
+  "BITRSHIFT",
+  "BITXOR",
+  "BYCOL",
+  "BYROW",
+  "CEILING.MATH",
+  "CEILING.PRECISE",
+  "CHISQ.DIST",
+  "CHISQ.DIST.RT",
+  "CHISQ.INV",
+  "CHISQ.INV.RT",
+  "CHISQ.TEST",
+  "CHOOSECOLS",
+  "CHOOSEROWS",
+  "COMBINA",
+  "CONCAT",
+  "CONFIDENCE.NORM",
+  "CONFIDENCE.T",
+  "COPILOT",
+  "COT",
+  "COTH",
+  "COVARIANCE.P",
+  "COVARIANCE.S",
+  "CSC",
+  "CSCH",
+  "DAYS",
+  "DECIMAL",
+  "DETECTLANGUAGE",
+  "DROP",
+  "ECMA.CEILING",
+  "ENCODEURL",
+  "ERF.PRECISE",
+  "ERFC.PRECISE",
+  "EXPAND",
+  "EXPON.DIST",
+  "F.DIST",
+  "F.DIST.RT",
+  "F.INV",
+  "F.INV.RT",
+  "F.TEST",
+  "FIELDVALUE",
+  "FILTER",
+  "FILTERXML",
+  "FLOOR.MATH",
+  "FLOOR.PRECISE",
+  "FORECAST.ETS",
+  "FORECAST.ETS.CONFINT",
+  "FORECAST.ETS.SEASONALITY",
+  "FORECAST.ETS.STAT",
+  "FORECAST.LINEAR",
+  "FORMULATEXT",
+  "GAMMA",
+  "GAMMA.DIST",
+  "GAMMA.INV",
+  "GAMMALN.PRECISE",
+  "GAUSS",
+  "GROUPBY",
+  "HSTACK",
+  "HYPGEOM.DIST",
+  "IFNA",
+  "IFS",
+  "IMAGE",
+  "IMCOSH",
+  "IMCOT",
+  "IMCSC",
+  "IMCSCH",
+  "IMSEC",
+  "IMSECH",
+  "IMSINH",
+  "IMTAN",
+  "ISFORMULA",
+  "ISOMITTED",
+  "ISOWEEKNUM",
+  "LAMBDA",
+  "LET",
+  "LOGNORM.DIST",
+  "LOGNORM.INV",
+  "MAKEARRAY",
+  "MAP",
+  "MAXIFS",
+  "MINIFS",
+  "MODE.MULT",
+  "MODE.SNGL",
+  "MUNIT",
+  "NEGBINOM.DIST",
+  "NETWORKDAYS.INTL",
+  "NORM.DIST",
+  "NORM.INV",
+  "NORM.S.DIST",
+  "NORM.S.INV",
+  "NUMBERVALUE",
+  "PDURATION",
+  "PERCENTILE.EXC",
+  "PERCENTILE.INC",
+  "PERCENTOF",
+  "PERCENTRANK.EXC",
+  "PERCENTRANK.INC",
+  "PERMUTATIONA",
+  "PHI",
+  "PIVOTBY",
+  "POISSON.DIST",
+  "QUARTILE.EXC",
+  "QUARTILE.INC",
+  "RANDARRAY",
+  "RANK.AVG",
+  "RANK.EQ",
+  "REDUCE",
+  "REGEXEXTRACT",
+  "REGEXREPLACE",
+  "REGEXTEST",
+  "RRI",
+  "SCAN",
+  "SEC",
+  "SECH",
+  "SEQUENCE",
+  "SHEET",
+  "SHEETS",
+  "SKEW.P",
+  "SORT",
+  "SORTBY",
+  "STDEV.P",
+  "STDEV.S",
+  "STOCKHISTORY",
+  "SWITCH",
+  "T.DIST",
+  "T.DIST.2T",
+  "T.DIST.RT",
+  "T.INV",
+  "T.INV.2T",
+  "T.TEST",
+  "TAKE",
+  "TEXTAFTER",
+  "TEXTBEFORE",
+  "TEXTJOIN",
+  "TEXTSPLIT",
+  "TOCOL",
+  "TOROW",
+  "TRANSLATE",
+  "TRIMRANGE",
+  "UNICHAR",
+  "UNICODE",
+  "UNIQUE",
+  "VALUETOTEXT",
+  "VAR.P",
+  "VAR.S",
+  "VSTACK",
+  "WEBSERVICE",
+  "WEIBULL.DIST",
+  "WORKDAY.INTL",
+  "WRAPCOLS",
+  "WRAPROWS",
+  "XLOOKUP",
+  "XMATCH",
+  "XOR",
+  "Z.TEST"
+]);
+var newer = new Set(newerFunctions.map(foldCase));
+function isNewerFunction(name) {
+  return newer.has(foldCase(name));
+}
+var worksheetOnly = /* @__PURE__ */ new Set(["FILTER", "SORT"]);
+var errors = ["#NULL!", "#DIV/0!", "#VALUE!", "#REF!", "#NAME?", "#NUM!", "#N/A"];
+var maxText = 255;
+var maxDepth = 64;
+var maxArguments = 255;
+var unseenInColumns = /[@,:."{}$^&*+=\-<>/\t\n\r]/;
+var Token = class {
+  kind;
+  text;
+  /** A Reference written with `#` after it: the Spill Range of the Formula in that cell. */
+  spilled;
+  /** The Sheet a Reference names, unquoted, or `undefined` for one of its own Sheet; for a 3D Reference, the Sheet its span
+   * begins on. */
+  sheet;
+  /** For a 3D Reference (`Sheet1:Sheet3!B2`), the Sheet its span ends on, unquoted. */
+  lastSheet;
+  /** A name that a `(` follows: a function's. */
+  called;
+  /** A name a `LET` binds or a `LAMBDA` takes, or a use of one where it is bound. */
+  bound = false;
+  constructor(kind, text, more = {}) {
+    this.kind = kind;
+    this.text = text;
+    this.spilled = more.spilled === true;
+    this.sheet = more.sheet;
+    this.lastSheet = more.lastSheet;
+    this.called = more.called === true;
+  }
+};
+function writeFormula(entry, hasSheet, columnsOf) {
+  const formula = entry.formula;
+  if (formula === void 0) throw new Error("Internal: only a Formula Entry is written as a Formula.");
+  const refused = (problem) => ({ text: formula.slice(1), problem });
+  const split = splitFormula(formula, columnsOf);
+  if (split.problem !== "none") return refused(split.problem);
+  const tokens = split.tokens;
+  if (hasSheet !== void 0 && tokens.some((t) => t.sheet !== void 0 && !hasSheet(t.sheet) || t.lastSheet !== void 0 && !hasSheet(t.lastSheet))) {
+    return refused("missingSheet");
+  }
+  const bound = bind(tokens);
+  if (bound !== "none") return refused(bound);
+  if (columnsOf !== void 0 && tokens.some((t) => t.kind === "name" && !t.called && !t.bound && columnsOf(t.text) !== void 0)) return refused("tableName");
+  if (tokens.some((t) => t.kind === "text" && t.text.length - 2 - count(t.text, '""') > maxText)) return refused("longText");
+  if (!sameUnbound(tokens, entry.unboundNames)) return refused("unreadable");
+  let text = "";
+  for (const token of tokens) {
+    if (token.kind === "reference" && token.spilled) text += `_xlfn.ANCHORARRAY(${token.text})`;
+    else if (token.kind === "name" && token.bound) text += `_xlpm.${token.text}`;
+    else if (token.kind === "name" && token.called && isNewerFunction(token.text)) text += (worksheetOnly.has(foldCase(token.text)) ? "_xlfn._xlws." : "_xlfn.") + token.text;
+    else text += token.text;
+  }
+  return { text, problem: "none" };
+}
+function count(text, of) {
+  let n = 0;
+  for (let at = text.indexOf(of); at >= 0; at = text.indexOf(of, at + of.length)) n++;
+  return n;
+}
+var referencePattern = new RegExp(
+  String.raw`(?:(?<sheet>'(?:[^']|'')+'|[A-Za-z_][A-Za-z0-9_.]*)!)?` + String.raw`(?:(?<c1>\$?[A-Za-z]{1,3})(?<r1>\$?[0-9]{1,7})(?::(?<c2>\$?[A-Za-z]{1,3})(?<r2>\$?[0-9]{1,7}))?` + String.raw`|(?<cc1>\$?[A-Za-z]{1,3}):(?<cc2>\$?[A-Za-z]{1,3})` + String.raw`|(?<rr1>\$?[0-9]{1,7}):(?<rr2>\$?[0-9]{1,7}))` + String.raw`(?![A-Za-z0-9_.(\[!:$])`,
+  "y"
+);
+var qualifiedRefError = /(?<sheet>'(?:[^']|'')+'|[A-Za-z_][A-Za-z0-9_.]*)!#REF!/iy;
+var sheetSpanPattern = /(?:'(?<quotedFirst>(?:[^':]|'')+):(?<quotedLast>(?:[^':]|'')+)'|(?<first>[A-Za-z_][A-Za-z0-9_.]*):(?<last>[A-Za-z_][A-Za-z0-9_.]*))!/y;
+var numberPattern = /(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?/y;
+var namePattern = /(?=[\0-￿])[\p{L}_\\](?:(?=[\0-￿])[\p{L}0-9_.])*/uy;
+function matchAt(pattern, text, at) {
+  pattern.lastIndex = at;
+  return pattern.exec(text);
+}
+var operators = ["<>", "<=", ">=", "=", "<", ">", "+", "-", "*", "/", "^", "&", "%"];
+function splitFormula(formula, columnsOf) {
+  const tokens = [];
+  const unreadable = { tokens: [], problem: "unreadable" };
+  let i = 1;
+  while (i < formula.length) {
+    const c = formula.charAt(i);
+    if (c === " " || c === "\n" || c === "\r") {
+      const start = i;
+      while (i < formula.length && (formula.charAt(i) === " " || formula.charAt(i) === "\n" || formula.charAt(i) === "\r")) i++;
+      tokens.push(new Token("space", formula.slice(start, i)));
+      continue;
+    }
+    if (c === '"') {
+      let j = i + 1;
+      while (j < formula.length && !(formula.charAt(j) === '"' && (j + 1 >= formula.length || formula.charAt(j + 1) !== '"'))) j += formula.charAt(j) === '"' ? 2 : 1;
+      if (j >= formula.length) return unreadable;
+      tokens.push(new Token("text", formula.slice(i, j + 1)));
+      i = j + 1;
+      continue;
+    }
+    if (c === "#") {
+      const error = errors.find((e) => startsWithIgnoreCase(formula, i, e));
+      if (error === void 0) return unreadable;
+      tokens.push(new Token("error", formula.slice(i, i + error.length)));
+      i += error.length;
+      continue;
+    }
+    if (c === "(" || c === ")" || c === ",") {
+      tokens.push(new Token(c === "(" ? "open" : c === ")" ? "close" : "comma", c));
+      i++;
+      continue;
+    }
+    const qualifiedError = matchAt(qualifiedRefError, formula, i);
+    if (qualifiedError !== null) {
+      tokens.push(new Token("error", qualifiedError[0], { sheet: sheetOf(qualifiedError) }));
+      i += qualifiedError[0].length;
+      continue;
+    }
+    const span = matchAt(sheetSpanPattern, formula, i);
+    if (span !== null) {
+      const place = matchAt(referencePattern, formula, i + span[0].length);
+      if (place?.groups !== void 0 && place.groups["sheet"] === void 0 && isReference(place)) {
+        const end = i + span[0].length + place[0].length;
+        const spannedSpill = place.groups["c1"] !== void 0 && place.groups["c2"] === void 0 && end < formula.length && formula.charAt(end) === "#";
+        const g = span.groups;
+        const first = g?.["quotedFirst"] ?? g?.["first"];
+        const last = g?.["quotedLast"] ?? g?.["last"];
+        if (first === void 0 || last === void 0) throw new Error("Internal: a span names no Sheets.");
+        tokens.push(new Token("reference", span[0] + place[0], { spilled: spannedSpill, sheet: first.replaceAll("''", "'"), lastSheet: last.replaceAll("''", "'") }));
+        i = end + (spannedSpill ? 1 : 0);
+        continue;
+      }
+    }
+    const reference = matchAt(referencePattern, formula, i);
+    if (reference?.groups !== void 0 && isReference(reference)) {
+      const end = i + reference[0].length;
+      const spilled = reference.groups["c1"] !== void 0 && reference.groups["c2"] === void 0 && end < formula.length && formula.charAt(end) === "#";
+      tokens.push(new Token("reference", reference[0], { spilled, sheet: sheetOf(reference) }));
+      i = end + (spilled ? 1 : 0);
+      continue;
+    }
+    if (c >= "0" && c <= "9" || c === ".") {
+      const number = matchAt(numberPattern, formula, i);
+      if (number === null) return unreadable;
+      tokens.push(new Token("number", number[0]));
+      i += number[0].length;
+      continue;
+    }
+    const name = matchAt(namePattern, formula, i);
+    if (name !== null) {
+      const end = i + name[0].length;
+      if (end < formula.length && formula.charAt(end) === "[") {
+        const column = structuredColumn(formula, end);
+        if (column.name === void 0) {
+          if (!column.at) return unreadable;
+          return { tokens, problem: "columnName" };
+        }
+        const declared = columnsOf?.(name[0]);
+        const columnName = column.name;
+        if (declared === void 0 || !declared.some((d) => equalsIgnoreCase(d, columnName))) return { tokens, problem: "structuredReference" };
+        if (columnName.startsWith(" ") || columnName.endsWith(" ") || unseenInColumns.test(columnName)) {
+          return { tokens, problem: "columnName" };
+        }
+        tokens.push(new Token("structuredReference", name[0] + storedColumn(columnName)));
+        i = column.after;
+        continue;
+      }
+      tokens.push(new Token("name", name[0], { called: end < formula.length && formula.charAt(end) === "(" }));
+      i = end;
+      continue;
+    }
+    const op = operators.find((o) => formula.startsWith(o, i));
+    if (op !== void 0) {
+      tokens.push(new Token("operator", op));
+      i += op.length;
+      continue;
+    }
+    return unreadable;
+  }
+  return { tokens, problem: "none" };
+}
+function structuredColumn(formula, open) {
+  const none = (at) => ({ name: void 0, after: open, at });
+  const doubled = open + 1 < formula.length && formula.charAt(open + 1) === "[";
+  let i = open + (doubled ? 2 : 1);
+  let column = "";
+  for (; ; ) {
+    if (i >= formula.length) return none(false);
+    const c = formula.charAt(i);
+    if (c === "'" && i + 1 < formula.length) {
+      column += formula.charAt(i + 1);
+      i += 2;
+      continue;
+    }
+    if (c === "[" || c === "#" || c === "@") return none(c === "@");
+    if (c === "]") break;
+    column += c;
+    i++;
+  }
+  if (doubled) {
+    if (i + 1 >= formula.length || formula.charAt(i + 1) !== "]") return none(false);
+    i++;
+  }
+  if (column.length === 0) return none(false);
+  return { name: column, after: i + 1, at: false };
+}
+function storedColumn(column) {
+  let text = "[";
+  for (const c of column) {
+    if (c === "[" || c === "]" || c === "#" || c === "'") text += "'";
+    text += c;
+  }
+  return `${text}]`;
+}
+function sheetOf(match) {
+  const raw = match.groups?.["sheet"];
+  if (raw === void 0) return void 0;
+  return raw.startsWith("'") ? raw.slice(1, -1).replaceAll("''", "'") : raw;
+}
+function bind(tokens) {
+  const bindings = [];
+  const frames = [{ function: void 0, arguments: [[]] }];
+  const top = () => elementAt(frames, frames.length - 1);
+  const lastArgument = (frame) => elementAt(frame.arguments, frame.arguments.length - 1);
+  let calls = 0;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = elementAt(tokens, i);
+    switch (token.kind) {
+      case "open": {
+        lastArgument(top()).push(i);
+        const previous = i > 0 ? elementAt(tokens, i - 1) : void 0;
+        const called = previous !== void 0 && previous.kind === "name" && previous.called ? previous : void 0;
+        if (called !== void 0 && ++calls > maxDepth) return "tooDeep";
+        frames.push({ function: called, arguments: [[]] });
+        break;
+      }
+      case "comma":
+        if (frames.length > 1) {
+          top().arguments.push([]);
+          if (top().function !== void 0 && top().arguments.length > maxArguments) return "tooManyArguments";
+        } else {
+          lastArgument(top()).push(i);
+        }
+        break;
+      case "close":
+        if (frames.length > 1) {
+          const frame = elementAt(frames, frames.length - 1);
+          frames.pop();
+          if (frame.function !== void 0) calls--;
+          lastArgument(top()).push(i);
+          binds(frame, tokens, i, bindings);
+        } else {
+          lastArgument(top()).push(i);
+        }
+        break;
+      case "space":
+        break;
+      case "text":
+      case "error":
+      case "reference":
+      case "number":
+      case "name":
+      case "operator":
+      case "structuredReference":
+        lastArgument(top()).push(i);
+        break;
+      default:
+        return unreachableKind(token.kind);
+    }
+  }
+  for (let i = 0; i < tokens.length; i++) {
+    const name = elementAt(tokens, i);
+    if (name.kind !== "name" || !bindings.some((b) => b.first <= i && i <= b.last && equalsIgnoreCase(b.name, name.text))) continue;
+    if (!name.called) name.bound = true;
+    else if (DeclaredFunction.find(name.text) === void 0) return "boundCall";
+  }
+  return "none";
+}
+function unreachableKind(kind) {
+  throw new Error(`Internal: ${String(kind)} is not a token's kind.`);
+}
+function binds(frame, tokens, close, bindings) {
+  const fn = frame.function;
+  if (fn === void 0) return;
+  const args = frame.arguments;
+  const loneName = (argument) => {
+    if (argument.length !== 1) return void 0;
+    const at = elementAt(argument, 0);
+    const token = elementAt(tokens, at);
+    return token.kind === "name" && !token.called ? [at, token] : void 0;
+  };
+  if (equalsIgnoreCase(fn.text, "LET")) {
+    for (let k = 0; k + 1 < args.length; k += 2) {
+      const named = loneName(elementAt(args, k));
+      if (named !== void 0) bindings.push({ name: named[1].text, first: named[0], last: close });
+    }
+  } else if (equalsIgnoreCase(fn.text, "LAMBDA") && args.length > 0 && elementAt(args, args.length - 1).length > 0) {
+    const body = elementAt(args, args.length - 1);
+    for (let k = 0; k + 1 < args.length; k++) {
+      const named = loneName(elementAt(args, k));
+      if (named !== void 0) {
+        bindings.push({ name: named[1].text, first: named[0], last: named[0] });
+        bindings.push({ name: named[1].text, first: elementAt(body, 0), last: elementAt(body, body.length - 1) });
+      }
+    }
+  }
+}
+function sameUnbound(tokens, engine) {
+  const unbound = new Set(tokens.filter((t) => t.kind === "name" && !t.called && !t.bound && !isBoolean(t.text) && isAscii(t.text)).map((t) => foldCase(t.text)));
+  const found = new Set(engine.map(foldCase));
+  return unbound.size === found.size && [...found].every((name) => unbound.has(name));
+}
+function isAscii(text) {
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) >= 128) return false;
+  }
+  return true;
+}
+function isBoolean(name) {
+  return equalsIgnoreCase(name, "TRUE") || equalsIgnoreCase(name, "FALSE");
+}
+function readsColumn(value) {
+  return value === void 0 || CellAddress2.tryParseColumn(trimDollars(value)) !== void 0;
+}
+function readsRow(value) {
+  if (value === void 0) return true;
+  const digits = trimDollars(value);
+  return !digits.startsWith("0") && /^[0-9]+$/.test(digits) && Number(digits) <= Sheet4.rowCount;
+}
+function isReference(match) {
+  const g = match.groups;
+  if (g === void 0) return false;
+  return readsColumn(g["c1"]) && readsColumn(g["c2"]) && readsColumn(g["cc1"]) && readsColumn(g["cc2"]) && readsRow(g["r1"]) && readsRow(g["r2"]) && readsRow(g["rr1"]) && readsRow(g["rr2"]);
+}
+function trimDollars(text) {
+  let i = 0;
+  while (i < text.length && text.charAt(i) === "$") i++;
+  return text.slice(i);
+}
+
+// src/writer.ts
+var maxFormulaLength = 8192;
+var maxTextLength = 32767;
+var maxLinkedTableRows = maxRows - 1;
+async function saveXlsxWorkbook(workbook, options = {}) {
+  options.signal?.throwIfAborted();
+  const maxBytes = options.maxUncompressedBytes === void 0 ? defaultMaxUncompressedBytes : options.maxUncompressedBytes;
+  if (!(maxBytes >= 1 && maxBytes <= defaultMaxUncompressedBytes)) {
+    throw new RangeError(`MaxUncompressedBytes is 1 to ${grouped(defaultMaxUncompressedBytes)}.`);
+  }
+  const maxCells = options.maxCells === void 0 ? defaultMaxCells : options.maxCells;
+  if (typeof maxCells !== "number" || Number.isNaN(maxCells)) throw new RangeError(`MaxCells is a number of elements, not ${String(maxCells)}.`);
+  const snapshot = snapshotOf(workbook);
+  const pacer = new SavePacer(options);
+  let writer;
+  try {
+    writer = await build(snapshot, maxCells, maxBytes, pacer);
+    const file = await writer.complete();
+    options.signal?.throwIfAborted();
+    return file;
+  } catch (e) {
+    await writer?.abandon();
+    if (e instanceof XlsxError3 && e.reason === "tooLarge") throw tooLarge(e, maxBytes);
+    throw e;
+  }
+}
+function tooLarge(e, maxBytes) {
+  const part = e.part === void 0 ? "" : e.part;
+  return new XlsxSaveError(
+    "tooLarge",
+    `The workbook would hold more than the ${grouped(maxBytes)} uncompressed bytes a file is written with, and read with by default; the part '${part}' went past it.`,
+    { sheet: e.sheet }
+  );
+}
+function snapshotOf(workbook) {
+  const document = workbook.toDocument();
+  const sheets = [];
+  const names = /* @__PURE__ */ new Map();
+  workbook.sheets.forEach((sheet, i) => {
+    const values = /* @__PURE__ */ new Map();
+    const spilledFrom = /* @__PURE__ */ new Map();
+    for (const at of sheet.valueAddresses) {
+      const value = sheet.getValue(at);
+      if (value !== void 0) values.set(at.key, value);
+      const anchor = sheet.spilledFrom(at);
+      if (anchor !== void 0) spilledFrom.set(at.key, { at, anchor });
+    }
+    sheets.push({ name: sheet.name, document: elementAt(document.sheets, i), values, spilledFrom });
+    if (!names.has(foldCase(sheet.name))) names.set(foldCase(sheet.name), sheet.name);
+  });
+  const tables = workbook.linkedTables.map((table) => ({ table, columns: table.isWaiting ? void 0 : workbook.linkedTableColumns(table.name) }));
+  return { culture: workbook.culture, shown: indexOf(workbook, workbook.shown), sheets, sheetNames: names, tables };
+}
+function indexOf(workbook, sheet) {
+  const sheets = workbook.sheets;
+  for (let i = 0; i < sheets.length; i++) {
+    if (sheets[i] === sheet) return i;
+  }
+  return 0;
+}
+async function build(snapshot, maxCells, maxBytes, pacer) {
+  pacer.sheets = snapshot.sheets.length + snapshot.tables.length;
+  const tables = await tablesOf(snapshot, pacer);
+  const planned = [];
+  let cells = 0;
+  for (const sheet of snapshot.sheets) {
+    if (!carries(sheet.name, true)) {
+      throw new XlsxSaveError(
+        "text",
+        "The Sheet's name holds a character a file cannot carry in a worksheet's name: a control character below U+0020, U+FFFE or U+FFFF, or half of a surrogate pair.",
+        { sheet: sheet.name }
+      );
+    }
+    const own = ownCells(sheet);
+    const plan = new SheetFormatPlan(sheet.document);
+    const crossings = plan.crossings(own.map((c) => c.at));
+    const rows = plan.formattedRows;
+    cells += own.length + crossings + rows;
+    if (cells > maxCells) {
+      throw new XlsxSaveError(
+        "tooManyCells",
+        `The workbook would write more than the ${grouped(maxCells)} elements it may (XlsxSaveOptions.MaxCells, which counts the cells written and each row a row format writes; by default the cells a file is read with): this Sheet writes ${grouped(own.length)} cells of its own, ${grouped(crossings)} where its formatted rows cross its formatted columns, and ${grouped(rows)} rows its row formats write.`,
+        { sheet: sheet.name }
+      );
+    }
+    planned.push({ sheet, plan, cells: own });
+    await pacer.checkpoint();
+  }
+  for (const { table, columns } of tables) {
+    cells += table.columns.length;
+    for (const column of columns) {
+      for (const value of column) if (value !== void 0) cells++;
+    }
+    if (cells > maxCells) {
+      throw new XlsxSaveError(
+        "tooManyCells",
+        `The workbook would write more than the ${grouped(maxCells)} elements it may (XlsxSaveOptions.MaxCells, which counts the cells written and each row a row format writes; by default the cells a file is read with): the Linked Table '${table.name}' writes ${grouped(table.rowCount)} rows of ${grouped(table.columns.length)} columns under its header.`,
+        { sheet: table.name }
+      );
+    }
+  }
+  const styles = new StyleTable(snapshot.culture);
+  const sheets = [];
+  for (const { sheet, plan, cells: own } of planned) {
+    plan.build(styles);
+    const recorded = [];
+    for (const { at, entry, own: parts } of own) {
+      recorded.push({ at, entry, style: plan.style(styles, parts, at) });
+      const step = pacer.step(0);
+      if (step !== void 0) await step;
+    }
+    sheets.push({ sheet, plan, cells: recorded, spills: spillsOf(sheet) });
+  }
+  pacer.total = cells;
+  pacer.sheet = 0;
+  const writer = createXlsxWriter({
+    styles: styles.build(),
+    activeSheet: snapshot.shown,
+    fullCalculationOnLoad: true,
+    maxUncompressedBytes: maxBytes
+  });
+  const declared = /* @__PURE__ */ new Map();
+  for (const { table } of snapshot.tables) {
+    if (!declared.has(foldCase(table.name))) declared.set(foldCase(table.name), table.columns);
+  }
+  const columnsOf = (name) => declared.get(foldCase(name));
+  const hasSheet = (name) => snapshot.sheetNames.has(foldCase(name));
+  try {
+    for (const { sheet, plan, cells: recorded, spills } of sheets) {
+      const out = new Paced(writer.addSheet(sheet.name, plan.columns), pacer);
+      await writeSheet(out, sheet, plan, recorded, spills, hasSheet, columnsOf);
+      pacer.sheet++;
+    }
+    for (const table of tables) {
+      await writeTable(new Paced(writer.addSheet(table.table.name), pacer), table);
+      pacer.sheet++;
+    }
+    pacer.sheet = Math.max(0, pacer.sheets - 1);
+    pacer.report();
+    return writer;
+  } catch (e) {
+    await writer.abandon();
+    throw e;
+  }
+}
+var flushEvery = 4096;
+var Paced = class {
+  sheet;
+  #pacer;
+  #since = 0;
+  constructor(sheet, pacer) {
+    this.sheet = sheet;
+    this.#pacer = pacer;
+  }
+  async row(row, style) {
+    this.sheet.writeRow({ row, styleIndex: style });
+    await this.#step();
+  }
+  async cell(cell) {
+    this.sheet.write(cell);
+    await this.#step();
+  }
+  async #step() {
+    if (++this.#since >= flushEvery) {
+      this.#since = 0;
+      await this.sheet.flush();
+    }
+    const step = this.#pacer.step();
+    if (step !== void 0) await step;
+  }
+};
+async function tablesOf(snapshot, pacer) {
+  const tables = [];
+  for (const { table, columns } of snapshot.tables) {
+    const name = table.name;
+    const where = { sheet: name };
+    if (table.isWaiting || columns === void 0) {
+      throw new XlsxSaveError(
+        "linkedTable",
+        `The Linked Table '${name}' has not answered: it holds no rows yet, or its last snapshot was refused, and every Formula that reads it shows #GETTING_DATA. Its rows are written as they stand, and it has none to write.`,
+        where
+      );
+    }
+    const sheet = snapshot.sheetNames.get(foldCase(name));
+    if (sheet !== void 0) {
+      throw new XlsxSaveError("linkedTable", `The Linked Table '${name}' is written on a worksheet of its name, and the Sheet '${sheet}' already has it.`, where);
+    }
+    if (!isValidTableName(name)) {
+      throw new XlsxSaveError(
+        "linkedTable",
+        `The Linked Table '${name}' is written as an Excel Table of its name, and Excel gives a Table no such name: it reads as a cell's address, or holds a character a Table's name does not.`,
+        where
+      );
+    }
+    const why = Sheet5.whyNotAName(name);
+    if (why !== void 0) {
+      throw new XlsxSaveError("linkedTable", `The Linked Table '${name}' is written on a worksheet of its name, and a worksheet cannot have it: ${why}`, where);
+    }
+    if (table.columns.length > maxColumns) {
+      throw new XlsxSaveError(
+        "linkedTable",
+        `The Linked Table '${name}' has ${grouped(table.columns.length)} columns, and a worksheet of Excel holds ${grouped(maxColumns)}.`,
+        where
+      );
+    }
+    if (table.rowCount === 0) {
+      throw new XlsxSaveError(
+        "linkedTable",
+        `The Linked Table '${name}' holds no rows, and an Excel Table holds at least one: written with one empty row, its Formulas would answer otherwise in Excel (ROWS gives 1, COUNTBLANK 1, the column itself 0 where ExSheet shows #VALUE!).`,
+        where
+      );
+    }
+    if (table.rowCount > maxLinkedTableRows) {
+      throw new XlsxSaveError(
+        "linkedTable",
+        `The Linked Table '${name}' holds ${grouped(table.rowCount)} rows, and a worksheet of Excel holds ${grouped(maxRows)}, its header's included.`,
+        where
+      );
+    }
+    for (let c = 0; c < columns.length; c++) {
+      const columnName = elementAt(table.columns, c);
+      checkTableText(name, columnName, 0, c, "as a column's name");
+      const column = elementAt(columns, c);
+      for (let r = 0; r < column.length; r++) {
+        const value = column[r];
+        if (value !== void 0 && value.kind === "text") {
+          checkTableText(name, value.text, r + 1, c, `in its column '${columnName}', row ${grouped(r + 1)},`);
+        }
+        const step = pacer.step(0);
+        if (step !== void 0) await step;
+      }
+    }
+    tables.push({ table, columns });
+  }
+  return tables;
+}
+function checkTableText(table, text, row, column, at) {
+  const cell = formatCell2(row, column);
+  if (text.length > maxTextLength) {
+    throw new XlsxSaveError(
+      "text",
+      `The Linked Table '${table}' holds, ${at} text ${grouped(text.length)} characters long, and a cell of Excel holds at most ${grouped(maxTextLength)}.`,
+      { sheet: table, cell }
+    );
+  }
+  if (!carries(text, false)) {
+    throw new XlsxSaveError("text", `The Linked Table '${table}' holds, ${at} text with half of a surrogate pair, which a file cannot carry.`, { sheet: table, cell });
+  }
+}
+async function writeTable(out, { table, columns }) {
+  out.sheet.addTable({ name: table.name, headerRow: 0, firstColumn: 0, columns: table.columns, dataRows: table.rowCount });
+  for (let c = 0; c < table.columns.length; c++) {
+    await out.cell({ row: 0, column: c, type: "sharedString", text: elementAt(table.columns, c) });
+  }
+  for (let r = 0; r < table.rowCount; r++) {
+    for (let c = 0; c < columns.length; c++) {
+      const value = elementAt(columns, c)[r];
+      if (value === void 0) continue;
+      const row = r + 1;
+      switch (value.kind) {
+        case "number":
+          await out.cell({ row, column: c, type: "number", value: roundTrip(value.number) });
+          break;
+        case "text":
+          await out.cell({ row, column: c, type: "sharedString", text: value.text });
+          break;
+        case "boolean":
+          await out.cell({ row, column: c, type: "boolean", value: value.boolean ? "1" : "0" });
+          break;
+        case "error":
+          await out.cell({ row, column: c, type: "error", value: value.toString() });
+          break;
+      }
+    }
+  }
+}
+function ownCells(sheet) {
+  const cells = /* @__PURE__ */ new Map();
+  for (const cell of sheet.document.cells) {
+    cells.set(cell.address.key, {
+      at: cell.address,
+      entry: cell.entry,
+      own: new FormatParts(cell.numberFormat, cell.alignment, cell.font, cell.fill, cell.borders)
+    });
+  }
+  for (const [key, { at }] of sheet.spilledFrom) {
+    if (!cells.has(key)) cells.set(key, { at, entry: void 0, own: FormatParts.empty });
+  }
+  return [...cells.values()].toSorted((a, b) => a.at.compareTo(b.at));
+}
+function spillsOf(sheet) {
+  const spills = /* @__PURE__ */ new Map();
+  for (const { at, anchor } of sheet.spilledFrom.values()) {
+    const last = spills.get(anchor.key);
+    spills.set(anchor.key, last === void 0 ? at : new CellAddress3(Math.max(last.row, at.row), Math.max(last.column, at.column)));
+  }
+  return spills;
+}
+async function writeSheet(out, sheet, plan, cells, spills, hasSheet, columnsOf) {
+  const write = (cell) => out.cell(cellOf(sheet, cell, spills, hasSheet, columnsOf));
+  const runs = plan.rows;
+  let run = 0;
+  let runRow = runs.length > 0 ? elementAt(runs, 0).first : Number.MAX_SAFE_INTEGER;
+  let next = 0;
+  while (next < cells.length || run < runs.length) {
+    const cellRow = next < cells.length ? elementAt(cells, next).at.row : Number.MAX_SAFE_INTEGER;
+    const row = Math.min(cellRow, runRow);
+    let end = next;
+    while (end < cells.length && elementAt(cells, end).at.row === row) end++;
+    if (row === runRow) {
+      const formatted2 = elementAt(runs, run);
+      await out.row(row, formatted2.style);
+      let at = next;
+      for (const crossing of formatted2.crossings) {
+        for (let column = crossing.first; column <= crossing.last; column++) {
+          while (at < end && elementAt(cells, at).at.column < column) await write(elementAt(cells, at++));
+          if (at < end && elementAt(cells, at).at.column === column) continue;
+          await out.cell({ row, column, type: "number", value: null, styleIndex: crossing.style });
+        }
+      }
+      while (at < end) await write(elementAt(cells, at++));
+      runRow++;
+      if (runRow > formatted2.last) {
+        run++;
+        runRow = run < runs.length ? elementAt(runs, run).first : Number.MAX_SAFE_INTEGER;
+      }
+    } else {
+      for (let at = next; at < end; at++) await write(elementAt(cells, at));
+    }
+    next = end;
+  }
+}
+function cellOf(sheet, cell, spills, hasSheet, columnsOf) {
+  const at = cell.at;
+  const empty = { row: at.row, column: at.column, type: "number", value: null, styleIndex: cell.style };
+  const entry = cell.entry;
+  const constant = entry?.constant;
+  if (constant !== void 0) {
+    if (constant.kind !== "text") return valued(sheet, at, constant, empty, void 0);
+    checkText(sheet, at, constant.text, void 0);
+    return { ...empty, type: "sharedString", text: constant.text };
+  }
+  const value = sheet.values.get(at.key);
+  const formula = entry?.formula;
+  if (entry !== void 0 && formula !== void 0) {
+    const where = { sheet: sheet.name, cell: at.toString(), held: formula };
+    if (formula.length - 1 > maxFormulaLength) {
+      throw new XlsxSaveError(
+        "formula",
+        `The Formula is ${grouped(formula.length - 1)} characters long, and Excel holds at most ${grouped(maxFormulaLength)}.`,
+        { sheet: sheet.name, cell: at.toString() }
+      );
+    }
+    if (!carries(formula, false)) throw new XlsxSaveError("formula", "The Formula holds half of a surrogate pair, which a file cannot carry.", where);
+    const { text: stored, problem } = writeFormula(entry, hasSheet, columnsOf);
+    switch (problem) {
+      case "boundCall":
+        throw new XlsxSaveError("formula", "The Formula calls a name a LET binds or a LAMBDA takes, which ExSheet reads as an unknown function and Excel would call.", where);
+      case "longText":
+        throw new XlsxSaveError("formula", `The Formula holds a text constant longer than the ${String(maxText)} characters Excel takes in one.`, where);
+      case "tooDeep":
+        throw new XlsxSaveError("formula", `The Formula nests its calls deeper than the ${String(maxDepth)} levels Excel takes.`, where);
+      case "tooManyArguments":
+        throw new XlsxSaveError("formula", `The Formula makes a call with more than the ${String(maxArguments)} arguments Excel takes.`, where);
+      case "missingSheet":
+        throw new XlsxSaveError("formula", "The Formula reads a Sheet the Workbook does not have, which Excel would read as another workbook's.", where);
+      case "structuredReference":
+        throw new XlsxSaveError(
+          "formula",
+          "The Formula reads, by a structured reference, a Linked Table or a column the Workbook does not declare; the file would hold no Excel Table of it for Excel to read.",
+          where
+        );
+      case "columnName":
+        throw new XlsxSaveError(
+          "formula",
+          `The Formula reads a Linked Table's column whose name begins or ends with a space, which a structured reference in Excel does not keep, or holds @ or one of , : . " { } $ ^ & * + = - < > / or a tab or line break, whose form in a structured reference Excel has not been seen to write.`,
+          where
+        );
+      case "tableName":
+        throw new XlsxSaveError(
+          "formula",
+          "The Formula reads a Linked Table's name as a name of its own, which ExSheet shows as #NAME? and Excel would read as the Excel Table written.",
+          where
+        );
+      case "unreadable":
+        throw new XlsxSaveError("formula", "The Formula cannot be written as Excel stores it: its names do not bind as the engine binds them.", where);
+      case "none":
+        break;
+    }
+    const last = spills.get(at.key);
+    const range = last === void 0 ? at.toString() : `${at.toString()}:${last.toString()}`;
+    const written = { text: stored, kind: "array", reference: range, isDynamicArray: true };
+    return { ...value === void 0 ? empty : valued(sheet, at, value, empty, formula), formula: written };
+  }
+  return value === void 0 ? empty : valued(sheet, at, value, empty, void 0);
+}
+function valued(sheet, at, value, cell, formula) {
+  switch (value.kind) {
+    case "number":
+      return { ...cell, value: roundTrip(value.number) };
+    case "boolean":
+      return { ...cell, type: "boolean", value: value.boolean ? "1" : "0" };
+    case "text":
+      checkText(sheet, at, value.text, formula);
+      return { ...cell, type: "formulaString", value: value.text };
+    case "error":
+      break;
+  }
+  const where = { sheet: sheet.name, cell: at.toString(), held: formula };
+  if (value.error === "#CIRC!") {
+    throw new XlsxSaveError(
+      "circularReference",
+      "The cell shows #CIRC!: it is part of a circular reference, or depends on one. A file holds no such Error Value, and Excel shows 0 there; no Value it can hold is the one shown.",
+      where
+    );
+  }
+  if (value.error === "#GETTING_DATA") {
+    throw new XlsxSaveError("linkedTable", "The cell shows #GETTING_DATA: it waits on a Linked Table that has not answered.", where);
+  }
+  return { ...cell, type: "error", value: value.toString() };
+}
+function isHighSurrogate(c) {
+  return c >= 55296 && c <= 56319;
+}
+function isLowSurrogate(c) {
+  return c >= 56320 && c <= 57343;
+}
+function carries(text, inName) {
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (isHighSurrogate(c) && i + 1 < text.length && isLowSurrogate(text.charCodeAt(i + 1))) {
+      i++;
+      continue;
+    }
+    if (isHighSurrogate(c) || isLowSurrogate(c)) return false;
+    if (inName && (c < 32 || c === 65534 || c === 65535)) return false;
+  }
+  return true;
+}
+function checkText(sheet, at, text, formula) {
+  const where = { sheet: sheet.name, cell: at.toString(), held: formula };
+  if (text.length > maxTextLength) {
+    throw new XlsxSaveError("text", `The cell's text is ${grouped(text.length)} characters long, and a cell of Excel holds at most ${grouped(maxTextLength)}.`, where);
+  }
+  if (!carries(text, false)) throw new XlsxSaveError("text", "The cell's text holds half of a surrogate pair, which a file cannot carry.", where);
+}
+export {
+  OpenReport,
+  XlsxOpenError,
+  XlsxSaveError,
+  maxFormulaLength,
+  maxLinkedTableRows,
+  maxTextLength,
+  openXlsxWorkbook,
+  saveXlsxWorkbook
+};
+//# sourceMappingURL=index.js.map