@ex-grid/data-xlsx 0.0.0-stage → 0.2.0-rc.1

package/dist/index.js

@@ -0,0 +1,4222 @@
+// 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;
+}
+
+// src/invariant.ts
+function parseInt32(text) {
+  if (!/^[+-]?[0-9]+$/.test(text)) return void 0;
+  const value = Number(text);
+  return value >= -2147483648 && value <= 2147483647 ? value : void 0;
+}
+function parseDigits(text) {
+  if (!/^[0-9]+$/.test(text)) return void 0;
+  const value = Number(text);
+  return value <= 2147483647 ? value : void 0;
+}
+function parseHex32(text) {
+  if (!/^[0-9A-Fa-f]+$/.test(text)) return void 0;
+  const value = Number.parseInt(text, 16);
+  return value <= 4294967295 ? value : void 0;
+}
+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 lower = trimmed.toLowerCase();
+  if (lower === "infinity" || lower === "+infinity") return Number.POSITIVE_INFINITY;
+  if (lower === "-infinity") return Number.NEGATIVE_INFINITY;
+  if (lower === "nan" || lower === "+nan" || lower === "-nan") return Number.NaN;
+  return void 0;
+}
+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 hex8(value) {
+  return (value >>> 0).toString(16).toUpperCase().padStart(8, "0");
+}
+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 equalsIgnoreCase(a, b) {
+  return a.length === b.length && foldCase(a) === foldCase(b);
+}
+
+// src/cell-reference.ts
+var maxRows = 1048576;
+var maxColumns = 16384;
+function columnName(column) {
+  if (!Number.isInteger(column) || column < 0) throw new RangeError(`The column ${String(column)} is not a column from zero.`);
+  let letters = "";
+  let n = column + 1;
+  while (n > 0) {
+    const rem = (n - 1) % 26;
+    letters = String.fromCharCode(65 + rem) + letters;
+    n = Math.floor((n - 1) / 26);
+  }
+  return letters;
+}
+function formatCell(row, column) {
+  if (!Number.isInteger(row) || row < 0) throw new RangeError(`The row ${String(row)} is not a row from zero.`);
+  return columnName(column) + String(row + 1);
+}
+function parseCell(text) {
+  let i = 0;
+  if (text.charAt(i) === "$") i++;
+  let col = 0;
+  let letters = 0;
+  for (; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    const upper = c >= 97 && c <= 122 ? c - 32 : c;
+    if (upper < 65 || upper > 90) break;
+    col = col * 26 + (upper - 65 + 1);
+    if (++letters > 3) return void 0;
+  }
+  if (letters === 0 || col > maxColumns) return void 0;
+  if (text.charAt(i) === "$") i++;
+  let r = 0;
+  let digits = 0;
+  for (; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c < 48 || c > 57) break;
+    r = r * 10 + (c - 48);
+    if (++digits > 7) return void 0;
+  }
+  if (digits === 0 || i !== text.length || r < 1 || r > maxRows) return void 0;
+  return { row: r - 1, column: col - 1 };
+}
+
+// src/names.ts
+var mainNamespace = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+var relationshipsNamespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var packageRelationshipsNamespace = "http://schemas.openxmlformats.org/package/2006/relationships";
+var contentTypesNamespace = "http://schemas.openxmlformats.org/package/2006/content-types";
+var drawingNamespace = "http://schemas.openxmlformats.org/drawingml/2006/main";
+var strictPrefix = "http://purl.oclc.org/ooxml/";
+var officeDocumentType = `${relationshipsNamespace}/officeDocument`;
+var worksheetType = `${relationshipsNamespace}/worksheet`;
+var sharedStringsType = `${relationshipsNamespace}/sharedStrings`;
+var stylesType = `${relationshipsNamespace}/styles`;
+var themeType = `${relationshipsNamespace}/theme`;
+var sheetMetadataType = `${relationshipsNamespace}/sheetMetadata`;
+var tableType = `${relationshipsNamespace}/table`;
+var workbookContent = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml";
+var templateContent = "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml";
+var binaryContent = "application/vnd.ms-excel.sheet.binary.macroEnabled.main";
+var worksheetContent = "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml";
+var sharedStringsContent = "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml";
+var stylesContent = "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml";
+var sheetMetadataContent = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml";
+var tableContent = "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml";
+var relationshipsContent = "application/vnd.openxmlformats-package.relationships+xml";
+var vbaProjectContent = "application/vnd.ms-office.vbaProject";
+var dynamicArrayExtension = "{bdbb8cdc-fa1e-496e-a857-3c3f30c029c3}";
+
+// src/xlsx-error.ts
+var XlsxError = class extends Error {
+  /** Why the file was refused. */
+  reason;
+  /** The package part the refusal met, as `xl/worksheets/sheet1.xml`; `undefined` when it is about the file as a whole. */
+  part;
+  /** The name of the Sheet the refusal met; `undefined` when it is not about one Sheet. */
+  sheet;
+  /** The cell the refusal met, as `B7`; `undefined` when it is not about one cell. */
+  cell;
+  /**
+   * A refusal naming what it met.
+   * @param reason - Why the file is refused.
+   * @param message - What was wrong, as a sentence that follows the Sheet and the cell.
+   * @param where - The part, the Sheet and the cell it met, 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.part, message), options);
+    this.name = "XlsxError";
+    this.reason = reason;
+    this.part = where.part;
+    this.sheet = where.sheet;
+    this.cell = where.cell;
+  }
+};
+function formatted(sheet, cell, part, message) {
+  if (sheet !== void 0) return cell !== void 0 ? `Sheet '${sheet}', cell ${cell}: ${message}` : `Sheet '${sheet}': ${message}`;
+  if (part !== void 0) return `Part '${part}': ${message}`;
+  return message;
+}
+
+// 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 unreachable(value) {
+  throw new Error(`Internal: ${String(value)} is not a value this switch takes.`);
+}
+
+// src/xml-reader.ts
+var XmlError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "XmlError";
+  }
+};
+var NeedMore = class extends Error {
+  constructor() {
+    super("Internal: the XML reader needs more text than it holds.");
+    this.name = "NeedMore";
+  }
+};
+var xmlnsNamespace = "http://www.w3.org/2000/xmlns/";
+var xmlNamespace = "http://www.w3.org/XML/1998/namespace";
+var invalidCharacter = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF]/;
+var nameStart = /[A-Z_a-z:\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\uD800-\uDBFF]/;
+var nameRest = /^[A-Z_a-z:\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\uD800-\uDFFF.\-0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/;
+function split(qualified) {
+  const colon = qualified.indexOf(":");
+  return colon < 0 ? ["", qualified] : [qualified.slice(0, colon), qualified.slice(colon + 1)];
+}
+function isSpace(c) {
+  return c === 32 || c === 9 || c === 10 || c === 13;
+}
+function lineFeeds(text) {
+  return text.includes("\r") ? text.replace(/\r\n?/g, "\n") : text;
+}
+function checkCharacters(text) {
+  const bad = invalidCharacter.exec(text);
+  if (bad !== null) {
+    const code = bad[0].charCodeAt(0);
+    throw new XmlError(`'${bad[0]}', hexadecimal value 0x${code.toString(16).toUpperCase().padStart(2, "0")}, is an invalid character.`);
+  }
+}
+function checkName(name) {
+  if (name === "" || !nameStart.test(name.charAt(0)) || !nameRest.test(name.slice(1))) {
+    throw new XmlError(`'${name}' is not a name XML allows.`);
+  }
+}
+function unescape(text) {
+  if (!text.includes("&")) return text;
+  let out = "";
+  let at = 0;
+  for (; ; ) {
+    const amp = text.indexOf("&", at);
+    if (amp < 0) return out + text.slice(at);
+    const semi = text.indexOf(";", amp + 1);
+    if (semi < 0) throw new XmlError("An entity reference is not ended by a semicolon.");
+    out += text.slice(at, amp);
+    const name = text.slice(amp + 1, semi);
+    switch (name) {
+      case "lt":
+        out += "<";
+        break;
+      case "gt":
+        out += ">";
+        break;
+      case "amp":
+        out += "&";
+        break;
+      case "quot":
+        out += '"';
+        break;
+      case "apos":
+        out += "'";
+        break;
+      default: {
+        const decimal = /^#([0-9]+)$/.exec(name);
+        const hexadecimal = /^#x([0-9a-fA-F]+)$/.exec(name);
+        const digits = decimal?.[1] ?? hexadecimal?.[1];
+        if (digits === void 0) {
+          if (name.startsWith("#")) throw new XmlError(`'&${name};' is not a character reference.`);
+          throw new XmlError(`Reference to undeclared entity '${name}'.`);
+        }
+        const code = Number.parseInt(digits, decimal === null ? 16 : 10);
+        const valid = code === 9 || code === 10 || code === 13 || code >= 32 && code <= 55295 || code >= 57344 && code <= 65533 || code >= 65536 && code <= 1114111;
+        if (!valid) throw new XmlError(`The character reference '&${name};' is to a character XML does not allow.`);
+        out += String.fromCodePoint(code);
+      }
+    }
+    at = semi + 1;
+  }
+}
+var XmlReader = class _XmlReader {
+  #source;
+  #text = "";
+  #pos = 0;
+  #ended = false;
+  #nodeType = "none";
+  #localName = "";
+  #prefix = "";
+  #namespaceUri = "";
+  #value = "";
+  #isEmptyElement = false;
+  #depth = 0;
+  #attributes = [];
+  #stack = [];
+  #popOnNext = false;
+  #started = false;
+  #rootSeen = false;
+  #rootClosed = false;
+  #eof = false;
+  constructor(source) {
+    this.#source = source;
+  }
+  /** A reader of `text`, whole. */
+  static of(text) {
+    let given = false;
+    return new _XmlReader(() => {
+      if (given) return Promise.resolve(void 0);
+      given = true;
+      return Promise.resolve(text);
+    });
+  }
+  nodeType() {
+    return this.#nodeType;
+  }
+  localName() {
+    return this.#localName;
+  }
+  prefix() {
+    return this.#prefix;
+  }
+  namespaceUri() {
+    return this.#namespaceUri;
+  }
+  /** The text of a text, CDATA or whitespace node; '' on an element. */
+  value() {
+    return this.#value;
+  }
+  isEmptyElement() {
+    return this.#isEmptyElement;
+  }
+  /** How deep the node lies: the root element is 0, its children 1, and an element's text one below it. */
+  depth() {
+    return this.#depth;
+  }
+  attributes() {
+    return this.#attributes;
+  }
+  /** Whether the reader has read past the part's end. */
+  eof() {
+    return this.#eof;
+  }
+  /** Whether every piece of the text has arrived. */
+  ended() {
+    return this.#ended;
+  }
+  /** The characters that have arrived and are not read yet. */
+  unread() {
+    return this.#text.length - this.#pos;
+  }
+  /** Reads pieces until at least `ahead` characters lie unread, or the text has all come. Done only where no mark
+   * is held: what has been read is let go. */
+  async fill(ahead2) {
+    if (this.#pos > 0) {
+      this.#text = this.#text.slice(this.#pos);
+      this.#pos = 0;
+    }
+    while (!this.#ended && this.#text.length < ahead2) {
+      const piece2 = await this.#source();
+      if (piece2 === void 0) this.#ended = true;
+      else this.#text += piece2;
+    }
+  }
+  snapshot() {
+    return {
+      pos: this.#pos,
+      state: {
+        nodeType: this.#nodeType,
+        localName: this.#localName,
+        prefix: this.#prefix,
+        namespaceUri: this.#namespaceUri,
+        value: this.#value,
+        isEmptyElement: this.#isEmptyElement,
+        depth: this.#depth,
+        attributes: this.#attributes,
+        stack: [...this.#stack],
+        popOnNext: this.#popOnNext,
+        started: this.#started,
+        rootSeen: this.#rootSeen,
+        rootClosed: this.#rootClosed,
+        eof: this.#eof
+      }
+    };
+  }
+  restore(mark) {
+    const s = mark.state;
+    this.#pos = mark.pos;
+    this.#nodeType = s.nodeType;
+    this.#localName = s.localName;
+    this.#prefix = s.prefix;
+    this.#namespaceUri = s.namespaceUri;
+    this.#value = s.value;
+    this.#isEmptyElement = s.isEmptyElement;
+    this.#depth = s.depth;
+    this.#attributes = s.attributes;
+    this.#stack = [...s.stack];
+    this.#popOnNext = s.popOnNext;
+    this.#started = s.started;
+    this.#rootSeen = s.rootSeen;
+    this.#rootClosed = s.rootClosed;
+    this.#eof = s.eof;
+  }
+  /** The attribute by its qualified name, as written (`GetAttribute(name)`), or `undefined`. */
+  getAttribute(name) {
+    for (const attribute of this.#attributes) {
+      if (attribute.name === name) return attribute.value;
+    }
+    return void 0;
+  }
+  /** The attribute by its local name and namespace (`GetAttribute(localName, namespaceURI)`), or `undefined`. */
+  getAttributeNs(localName, namespaceUri) {
+    for (const attribute of this.#attributes) {
+      if (attribute.localName === localName && attribute.namespaceUri === namespaceUri) return attribute.value;
+    }
+    return void 0;
+  }
+  /** Moves to the next content node — an element, an element's end, or text that is not only white space — unless the
+   * reader is on one (`MoveToContent`). */
+  moveToContent() {
+    for (; ; ) {
+      switch (this.#nodeType) {
+        case "element":
+        case "endElement":
+        case "text":
+        case "cdata":
+          return this.#nodeType;
+        case "none":
+        case "whitespace":
+        case "significantWhitespace":
+          if (!this.read()) return this.#nodeType;
+          break;
+        default:
+          return unreachable(this.#nodeType);
+      }
+    }
+  }
+  /** The text of the element the reader is on, its text and CDATA joined, leaving the reader past its end
+   * (`ReadElementContentAsString`). An element that holds an element is not well-formed for it. */
+  readElementContentAsString() {
+    if (this.#nodeType !== "element") throw new Error(`Internal: the reader is on ${this.#nodeType}, not an element.`);
+    if (this.#isEmptyElement) {
+      this.read();
+      return "";
+    }
+    let text = "";
+    this.read();
+    for (; ; ) {
+      const node = this.nodeType();
+      switch (node) {
+        case "text":
+        case "cdata":
+        case "whitespace":
+        case "significantWhitespace":
+          text += this.#value;
+          this.read();
+          break;
+        case "element":
+          throw new XmlError("ReadElementContentAs() methods cannot be called on an element that has child elements.");
+        case "endElement":
+          this.read();
+          return text;
+        case "none":
+          throw new XmlError("Unexpected end of file.");
+        default:
+          return unreachable(node);
+      }
+    }
+  }
+  /** Reads on to the next element of `localName` in `namespaceUri`; false, at the part's end, when there is none
+   * (`ReadToFollowing`). */
+  readToFollowing(localName, namespaceUri) {
+    while (this.read()) {
+      if (this.#nodeType === "element" && this.#localName === localName && this.#namespaceUri === namespaceUri) return true;
+    }
+    return false;
+  }
+  /** Moves past the element the reader is on and all it holds, or past any other node (`Skip`). */
+  skip() {
+    if (this.#nodeType !== "element" || this.#isEmptyElement) {
+      this.read();
+      return;
+    }
+    const depth = this.#depth;
+    while (this.read()) {
+      if (this.nodeType() === "endElement" && this.depth() === depth) break;
+    }
+    this.read();
+  }
+  /** Reads the next node; false at the part's end. */
+  read() {
+    if (this.#eof) return false;
+    if (this.#popOnNext) {
+      this.#stack.pop();
+      this.#popOnNext = false;
+    }
+    if (!this.#started) this.#prolog();
+    const text = this.#text;
+    for (; ; ) {
+      if (this.#pos >= text.length) {
+        if (!this.#ended) throw new NeedMore();
+        if (!this.#rootSeen) throw new XmlError("Root element is missing.");
+        if (this.#stack.length > 0) {
+          throw new XmlError(`Unexpected end of file has occurred. The following elements are not closed: ${this.#stack.map((f) => f.name).toReversed().join(", ")}.`);
+        }
+        this.#eof = true;
+        this.#node("none", "", "", "", "", this.#stack.length);
+        return false;
+      }
+      if (text.charCodeAt(this.#pos) !== 60) {
+        this.#readText(text);
+        return true;
+      }
+      const next = this.#charAt(text, this.#pos + 1);
+      if (next === "/") {
+        this.#readEnd(text);
+        return true;
+      }
+      if (next === "?") {
+        this.#skipInstruction(text);
+        continue;
+      }
+      if (next === "!") {
+        if (this.#readBang(text)) return true;
+        continue;
+      }
+      this.#readStart(text);
+      return true;
+    }
+  }
+  // ---- the nodes -------------------------------------------------------------------------------
+  #node(type, localName, prefix, namespaceUri, value, depth) {
+    this.#nodeType = type;
+    this.#localName = localName;
+    this.#prefix = prefix;
+    this.#namespaceUri = namespaceUri;
+    this.#value = value;
+    this.#depth = depth;
+    this.#isEmptyElement = false;
+    this.#attributes = [];
+  }
+  /** The character at `at`, asking for more text where it has not arrived; '' past the part's end. */
+  #charAt(text, at) {
+    if (at < text.length) return text.charAt(at);
+    if (!this.#ended) throw new NeedMore();
+    return "";
+  }
+  /** Where `token` next begins at or after `from`, asking for more text where it has not arrived; -1 past the part's end. */
+  #find(text, token, from) {
+    const at = text.indexOf(token, from);
+    if (at < 0 && !this.#ended) throw new NeedMore();
+    return at;
+  }
+  #prolog() {
+    const text = this.#text;
+    if (text.length < 6 && !this.#ended) throw new NeedMore();
+    if (text.startsWith("<?xml") && isSpace(text.charCodeAt(5))) {
+      const end = this.#find(text, "?>", 5);
+      if (end < 0) throw new XmlError("The XML declaration is not ended.");
+      const declaration2 = text.slice(5, end);
+      const encoding = /\bencoding\s*=\s*["']([^"']*)["']/.exec(declaration2)?.[1];
+      if (!/\bversion\s*=\s*["']1\.[0-9]+["']/.test(declaration2)) throw new XmlError("The XML declaration names no version 1.x.");
+      if (encoding !== void 0 && !/^(?:utf-?8|utf-?16|unicode)$/i.test(encoding)) {
+        throw new XmlError(`The part declares the encoding '${encoding}', which is not read.`);
+      }
+      this.#pos = end + 2;
+    }
+    this.#started = true;
+  }
+  #readText(text) {
+    const lt = this.#find(text, "<", this.#pos);
+    const end = lt < 0 ? text.length : lt;
+    const raw = text.slice(this.#pos, end);
+    checkCharacters(raw);
+    if (raw.includes("]]>")) throw new XmlError("']]>' is not allowed in text.");
+    const value = unescape(lineFeeds(raw));
+    let space = true;
+    for (let i = 0; i < raw.length; i++) {
+      if (!isSpace(raw.charCodeAt(i))) {
+        space = false;
+        break;
+      }
+    }
+    const depth = this.#stack.length;
+    if (depth === 0 && !space) throw new XmlError("Data at the root level is invalid.");
+    if (depth > 0 && lt < 0) throw new XmlError(`Unexpected end of file has occurred. The following elements are not closed: ${this.#stack.map((f) => f.name).toReversed().join(", ")}.`);
+    const preserve = this.#stack.at(-1)?.preserve === true;
+    this.#node(space ? preserve ? "significantWhitespace" : "whitespace" : "text", "", "", "", value, depth);
+    this.#pos = end;
+  }
+  #skipInstruction(text) {
+    const end = this.#find(text, "?>", this.#pos + 2);
+    if (end < 0) throw new XmlError("A processing instruction is not ended.");
+    const body = text.slice(this.#pos + 2, end);
+    const space = body.search(/\s/);
+    const target = space < 0 ? body : body.slice(0, space);
+    if (target.toLowerCase() === "xml") throw new XmlError("Unexpected XML declaration. The XML declaration must be the first node in the document.");
+    checkName(target);
+    checkCharacters(body);
+    this.#pos = end + 2;
+  }
+  /** A comment (skipped), CDATA (a node: true) or a document type (refused). */
+  #readBang(text) {
+    const at = this.#pos;
+    if (text.length < at + 9 && !this.#ended) throw new NeedMore();
+    if (text.startsWith("<!--", at)) {
+      const end = this.#find(text, "-->", at + 4);
+      if (end < 0) throw new XmlError("A comment is not ended.");
+      const body = text.slice(at + 4, end);
+      if (body.includes("--") || body.endsWith("-")) throw new XmlError("An XML comment cannot contain '--', and '-' cannot be the last character.");
+      checkCharacters(body);
+      this.#pos = end + 3;
+      return false;
+    }
+    if (text.startsWith("<![CDATA[", at)) {
+      if (this.#stack.length === 0) throw new XmlError("Data at the root level is invalid.");
+      const end = this.#find(text, "]]>", at + 9);
+      if (end < 0) throw new XmlError("A CDATA section is not ended.");
+      const body = text.slice(at + 9, end);
+      checkCharacters(body);
+      this.#node("cdata", "", "", "", lineFeeds(body), this.#stack.length);
+      this.#pos = end + 3;
+      return true;
+    }
+    if (text.startsWith("<!DOCTYPE", at)) {
+      throw new XmlError("For security reasons DTD is prohibited in this XML document. To enable DTD processing set the DtdProcessing property on XmlReaderSettings to Parse and pass the settings into XmlReader.Create method.");
+    }
+    throw new XmlError("An unexpected markup declaration was met.");
+  }
+  #readEnd(text) {
+    const close = this.#find(text, ">", this.#pos + 2);
+    if (close < 0) throw new XmlError("An end tag is not ended.");
+    const name = text.slice(this.#pos + 2, close).replace(/[\t\n\r ]+$/, "");
+    const frame = this.#stack.at(-1);
+    if (frame === void 0) throw new XmlError(`The end tag '${name}' closes no element.`);
+    if (frame.name !== name) throw new XmlError(`The '${frame.name}' start tag does not match the end tag of '${name}'.`);
+    this.#node("endElement", frame.localName, frame.prefix, frame.namespaceUri, "", this.#stack.length - 1);
+    this.#stack.pop();
+    if (this.#stack.length === 0) this.#rootClosed = true;
+    this.#pos = close + 1;
+  }
+  #readStart(text) {
+    if (this.#rootClosed) throw new XmlError("There are multiple root elements.");
+    let at = this.#pos + 1;
+    const nameEnd = (from) => {
+      let i = from;
+      for (; ; ) {
+        const c = this.#charAt(text, i);
+        if (c === "" || c === ">" || c === "/" || c === "=" || isSpace(c.charCodeAt(0))) return i;
+        i++;
+      }
+    };
+    const end = nameEnd(at);
+    const name = text.slice(at, end);
+    checkName(name);
+    at = end;
+    const raw = [];
+    let empty = false;
+    for (; ; ) {
+      let spaced = false;
+      while (isSpace(this.#charAt(text, at).charCodeAt(0))) {
+        at++;
+        spaced = true;
+      }
+      const c = this.#charAt(text, at);
+      if (c === ">") {
+        at++;
+        break;
+      }
+      if (c === "/") {
+        if (this.#charAt(text, at + 1) !== ">") throw new XmlError(`The start tag '${name}' is not ended.`);
+        at += 2;
+        empty = true;
+        break;
+      }
+      if (c === "") throw new XmlError(`The start tag '${name}' is not ended.`);
+      if (!spaced) throw new XmlError(`The start tag '${name}' needs white space before an attribute.`);
+      const attributeEnd = nameEnd(at);
+      const attributeName = text.slice(at, attributeEnd);
+      checkName(attributeName);
+      at = attributeEnd;
+      while (isSpace(this.#charAt(text, at).charCodeAt(0))) at++;
+      if (this.#charAt(text, at) !== "=") throw new XmlError(`The attribute '${attributeName}' has no value.`);
+      at++;
+      while (isSpace(this.#charAt(text, at).charCodeAt(0))) at++;
+      const quote = this.#charAt(text, at);
+      if (quote !== '"' && quote !== "'") throw new XmlError(`The value of the attribute '${attributeName}' is not quoted.`);
+      const close = this.#find(text, quote, at + 1);
+      if (close < 0) throw new XmlError(`The value of the attribute '${attributeName}' is not ended.`);
+      const written = text.slice(at + 1, close);
+      if (written.includes("<")) throw new XmlError(`'<', hexadecimal value 0x3C, is an invalid attribute character.`);
+      checkCharacters(written);
+      const value = unescape(written.replace(/\r\n|[\t\n\r]/g, " "));
+      if (raw.some((a) => a.name === attributeName)) throw new XmlError(`'${attributeName}' is a duplicate attribute name.`);
+      raw.push({ name: attributeName, value });
+      at = close + 1;
+    }
+    let declared = null;
+    let preserve = this.#stack.at(-1)?.preserve === true;
+    for (const attribute of raw) {
+      if (attribute.name === "xmlns") (declared ??= /* @__PURE__ */ new Map()).set("", attribute.value);
+      else if (attribute.name.startsWith("xmlns:")) (declared ??= /* @__PURE__ */ new Map()).set(attribute.name.slice(6), attribute.value);
+      else if (attribute.name === "xml:space") preserve = attribute.value === "preserve" ? true : attribute.value === "default" ? false : preserve;
+    }
+    const lookup = (prefix2) => {
+      if (prefix2 === "xml") return xmlNamespace;
+      if (prefix2 === "xmlns") return xmlnsNamespace;
+      const own = declared?.get(prefix2);
+      if (own !== void 0) return own;
+      for (let i = this.#stack.length - 1; i >= 0; i--) {
+        const uri = this.#stack[i]?.declared?.get(prefix2);
+        if (uri !== void 0) return uri;
+      }
+      return prefix2 === "" ? "" : void 0;
+    };
+    const [prefix, localName] = split(name);
+    const namespaceUri = lookup(prefix);
+    if (namespaceUri === void 0) throw new XmlError(`'${prefix}' is an undeclared prefix.`);
+    const attributes = raw.map((attribute) => {
+      if (attribute.name === "xmlns") return { name: "xmlns", prefix: "", localName: "xmlns", namespaceUri: xmlnsNamespace, value: attribute.value };
+      const [p, local] = split(attribute.name);
+      if (p === "") return { name: attribute.name, prefix: "", localName: local, namespaceUri: "", value: attribute.value };
+      const uri = lookup(p);
+      if (uri === void 0) throw new XmlError(`'${p}' is an undeclared prefix.`);
+      return { name: attribute.name, prefix: p, localName: local, namespaceUri: uri, value: attribute.value };
+    });
+    for (let i = 0; i < attributes.length; i++) {
+      const a = attributes[i];
+      if (a === void 0 || a.namespaceUri === "") continue;
+      for (let j = i + 1; j < attributes.length; j++) {
+        const b = attributes[j];
+        if (b !== void 0 && b.localName === a.localName && b.namespaceUri === a.namespaceUri) {
+          throw new XmlError(`The attribute '${b.localName}' of the namespace '${b.namespaceUri}' is written twice.`);
+        }
+      }
+    }
+    const depth = this.#stack.length;
+    this.#node("element", localName, prefix, namespaceUri, "", depth);
+    this.#isEmptyElement = empty;
+    this.#attributes = attributes;
+    this.#stack.push({ name, localName, prefix, namespaceUri, declared, preserve });
+    this.#popOnNext = empty;
+    this.#rootSeen = true;
+    if (empty && depth === 0) this.#rootClosed = true;
+    this.#pos = at;
+  }
+};
+
+// src/zip-read.ts
+var piece = 1 << 20;
+function byteSource(file) {
+  if (typeof Blob !== "undefined" && file instanceof Blob) {
+    return {
+      size: file.size,
+      read: async (offset, length) => new Uint8Array(await file.slice(offset, Math.min(file.size, offset + length)).arrayBuffer()),
+      stream: (offset, length) => file.slice(offset, offset + length).stream()
+    };
+  }
+  if (!(file instanceof Uint8Array) && !(file instanceof ArrayBuffer)) {
+    throw new TypeError("The file is a Uint8Array, an ArrayBuffer or a Blob.");
+  }
+  const bytes = file instanceof Uint8Array ? file : new Uint8Array(file);
+  return {
+    size: bytes.length,
+    read: (offset, length) => Promise.resolve(bytes.subarray(offset, Math.min(bytes.length, offset + length))),
+    stream: (offset, length) => {
+      let at = offset;
+      const end = Math.min(bytes.length, offset + length);
+      return new ReadableStream({
+        pull(controller) {
+          if (at >= end) {
+            controller.close();
+            return;
+          }
+          const next = Math.min(end, at + piece);
+          controller.enqueue(bytes.slice(at, next));
+          at = next;
+        }
+      });
+    }
+  };
+}
+var ZipFormatError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ZipFormatError";
+  }
+};
+function u16(bytes, at) {
+  const low2 = bytes[at];
+  const high = bytes[at + 1];
+  if (low2 === void 0 || high === void 0) throw new ZipFormatError("A record of the zip is cut short.");
+  return low2 | high << 8;
+}
+function u32(bytes, at) {
+  return (u16(bytes, at) | u16(bytes, at + 2) << 16) >>> 0;
+}
+function u64(bytes, at) {
+  const value = u32(bytes, at) + u32(bytes, at + 4) * 4294967296;
+  return value > Number.MAX_SAFE_INTEGER ? Number.POSITIVE_INFINITY : value;
+}
+function need(bytes, length, what) {
+  if (bytes.length < length) throw new ZipFormatError(`${what} is cut short.`);
+}
+var utf8 = new TextDecoder();
+async function readCentralDirectory(source) {
+  const tailLength = Math.min(source.size, 22 + 65535);
+  const tailStart = source.size - tailLength;
+  const tail = await source.read(tailStart, tailLength);
+  let end = -1;
+  for (let at2 = tail.length - 22; at2 >= 0; at2--) {
+    if (u32(tail, at2) === 101010256) {
+      end = at2;
+      break;
+    }
+  }
+  if (end < 0) throw new ZipFormatError("End of Central Directory record could not be found.");
+  let count2 = u16(tail, end + 10);
+  let size = u32(tail, end + 12);
+  let offset = u32(tail, end + 16);
+  if (count2 === 65535 || size === 4294967295 || offset === 4294967295) {
+    const locator = end - 20;
+    if (locator < 0 || u32(tail, locator) !== 117853008) throw new ZipFormatError("The Zip64 end of central directory locator could not be found.");
+    const at2 = u64(tail, locator + 8);
+    const record = await source.read(at2, 56);
+    need(record, 56, "The Zip64 end of central directory record");
+    if (u32(record, 0) !== 101075792) throw new ZipFormatError("The Zip64 end of central directory record could not be found.");
+    count2 = u64(record, 32);
+    size = u64(record, 40);
+    offset = u64(record, 48);
+  }
+  if (!Number.isFinite(size) || !Number.isFinite(offset) || offset + size > source.size) {
+    throw new ZipFormatError("The central directory lies outside the file.");
+  }
+  const directory = await source.read(offset, size);
+  const entries = [];
+  let at = 0;
+  while (at + 46 <= directory.length && u32(directory, at) === 33639248) {
+    const flags = u16(directory, at + 8);
+    const method = u16(directory, at + 10);
+    let compressedSize = u32(directory, at + 20);
+    let uncompressedSize = u32(directory, at + 24);
+    const nameLength = u16(directory, at + 28);
+    const extraLength = u16(directory, at + 30);
+    const commentLength = u16(directory, at + 32);
+    let localHeaderOffset = u32(directory, at + 42);
+    const nameAt = at + 46;
+    need(directory, nameAt + nameLength + extraLength + commentLength, "The central directory");
+    const name = utf8.decode(directory.subarray(nameAt, nameAt + nameLength));
+    let extra = nameAt + nameLength;
+    const extraEnd = extra + extraLength;
+    while (extra + 4 <= extraEnd) {
+      const id = u16(directory, extra);
+      const length = u16(directory, extra + 2);
+      if (id === 1) {
+        let field = extra + 4;
+        if (uncompressedSize === 4294967295) {
+          uncompressedSize = u64(directory, field);
+          field += 8;
+        }
+        if (compressedSize === 4294967295) {
+          compressedSize = u64(directory, field);
+          field += 8;
+        }
+        if (localHeaderOffset === 4294967295) {
+          localHeaderOffset = u64(directory, field);
+        }
+      }
+      extra += 4 + length;
+    }
+    entries.push({ name, method, flags, compressedSize, uncompressedSize, localHeaderOffset });
+    at = extraEnd + commentLength;
+  }
+  if (entries.length !== count2) {
+    throw new ZipFormatError("Number of entries expected in End Of Central Directory does not correspond to number of entries in Central Directory.");
+  }
+  return entries;
+}
+async function dataOffset(source, entry) {
+  const header2 = await source.read(entry.localHeaderOffset, 30);
+  if (header2.length < 30 || u32(header2, 0) !== 67324752) throw new ZipFormatError("A local file header is corrupt.");
+  const start = entry.localHeaderOffset + 30 + u16(header2, 26) + u16(header2, 28);
+  if (start + entry.compressedSize > source.size) throw new ZipFormatError("A local file header is corrupt.");
+  return start;
+}
+
+// src/package.ts
+var headLength = 64 * 1024;
+var PartBytes = class {
+  #reader;
+  #declared;
+  #deflated;
+  #part;
+  #sheet;
+  #head = new Uint8Array(headLength);
+  #headLength = 0;
+  #read = 0;
+  #done = false;
+  constructor(stream, entry, part, sheet) {
+    this.#deflated = entry.method === 8;
+    this.#reader = (this.#deflated ? stream.pipeThrough(new DecompressionStream("deflate-raw")) : stream).getReader();
+    this.#declared = entry.uncompressedSize;
+    this.#part = part;
+    this.#sheet = sheet;
+  }
+  /** The bytes inflated so far. */
+  get bytesRead() {
+    return this.#read;
+  }
+  /** The first bytes the part inflated to, as far as they have been read. */
+  get head() {
+    return this.#head.subarray(0, this.#headLength);
+  }
+  /**
+   * The next bytes, or `undefined` at the part's end. A deflated part is inflated no further than it declares, as .NET
+   * cuts it; a stored one, which .NET reads to its compressed size, is refused past it: a zip bomb's headers may lie.
+   * Bytes that cannot be inflated are refused as malformed, naming the part.
+   */
+  async next() {
+    if (this.#done) return void 0;
+    let result;
+    try {
+      result = await this.#reader.read();
+    } catch (error) {
+      this.#done = true;
+      throw new XlsxError("malformed", `The part's compressed bytes cannot be inflated: ${inflateFailure(error)}`, { part: this.#part, sheet: this.#sheet }, { cause: error });
+    }
+    if (result.done) {
+      this.#done = true;
+      return void 0;
+    }
+    let bytes = result.value;
+    if (this.#read + bytes.length > this.#declared) {
+      if (!this.#deflated) {
+        throw new XlsxError(
+          "tooLarge",
+          `The part inflates to more than the ${grouped(this.#declared)} bytes the zip declares for it.`,
+          { part: this.#part, sheet: this.#sheet }
+        );
+      }
+      bytes = bytes.subarray(0, this.#declared - this.#read);
+      this.#done = true;
+      await this.#reader.cancel();
+    }
+    if (this.#headLength < headLength) {
+      const kept = bytes.subarray(0, headLength - this.#headLength);
+      this.#head.set(kept, this.#headLength);
+      this.#headLength += kept.length;
+    }
+    this.#read += bytes.length;
+    return bytes;
+  }
+  /** Lets go of what the part has not read. */
+  async close() {
+    if (this.#done) return;
+    this.#done = true;
+    await this.#reader.cancel();
+  }
+};
+function inflateFailure(error) {
+  if (!(error instanceof Error)) return String(error);
+  if (error.message === "" && error.cause instanceof Error) return error.cause.message;
+  return error.message;
+}
+function encodingOf(head) {
+  const [a, b, c, d] = head;
+  if (a === 255 && b === 254) return "utf-16le";
+  if (a === 254 && b === 255) return "utf-16be";
+  if (a === 60 && b === 0 && c === 63 && d === 0) return "utf-16le";
+  if (a === 0 && b === 60 && c === 0 && d === 63) return "utf-16be";
+  return "utf-8";
+}
+function textOf(bytes) {
+  let decoder;
+  let held = new Uint8Array(0);
+  let finished = false;
+  const decode = (chunk, stream) => {
+    try {
+      return (decoder ??= new TextDecoder(encodingOf(chunk), { fatal: true })).decode(chunk, { stream });
+    } catch (error) {
+      throw new XmlError("Invalid character in the given encoding.", { cause: error });
+    }
+  };
+  return async () => {
+    if (finished) return void 0;
+    for (; ; ) {
+      const chunk = await bytes.next();
+      if (chunk === void 0) {
+        finished = true;
+        const rest = decode(held, false);
+        held = new Uint8Array(0);
+        return rest;
+      }
+      if (decoder === void 0 && held.length + chunk.length < 4) {
+        const more = new Uint8Array(held.length + chunk.length);
+        more.set(held);
+        more.set(chunk, held.length);
+        held = more;
+        continue;
+      }
+      if (held.length > 0) {
+        const joined = new Uint8Array(held.length + chunk.length);
+        joined.set(held);
+        joined.set(chunk, held.length);
+        held = new Uint8Array(0);
+        return decode(joined, true);
+      }
+      return decode(chunk, true);
+    }
+  };
+}
+var Package = class _Package {
+  #source;
+  #entries;
+  /** The parts' names, in the zip's order, as the first entry of each name in any case writes it. */
+  partNames;
+  constructor(source, entries, names) {
+    this.#source = source;
+    this.#entries = entries;
+    this.partNames = names;
+  }
+  /** The zip in `source`, refused when it cannot be read or holds more than `maxUncompressedBytes`. */
+  static async open(source, maxUncompressedBytes) {
+    let listed;
+    try {
+      listed = await readCentralDirectory(source);
+    } catch (error) {
+      if (!(error instanceof ZipFormatError)) throw error;
+      throw new XlsxError("notAZip", `The file is not a zip package that can be read: ${error.message}`, {}, { cause: error });
+    }
+    const entries = /* @__PURE__ */ new Map();
+    const names = [];
+    for (const entry of listed) {
+      if (entry.name.endsWith("/")) continue;
+      const name = entry.name.replace(/^\/+/, "");
+      const key = foldCase(name);
+      if (entries.has(key)) continue;
+      entries.set(key, entry);
+      names.push(name);
+    }
+    let total = 0;
+    for (const entry of entries.values()) {
+      total += entry.uncompressedSize;
+      if (total > maxUncompressedBytes) {
+        throw new XlsxError(
+          "tooLarge",
+          `The file holds more than the ${grouped(maxUncompressedBytes)} uncompressed bytes a read is allowed (XlsxReadOptions.MaxUncompressedBytes).`
+        );
+      }
+    }
+    return new _Package(source, entries, Object.freeze(names));
+  }
+  has(part) {
+    return this.#entries.has(foldCase(part));
+  }
+  lengthOf(part) {
+    return this.#entries.get(foldCase(part))?.uncompressedSize ?? 0;
+  }
+  /** The part's bytes as they inflate, or `undefined` when the package has no such part.
+   * @param sheet - The Sheet the part is, named by a refusal the read meets. */
+  async openPart(part, sheet) {
+    const entry = this.#entries.get(foldCase(part));
+    if (entry === void 0) return void 0;
+    if (entry.method !== 0 && entry.method !== 8) {
+      throw new XlsxError("notAZip", "The part cannot be inflated: The archive entry was compressed using an unsupported compression method.", { part, sheet });
+    }
+    let start;
+    try {
+      start = await dataOffset(this.#source, entry);
+    } catch (error) {
+      if (!(error instanceof ZipFormatError)) throw error;
+      throw new XlsxError("notAZip", `The part cannot be inflated: ${error.message}`, { part, sheet }, { cause: error });
+    }
+    return new PartBytes(this.#source.stream(start, entry.compressedSize), entry, part, sheet);
+  }
+  /** The part's XML, being read a piece at a time, or `undefined` when the package has no such part. */
+  async openXml(part, sheet) {
+    const bytes = await this.openPart(part, sheet);
+    return bytes === void 0 ? void 0 : { xml: new XmlReader(textOf(bytes)), bytes };
+  }
+  /** The part's XML with all of its text read, for a part read whole, or `undefined` when the package has no such part. */
+  async readXml(part) {
+    const opened = await this.openXml(part);
+    if (opened === void 0) return void 0;
+    await opened.xml.fill(Number.POSITIVE_INFINITY);
+    return opened;
+  }
+  /**
+   * The refusal a part that is not well-formed stands for: one that declares a document type, which the first 64 KiB
+   * show in any part a workbook has, or one that is not well-formed.
+   */
+  static refuse(error, opened, part, sheet) {
+    if (new TextDecoder().decode(opened.bytes.head).includes("<!DOCTYPE")) {
+      return new XlsxError("dtd", "The part declares a document type (<!DOCTYPE), which a workbook never needs; it is not read.", { part, sheet }, { cause: error });
+    }
+    return new XlsxError("malformed", `The part is not well-formed XML: ${error.message}`, { part, sheet }, { cause: error });
+  }
+};
+var ole = [208, 207, 17, 224, 161, 177, 26, 225];
+function isOle(head) {
+  return head.length >= ole.length && ole.every((b, i) => head[i] === b);
+}
+function isZip(head) {
+  return head.length >= 4 && head[0] === 80 && head[1] === 75 && (head[2] === 3 && head[3] === 4 || head[2] === 5 && head[3] === 6 || head[2] === 7 && head[3] === 8);
+}
+var lastSector = 4294967290;
+var endOfChain = 4294967294;
+var guard = 1 << 16;
+async function classifyOle(source) {
+  if (await isEncrypted(source)) {
+    return new XlsxError(
+      "encrypted",
+      "The file is an encrypted workbook. Remove its password in Excel (File, Info, Protect Workbook, Encrypt with Password) and save it again."
+    );
+  }
+  return new XlsxError(
+    "legacy",
+    "The file is an Excel 97\u20132003 workbook (.xls), or another Office binary file, not an .xlsx. Save it from Excel as an Excel Workbook (.xlsx)."
+  );
+}
+async function readExactly(source, offset, length) {
+  if (offset + length > source.size) return void 0;
+  const bytes = await source.read(offset, length);
+  return bytes.length === length ? bytes : void 0;
+}
+async function isEncrypted(source) {
+  const header2 = await readExactly(source, 0, 512);
+  if (header2 === void 0) return false;
+  const shift = u16(header2, 30);
+  if (shift !== 9 && shift !== 12) return false;
+  const size = 1 << shift;
+  const perSector = size / 4;
+  const at = (sector) => (sector + 1) * size;
+  const fatSectors = [];
+  for (let i = 0; i < 109; i++) {
+    const s = u32(header2, 76 + i * 4);
+    if (s < lastSector) fatSectors.push(s);
+  }
+  let difat = u32(header2, 68);
+  let difatRead = 0;
+  const fatCache = /* @__PURE__ */ new Map();
+  const next = async (sector) => {
+    const fat = Math.floor(sector / perSector);
+    while (fat >= fatSectors.length && difat < lastSector && difatRead++ < guard) {
+      const block = await readExactly(source, at(difat), size);
+      if (block === void 0) return endOfChain;
+      for (let i = 0; i < size / 4 - 1; i++) {
+        const s = u32(block, i * 4);
+        if (s < lastSector) fatSectors.push(s);
+      }
+      difat = u32(block, size - 4);
+    }
+    const fatSector = fatSectors[fat];
+    if (fatSector === void 0) return endOfChain;
+    let entries = fatCache.get(fat);
+    if (entries === void 0) {
+      const read = await readExactly(source, at(fatSector), size);
+      entries = read === void 0 ? null : read;
+      fatCache.set(fat, entries);
+    }
+    return entries === null ? endOfChain : u32(entries, sector % perSector * 4);
+  };
+  const names = new TextDecoder("utf-16le");
+  let dir = u32(header2, 48);
+  for (let step = 0; dir < lastSector && step < guard; step++) {
+    const directory = await readExactly(source, at(dir), size);
+    if (directory === void 0) break;
+    for (let e = 0; e < size / 128; e++) {
+      const entry = directory.subarray(e * 128, e * 128 + 128);
+      const length = u16(entry, 64);
+      if (length >= 2 && length <= 64) {
+        const name = names.decode(entry.subarray(0, length - 2));
+        if (name === "EncryptedPackage" || name === "EncryptionInfo") return true;
+      }
+    }
+    dir = await next(dir);
+  }
+  return false;
+}
+
+// src/pacer.ts
+var defaultMaxUncompressedBytes = 2 ** 30;
+var defaultMaxCells = 1e7;
+function macrotask() {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, 0);
+  });
+}
+var Pacer = class {
+  #budget;
+  #yield;
+  #onProgress;
+  #signal;
+  #sliceStart = performance.now();
+  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;
+  }
+  cancelled() {
+    this.#signal?.throwIfAborted();
+  }
+  /** A point between batches: when the slice has spent its budget, reports `progress` and yields. */
+  async checkpoint(progress) {
+    this.cancelled();
+    if (performance.now() < this.#sliceStart + this.#budget) return;
+    this.#onProgress?.(progress());
+    await this.#yield();
+    this.cancelled();
+    this.#sliceStart = performance.now();
+  }
+  report(progress) {
+    this.#onProgress?.(progress);
+  }
+};
+
+// src/shared-strings.ts
+var XlsxSharedStrings = class _XlsxSharedStrings {
+  /** A workbook with no shared strings. */
+  static empty = new _XlsxSharedStrings([], /* @__PURE__ */ new Set());
+  #texts;
+  #rich;
+  /** The strings `texts`, those at the indexes in `rich` marked as having come in runs. */
+  constructor(texts, rich) {
+    this.#texts = Object.freeze(texts);
+    this.#rich = rich;
+  }
+  /** The strings, in the part's order: a cell's `<v>` is an index into them. */
+  get texts() {
+    return this.#texts;
+  }
+  /** How many there are. */
+  get count() {
+    return this.#texts.length;
+  }
+  /** Whether the string at `index` came in runs of their own formatting, which are not carried; its text is. */
+  isRich(index) {
+    return this.#rich.has(index);
+  }
+};
+
+// src/model.ts
+function referenceOf(cell) {
+  return formatCell(cell.row, cell.column);
+}
+function isValidTableName(name) {
+  return name.length > 0 && name.length <= 255 && !/[\uD800-\uDFFF]/.test(name) && /^[\p{L}_\\][\p{L}\p{Nd}_.]*$/u.test(name) && parseCell(name) === void 0 && !/^[Rr][0-9]*[Cc][0-9]*$|^[RrCc]$/.test(name) && !equalsIgnoreCase(name, "TRUE") && !equalsIgnoreCase(name, "FALSE");
+}
+function tableReference(table2) {
+  return `${formatCell(table2.headerRow, table2.firstColumn)}:${formatCell(table2.headerRow + table2.dataRows, table2.firstColumn + table2.columns.length - 1)}`;
+}
+var elementMaxDepth = 3;
+var elementMaxChildren = 16;
+var elementMaxText = 1024;
+
+// src/x-string.ts
+function hexAt(text, at) {
+  const digits = text.slice(at, at + 4);
+  return /^[0-9A-Fa-f]{4}$/.test(digits) ? Number.parseInt(digits, 16) : void 0;
+}
+function decodeXString(text) {
+  let at = text.indexOf("_x");
+  if (at < 0) return text;
+  let out = "";
+  let start = 0;
+  while (at >= 0) {
+    const code = at + 7 <= text.length && text.charAt(at + 6) === "_" ? hexAt(text, at + 2) : void 0;
+    if (code !== void 0) {
+      out += text.slice(start, at) + String.fromCharCode(code);
+      start = at + 7;
+      at = text.indexOf("_x", start);
+    } else {
+      at = text.indexOf("_x", at + 2);
+    }
+  }
+  return out + text.slice(start);
+}
+function escaped(c) {
+  return c < 32 && c !== 9 && c !== 10 || c === 65534 || c === 65535;
+}
+function looksEscaped(text, at) {
+  return at + 7 <= text.length && text.charAt(at + 1) === "x" && text.charAt(at + 6) === "_" && hexAt(text, at + 2) !== void 0;
+}
+function encodeXString(text) {
+  let needs = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 95 || escaped(c)) {
+      needs = true;
+      break;
+    }
+  }
+  if (!needs) return text;
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (escaped(c)) out += `_x${c.toString(16).toUpperCase().padStart(4, "0")}_`;
+    else if (c === 95 && looksEscaped(text, i)) out += "_x005F_";
+    else out += text.charAt(i);
+  }
+  return out;
+}
+function carries(text, encoded) {
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c >= 55296 && c <= 56319) {
+      const next = i + 1 < text.length ? text.charCodeAt(i + 1) : 0;
+      if (next >= 56320 && next <= 57343) {
+        i++;
+        continue;
+      }
+      return false;
+    }
+    if (c >= 56320 && c <= 57343) return false;
+    if (!encoded && (c < 32 && c !== 9 && c !== 10 && c !== 13 || c === 65534 || c === 65535)) return false;
+  }
+  return true;
+}
+
+// src/string-item.ts
+function readText(xml) {
+  if (xml.isEmptyElement()) return ["", false];
+  const depth = xml.depth();
+  let text = "";
+  let rich = false;
+  xml.read();
+  while (!xml.eof() && !(xml.nodeType() === "endElement" && xml.depth() === depth)) {
+    if (xml.nodeType() !== "element") {
+      xml.read();
+      continue;
+    }
+    switch (xml.localName()) {
+      case "t":
+        text += xml.readElementContentAsString();
+        break;
+      case "r":
+        rich = true;
+        if (xml.isEmptyElement()) xml.skip();
+        else xml.read();
+        break;
+      default:
+        xml.skip();
+        break;
+    }
+  }
+  return [decodeXString(text), rich];
+}
+
+// src/steps.ts
+var margin = 64 * 1024;
+var ahead = 1 << 20;
+function low(xml) {
+  return !xml.ended() && xml.unread() < margin;
+}
+async function runSteps(xml, save, step) {
+  let want = ahead;
+  for (; ; ) {
+    await xml.fill(want);
+    const mark = xml.snapshot();
+    const rewind = save();
+    let end;
+    try {
+      end = step();
+    } catch (error) {
+      if (!(error instanceof NeedMore)) throw error;
+      xml.restore(mark);
+      rewind();
+      want = Math.max(want, xml.unread()) * 2;
+      continue;
+    }
+    if (end !== "more") return end;
+    want = ahead;
+  }
+}
+
+// src/values.ts
+function bool(value) {
+  return value === "1" || value === "true";
+}
+function int(value, where) {
+  const n = parseInt32(value);
+  if (n === void 0) throw new XlsxError("malformed", `'${value}' is not a whole number where the part needs one.`, where);
+  return n;
+}
+function double(value, part) {
+  const n = parseDouble(value);
+  if (n === void 0) throw new XlsxError("malformed", `'${value}' is not a number where the part needs one.`, { part });
+  return n;
+}
+
+// src/sheet-reader.ts
+var batchSize = 4096;
+var SheetReader = class {
+  #owner;
+  #index;
+  #part;
+  #opened;
+  #batch = [];
+  #columns = [];
+  #rows = [];
+  #other = [];
+  #state = "start";
+  #row = -1;
+  #column = -1;
+  #reported = 0;
+  #customRowHeights = false;
+  #hiddenRows = false;
+  #frozenPanes = false;
+  #closed = false;
+  /** The sheet as the workbook lists it. */
+  sheet;
+  constructor(owner, index, sheet, part, opened) {
+    this.#owner = owner;
+    this.#index = index;
+    this.sheet = sheet;
+    this.#part = part;
+    this.#opened = opened;
+  }
+  /** The cells of the batch the last `read` read, in the file's order. */
+  get cells() {
+    return this.#batch;
+  }
+  /** The rows the last `read` began that record a cell format of their own (`customFormat`), in the file's order. A row
+   * comes in the batch that holds its first cell, or in an earlier one. */
+  get rows() {
+    return this.#rows;
+  }
+  /** The worksheet's column widths, complete once the first `read` has returned: they come before the cells. */
+  get columns() {
+    return this.#columns;
+  }
+  /**
+   * Every element of the worksheet the reader does not read, beside its cells and columns, in the file's order, complete
+   * once `read` has returned false: `dimension`, `sheetViews` (of which only `frozenPanes` is read), `sheetFormatPr`,
+   * `mergeCells`, `conditionalFormatting`, `dataValidations`, `hyperlinks`, `drawing`, `legacyDrawing` (notes),
+   * `tableParts`, `sheetProtection`, `pageMargins`, `pageSetup`, `extLst` and the rest, each as far as `XlsxElement`
+   * keeps it. None of it is judged here: whether an element holds anything that matters is for the reader of the file to
+   * say.
+   */
+  get otherElements() {
+    return this.#other;
+  }
+  /** Whether a row read so far sets a height of its own. */
+  get customRowHeights() {
+    return this.#customRowHeights;
+  }
+  /** Whether a row read so far is hidden. */
+  get hiddenRows() {
+    return this.#hiddenRows;
+  }
+  /** Whether the sheet's view freezes panes; known once the first `read` has returned. */
+  get frozenPanes() {
+    return this.#frozenPanes;
+  }
+  /**
+   * Reads the next batch of cells into `cells`; false when the worksheet has no more. Refuses the file by name
+   * (`XlsxError`) on a cell it cannot read, or past the read's cells.
+   */
+  async read() {
+    if (this.#closed) throw new Error("The worksheet reader is closed.");
+    this.#batch.length = 0;
+    this.#rows.length = 0;
+    if (this.#finished()) return false;
+    await this.#owner.checkpoint(this.#index);
+    const { xml, bytes } = this.#opened;
+    try {
+      await runSteps(xml, () => this.#save(), () => this.#step());
+    } catch (error) {
+      if (error instanceof XmlError) throw Package.refuse(error, this.#opened, this.#part, this.sheet.name);
+      throw error;
+    } finally {
+      this.#owner.countBytes(bytes.bytesRead - this.#reported);
+      this.#reported = bytes.bytesRead;
+    }
+    if (this.#finished()) {
+      this.#owner.report(this.#index);
+      await bytes.close();
+    }
+    return this.#batch.length > 0 || this.#rows.length > 0 || !this.#finished();
+  }
+  #finished() {
+    return this.#stateIs("finished");
+  }
+  /** The state, read where a call before may have changed it. */
+  #stateIs(state) {
+    return this.#state === state;
+  }
+  /** Closes the worksheet's part. */
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#owner.closed();
+    await this.#opened.bytes.close();
+  }
+  /** What puts the reader back where a step began, for a step read again with more text. */
+  #save() {
+    const state = this.#state;
+    const row = this.#row;
+    const column = this.#column;
+    const batch = this.#batch.length;
+    const rows = this.#rows.length;
+    const columns = this.#columns.length;
+    const other = this.#other.length;
+    const flags = [this.#customRowHeights, this.#hiddenRows, this.#frozenPanes];
+    const cells = this.#owner.cells();
+    return () => {
+      this.#state = state;
+      this.#row = row;
+      this.#column = column;
+      this.#batch.length = batch;
+      this.#rows.length = rows;
+      this.#columns.length = columns;
+      this.#other.length = other;
+      [this.#customRowHeights, this.#hiddenRows, this.#frozenPanes] = flags;
+      this.#owner.rewindCells(cells);
+    };
+  }
+  #step() {
+    if (this.#state === "start") this.#readRoot();
+    if (this.#state === "head" && this.#readHead() === "more") return "more";
+    if (this.#state === "cells") {
+      const end = this.#readCells();
+      if (end !== "done" || this.#stateIs("cells")) return end;
+    }
+    if (this.#state === "tail" && this.#readTail() === "more") return "more";
+    return "done";
+  }
+  #where(cell) {
+    return cell === void 0 ? { part: this.#part, sheet: this.sheet.name } : { part: this.#part, sheet: this.sheet.name, cell };
+  }
+  /** Reads the root, and refuses a worksheet that is not one. */
+  #readRoot() {
+    const xml = this.#opened.xml;
+    xml.moveToContent();
+    if (xml.namespaceUri().startsWith(strictPrefix)) {
+      throw new XlsxError("strictOpenXml", "The worksheet is saved as Strict Open XML, which is not read.", this.#where());
+    }
+    if (xml.localName() !== "worksheet") throw new XlsxError("malformed", `The worksheet part's root is <${xml.localName()}>, not <worksheet>.`, this.#where());
+    if (xml.isEmptyElement()) {
+      this.#state = "tail";
+      return;
+    }
+    xml.read();
+    this.#state = "head";
+  }
+  /** Reads the children before `<sheetData>`. */
+  #readHead() {
+    const xml = this.#opened.xml;
+    while (!xml.eof() && !(xml.nodeType() === "endElement" && xml.depth() === 0)) {
+      if (xml.nodeType() !== "element") {
+        xml.read();
+        continue;
+      }
+      if (low(xml)) return "more";
+      switch (xml.localName()) {
+        case "sheetData":
+          this.#state = xml.isEmptyElement() ? "tail" : "cells";
+          xml.read();
+          return "done";
+        case "cols":
+          this.#readColumns();
+          break;
+        case "sheetViews": {
+          const views = this.#readElement(0);
+          this.#other.push(views);
+          this.#frozenPanes = views.children.some((view) => view.children.some((pane) => {
+            const state = pane.attributes.get("state");
+            return pane.name === "pane" && (state === "frozen" || state === "frozenSplit");
+          }));
+          break;
+        }
+        default:
+          this.#other.push(this.#readElement(0));
+          break;
+      }
+    }
+    this.#state = "tail";
+    return "done";
+  }
+  #readColumns() {
+    const xml = this.#opened.xml;
+    if (xml.isEmptyElement()) {
+      xml.read();
+      return;
+    }
+    const depth = xml.depth();
+    const sheet = this.sheet.name;
+    const part = this.#part;
+    xml.read();
+    while (!xml.eof() && !(xml.nodeType() === "endElement" && xml.depth() === depth)) {
+      if (xml.nodeType() === "element" && xml.localName() === "col") {
+        const a = xml.getAttribute("min");
+        const b = xml.getAttribute("max");
+        const min = a === void 0 ? 0 : int(a, { part, sheet });
+        const max = b === void 0 ? min : int(b, { part, sheet });
+        if (min < 1 || max < min || max > maxColumns) {
+          throw new XlsxError("malformed", `A column range ${String(min)} to ${String(max)} lies outside the sheet's columns.`, { part, sheet });
+        }
+        const w = xml.getAttribute("width");
+        const width = w === void 0 ? null : double(w, part);
+        const hidden = bool(xml.getAttribute("hidden"));
+        const s = xml.getAttribute("style");
+        const style = s === void 0 ? 0 : int(s, { part, sheet });
+        if (style < 0 || style >= this.#owner.styles.cellFormats.length) {
+          throw new XlsxError(
+            "malformed",
+            `The columns ${String(min)} to ${String(max)} name the cell format ${String(style)}, which the styles do not hold.`,
+            { part, sheet }
+          );
+        }
+        this.#columns.push(Object.freeze({
+          first: min - 1,
+          last: max - 1,
+          width,
+          hidden,
+          styleIndex: style,
+          bestFit: bool(xml.getAttribute("bestFit")),
+          customWidth: width === null || bool(xml.getAttribute("customWidth"))
+        }));
+      }
+      if (xml.nodeType() === "element") xml.skip();
+      else xml.read();
+    }
+    xml.read();
+  }
+  /** The element at the reader, kept as `XlsxElement` keeps it, `depth` levels below the worksheet's element; the reader
+   * is left past its end. */
+  #readElement(depth) {
+    const xml = this.#opened.xml;
+    const name = xml.localName();
+    const attributes = /* @__PURE__ */ new Map();
+    for (const attribute of xml.attributes()) {
+      if (attribute.namespaceUri !== "http://www.w3.org/2000/xmlns/" && !attributes.has(attribute.localName)) {
+        attributes.set(attribute.localName, attribute.value);
+      }
+    }
+    if (xml.isEmptyElement()) {
+      xml.read();
+      return Object.freeze({ name, attributes, children: Object.freeze([]), text: null, childrenCut: false });
+    }
+    const children2 = [];
+    let text = null;
+    let cut = false;
+    const end = xml.depth();
+    xml.read();
+    while (!xml.eof() && !(xml.nodeType() === "endElement" && xml.depth() === end)) {
+      const node = xml.nodeType();
+      switch (node) {
+        case "element":
+          if (depth < elementMaxDepth && children2.length < elementMaxChildren) {
+            children2.push(this.#readElement(depth + 1));
+          } else {
+            cut = true;
+            xml.skip();
+          }
+          break;
+        case "text":
+        case "cdata":
+        case "significantWhitespace": {
+          const kept = text === null ? "" : text;
+          text = kept + xml.value().slice(0, elementMaxText - kept.length);
+          xml.read();
+          break;
+        }
+        case "whitespace":
+        case "endElement":
+        case "none":
+          xml.read();
+          break;
+        default:
+          unreachable(node);
+      }
+    }
+    xml.read();
+    return Object.freeze({ name, attributes, children: Object.freeze(children2), text, childrenCut: cut });
+  }
+  /** Reads cells until the batch is full, `<sheetData>` ends, or the text ahead runs low. */
+  #readCells() {
+    const xml = this.#opened.xml;
+    while (this.#batch.length + this.#rows.length < batchSize) {
+      if (xml.eof()) throw new XlsxError("malformed", "The worksheet ends inside its cells.", this.#where());
+      if (low(xml)) return "more";
+      const node = xml.nodeType();
+      switch (node) {
+        case "element":
+          if (xml.localName() === "row") {
+            this.#startRow();
+            if (xml.isEmptyElement()) xml.skip();
+            else xml.read();
+          } else if (xml.localName() === "c") {
+            this.#readCell();
+          } else {
+            xml.skip();
+          }
+          break;
+        case "endElement":
+          if (xml.localName() === "sheetData") {
+            xml.read();
+            this.#state = "tail";
+            return "done";
+          }
+          xml.read();
+          break;
+        case "text":
+        case "cdata":
+        case "whitespace":
+        case "significantWhitespace":
+        case "none":
+          xml.read();
+          break;
+        default:
+          unreachable(node);
+      }
+    }
+    return "done";
+  }
+  #startRow() {
+    const xml = this.#opened.xml;
+    const where = this.#where();
+    let r = this.#row + 1;
+    let style;
+    let customFormat = false;
+    for (const attribute of xml.attributes()) {
+      switch (attribute.localName) {
+        case "r":
+          r = int(attribute.value, where) - 1;
+          break;
+        case "customHeight":
+          if (bool(attribute.value)) this.#customRowHeights = true;
+          break;
+        case "hidden":
+          if (bool(attribute.value)) this.#hiddenRows = true;
+          break;
+        case "s":
+          style = attribute.value;
+          break;
+        case "customFormat":
+          customFormat = bool(attribute.value);
+          break;
+        default:
+          break;
+      }
+    }
+    if (r < 0 || r >= maxRows) throw new XlsxError("malformed", `Row ${String(r + 1)} lies outside the sheet's rows.`, where);
+    if (r <= this.#row) {
+      throw new XlsxError("malformed", `Row ${String(r + 1)} comes after row ${String(this.#row + 1)}: a worksheet's rows are in order, each once.`, where);
+    }
+    this.#row = r;
+    this.#column = -1;
+    if (!customFormat) return;
+    const index = style === void 0 ? 0 : int(style, where);
+    if (index < 0 || index >= this.#owner.styles.cellFormats.length) {
+      throw new XlsxError("malformed", `Row ${String(r + 1)} names the cell format ${String(index)}, which the styles do not hold.`, where);
+    }
+    this.#rows.push(Object.freeze({ row: r, styleIndex: index }));
+  }
+  #readCell() {
+    const xml = this.#opened.xml;
+    let reference;
+    let type;
+    let style;
+    let metadata;
+    for (const attribute of xml.attributes()) {
+      switch (attribute.localName) {
+        case "r":
+          reference = attribute.value;
+          break;
+        case "t":
+          type = attribute.value;
+          break;
+        case "s":
+          style = attribute.value;
+          break;
+        case "cm":
+          metadata = attribute.value;
+          break;
+        default:
+          break;
+      }
+    }
+    let r;
+    let c;
+    if (reference === void 0) {
+      r = this.#row < 0 ? 0 : this.#row;
+      c = this.#column + 1;
+      if (c >= maxColumns) throw new XlsxError("malformed", "A cell lies past the sheet's last column.", this.#where());
+    } else {
+      const place = parseCell(reference);
+      if (place === void 0) throw new XlsxError("malformed", `'${reference}' is not a cell of the sheet.`, this.#where());
+      r = place.row;
+      c = place.column;
+      if (this.#row >= 0 && r !== this.#row) {
+        throw new XlsxError("malformed", `The cell is written inside row ${String(this.#row + 1)}, not its own.`, this.#where(reference));
+      }
+      if (c <= this.#column) {
+        throw new XlsxError(
+          "malformed",
+          `The cell comes after ${formatCell(r, this.#column)}: a row's cells are in order, each once.`,
+          this.#where(reference)
+        );
+      }
+    }
+    this.#row = r;
+    this.#column = c;
+    this.#owner.countCell(this.sheet, r, c);
+    const at = () => this.#where(formatCell(r, c));
+    const cellType = cellTypeOf(type, at);
+    const styleIndex = style === void 0 ? 0 : int(style, at());
+    if (styleIndex < 0 || styleIndex >= this.#owner.styles.cellFormats.length) {
+      throw new XlsxError("malformed", `The cell names the cell format ${String(styleIndex)}, which the styles do not hold.`, at());
+    }
+    let value = null;
+    let text = null;
+    let formula = null;
+    let rich = false;
+    if (xml.isEmptyElement()) {
+      xml.read();
+    } else {
+      const depth = xml.depth();
+      xml.read();
+      while (!xml.eof() && !(xml.nodeType() === "endElement" && xml.depth() === depth)) {
+        if (xml.nodeType() !== "element") {
+          xml.read();
+          continue;
+        }
+        switch (xml.localName()) {
+          case "v":
+            value = xml.readElementContentAsString();
+            break;
+          case "f":
+            formula = this.#readFormula(metadata, at);
+            break;
+          case "is":
+            [text, rich] = readText(xml);
+            xml.read();
+            break;
+          default:
+            xml.skip();
+            break;
+        }
+      }
+      xml.read();
+    }
+    switch (cellType) {
+      case "sharedString": {
+        const strings = this.#owner.sharedStrings();
+        const index = value === null ? void 0 : parseDigits(value);
+        if (index === void 0 || index >= strings.count) {
+          throw new XlsxError("malformed", `The cell names the shared string '${value === null ? "" : value}', which the workbook does not hold.`, at());
+        }
+        text = elementAt(strings.texts, index);
+        rich = strings.isRich(index);
+        break;
+      }
+      case "inlineString":
+        if (text === null) text = "";
+        break;
+      case "formulaString":
+        if (value !== null) value = decodeXString(value);
+        break;
+      case "number":
+      case "boolean":
+      case "error":
+      case "date":
+        break;
+      default:
+        return unreachableType(cellType);
+    }
+    this.#batch.push(Object.freeze({ row: r, column: c, type: cellType, value, text, formula, styleIndex, isRichText: rich }));
+  }
+  #readFormula(metadata, at) {
+    const xml = this.#opened.xml;
+    let kind;
+    let reference;
+    let shared;
+    for (const attribute of xml.attributes()) {
+      switch (attribute.localName) {
+        case "t":
+          kind = attribute.value;
+          break;
+        case "ref":
+          reference = attribute.value;
+          break;
+        case "si":
+          shared = attribute.value;
+          break;
+        default:
+          break;
+      }
+    }
+    const formulaKind = formulaKindOf(kind, at);
+    const sharedIndex = shared === void 0 ? null : int(shared, at());
+    if (formulaKind === "shared" && sharedIndex === null) throw new XlsxError("malformed", "A shared formula names no group (si).", at());
+    const cm = metadata === void 0 ? void 0 : parseDigits(metadata);
+    const isDynamicArray = formulaKind === "array" && cm !== void 0 && this.#owner.isDynamicArray(cm);
+    const text = decodeXString(xml.readElementContentAsString());
+    return Object.freeze({ text, kind: formulaKind, reference: reference === void 0 ? null : reference, sharedIndex, isDynamicArray });
+  }
+  /** Reads what follows the cells, to the part's end. */
+  #readTail() {
+    const xml = this.#opened.xml;
+    while (!xml.eof()) {
+      if (xml.nodeType() === "element") {
+        if (low(xml)) return "more";
+        this.#other.push(this.#readElement(0));
+      } else {
+        xml.read();
+      }
+    }
+    this.#state = "finished";
+    return "done";
+  }
+};
+function cellTypeOf(type, at) {
+  switch (type) {
+    case void 0:
+    case "n":
+      return "number";
+    case "s":
+      return "sharedString";
+    case "inlineStr":
+      return "inlineString";
+    case "str":
+      return "formulaString";
+    case "b":
+      return "boolean";
+    case "e":
+      return "error";
+    case "d":
+      return "date";
+    default:
+      throw new XlsxError("malformed", `'${type}' is not a cell type.`, at());
+  }
+}
+function formulaKindOf(kind, at) {
+  switch (kind) {
+    case void 0:
+    case "normal":
+      return "normal";
+    case "shared":
+      return "shared";
+    case "array":
+      return "array";
+    case "dataTable":
+      return "dataTable";
+    default:
+      throw new XlsxError("malformed", `'${kind}' is not a kind of Formula.`, at());
+  }
+}
+function unreachableType(type) {
+  throw new Error(`Internal: ${String(type)} is not a cell's type.`);
+}
+
+// src/styles.ts
+var automaticColor = Object.freeze({ kind: "automatic", value: 0, tint: 0 });
+function rgbColor(argb2, tint = 0) {
+  return Object.freeze({ kind: "rgb", value: argb2 >>> 0, tint });
+}
+function themeColor(slot, tint = 0) {
+  return Object.freeze({ kind: "theme", value: slot >>> 0, tint });
+}
+function indexedColor(index, tint = 0) {
+  return Object.freeze({ kind: "indexed", value: index >>> 0, tint });
+}
+var noBorderEdge = Object.freeze({ style: "none", color: null });
+var noBorder = Object.freeze({
+  left: noBorderEdge,
+  right: noBorderEdge,
+  top: noBorderEdge,
+  bottom: noBorderEdge,
+  diagonal: noBorderEdge,
+  diagonalUp: false,
+  diagonalDown: false
+});
+var noFill = Object.freeze({ pattern: "none", foreground: null, background: null, isGradient: false });
+var gray125Fill = Object.freeze({ pattern: "gray125", foreground: null, background: null, isGradient: false });
+function solidFill(color) {
+  return Object.freeze({ pattern: "solid", foreground: color, background: null, isGradient: false });
+}
+var defaultAlignment = Object.freeze({
+  horizontal: "general",
+  vertical: "bottom",
+  wrapText: false,
+  indent: 0,
+  textRotation: 0,
+  shrinkToFit: false
+});
+var FrozenMap = class extends Map {
+  constructor(entries) {
+    super(entries);
+    Object.freeze(this);
+  }
+  set(key, value) {
+    if (Object.isFrozen(this)) throw new TypeError("The default styles cannot be changed.");
+    return super.set(key, value);
+  }
+  delete() {
+    throw new TypeError("The default styles cannot be changed.");
+  }
+  clear() {
+    throw new TypeError("The default styles cannot be changed.");
+  }
+};
+var defaultStyles = Object.freeze({
+  numberFormats: new FrozenMap([]),
+  fonts: Object.freeze([Object.freeze({
+    name: "Calibri",
+    size: 11,
+    bold: false,
+    italic: false,
+    underline: "none",
+    strike: false,
+    color: themeColor(1)
+  })]),
+  fills: Object.freeze([noFill, gray125Fill]),
+  borders: Object.freeze([noBorder]),
+  cellFormats: Object.freeze([Object.freeze({ numberFormatId: 0, fontId: 0, fillId: 0, borderId: 0, alignment: null })]),
+  indexedColors: null
+});
+var firstCustomNumberFormat = 164;
+var borderStyleNames = [
+  "none",
+  "thin",
+  "medium",
+  "dashed",
+  "dotted",
+  "thick",
+  "double",
+  "hair",
+  "mediumDashed",
+  "dashDot",
+  "mediumDashDot",
+  "dashDotDot",
+  "mediumDashDotDot",
+  "slantDashDot"
+];
+var horizontalNames = ["general", "left", "center", "right", "fill", "justify", "centerContinuous", "distributed"];
+var verticalNames = ["bottom", "top", "center", "justify", "distributed"];
+
+// src/styles-reader.ts
+async function readStyles(pkg, part) {
+  const opened = await pkg.readXml(part);
+  if (opened === void 0) return defaultStyles;
+  const numberFormats = /* @__PURE__ */ new Map();
+  const fonts = [];
+  const fills = [];
+  const borders = [];
+  const cellFormats = [];
+  let indexed = null;
+  const xml = opened.xml;
+  try {
+    xml.moveToContent();
+    if (xml.isEmptyElement()) return defaultStyles;
+    const depth = xml.depth();
+    xml.read();
+    while (!xml.eof() && !(xml.nodeType() === "endElement" && xml.depth() === depth)) {
+      if (xml.nodeType() !== "element") {
+        xml.read();
+        continue;
+      }
+      switch (xml.localName()) {
+        case "numFmts":
+          children(xml, "numFmt", () => {
+            const id = xml.getAttribute("numFmtId");
+            const code = xml.getAttribute("formatCode");
+            if (id !== void 0 && code !== void 0) numberFormats.set(int(id, { part }), decodeXString(code));
+          });
+          break;
+        case "fonts":
+          children(xml, "font", () => fonts.push(readFont(xml, part)));
+          break;
+        case "fills":
+          children(xml, "fill", () => fills.push(readFill(xml, part)));
+          break;
+        case "borders":
+          children(xml, "border", () => borders.push(readBorder(xml, part)));
+          break;
+        case "cellXfs":
+          children(xml, "xf", () => cellFormats.push(readCellFormat(xml, part)));
+          break;
+        case "colors":
+          indexed = readIndexedColors(xml, part);
+          break;
+        default:
+          xml.skip();
+          break;
+      }
+    }
+  } catch (error) {
+    if (error instanceof XmlError) throw Package.refuse(error, opened, part);
+    throw error;
+  }
+  if (fonts.length === 0) fonts.push(...defaultStyles.fonts);
+  if (fills.length === 0) fills.push(...defaultStyles.fills);
+  if (borders.length === 0) borders.push(...defaultStyles.borders);
+  if (cellFormats.length === 0) cellFormats.push(...defaultStyles.cellFormats);
+  cellFormats.forEach((f, i) => {
+    const check = (what, id, count2) => {
+      if (id < 0 || id >= count2) {
+        throw new XlsxError("malformed", `The cell format ${String(i)} names the ${what} ${String(id)}, which the styles do not hold.`, { part });
+      }
+    };
+    check("font", f.fontId, fonts.length);
+    check("fill", f.fillId, fills.length);
+    check("border", f.borderId, borders.length);
+    if (f.numberFormatId < 0 || f.numberFormatId >= firstCustomNumberFormat && !numberFormats.has(f.numberFormatId)) {
+      throw new XlsxError(
+        "malformed",
+        `The cell format ${String(i)} names the Number Format ${String(f.numberFormatId)}, which the styles do not hold.`,
+        { part }
+      );
+    }
+  });
+  return Object.freeze({
+    numberFormats,
+    fonts: Object.freeze(fonts),
+    fills: Object.freeze(fills),
+    borders: Object.freeze(borders),
+    cellFormats: Object.freeze(cellFormats),
+    indexedColors: indexed === null ? null : Object.freeze(indexed)
+  });
+}
+function children(xml, name, each) {
+  if (xml.isEmptyElement()) {
+    xml.read();
+    return;
+  }
+  const depth = xml.depth();
+  xml.read();
+  while (!xml.eof() && !(xml.nodeType() === "endElement" && xml.depth() === depth)) {
+    if (xml.nodeType() === "element" && xml.depth() === depth + 1 && xml.localName() === name) {
+      each();
+      xml.skip();
+      continue;
+    }
+    if (xml.nodeType() === "element") xml.skip();
+    else xml.read();
+  }
+  xml.read();
+}
+function subtree(xml, visit) {
+  if (xml.isEmptyElement()) return;
+  const top = xml.depth();
+  while (xml.read() && !(xml.nodeType() === "endElement" && xml.depth() === top)) visit(xml.depth() - top);
+}
+function readFont(xml, part) {
+  let name = null;
+  let size = null;
+  let bold = false;
+  let italic = false;
+  let strike = false;
+  let underline = "none";
+  let color = null;
+  subtree(xml, (depth) => {
+    if (xml.nodeType() !== "element" || depth !== 1) return;
+    const val = xml.getAttribute("val");
+    switch (xml.localName()) {
+      case "name":
+        name = val === void 0 ? null : val;
+        break;
+      case "sz":
+        size = val === void 0 ? null : double(val, part);
+        break;
+      case "b":
+        bold = val === void 0 || bool(val);
+        break;
+      case "i":
+        italic = val === void 0 || bool(val);
+        break;
+      case "strike":
+        strike = val === void 0 || bool(val);
+        break;
+      case "u":
+        underline = underlineOf(val, part);
+        break;
+      case "color":
+        color = readColor(xml, part);
+        break;
+      default:
+        break;
+    }
+  });
+  return Object.freeze({ name, size, bold, italic, underline, strike, color });
+}
+function underlineOf(val, part) {
+  switch (val) {
+    case void 0:
+    case "single":
+      return "single";
+    case "double":
+      return "double";
+    case "singleAccounting":
+      return "singleAccounting";
+    case "doubleAccounting":
+      return "doubleAccounting";
+    case "none":
+      return "none";
+    default:
+      throw new XlsxError("malformed", `'${val}' is not an underline.`, { part });
+  }
+}
+function readFill(xml, part) {
+  if (xml.isEmptyElement()) return noFill;
+  const top = xml.depth();
+  const fill = firstFill(xml, top, part);
+  while (!(xml.nodeType() === "endElement" && xml.depth() === top) && xml.read()) ;
+  return fill;
+}
+function firstFill(xml, top, part) {
+  while (xml.read() && !(xml.nodeType() === "endElement" && xml.depth() === top)) {
+    if (xml.nodeType() !== "element" || xml.depth() !== top + 1) continue;
+    if (xml.localName() === "gradientFill") return Object.freeze({ pattern: null, foreground: null, background: null, isGradient: true });
+    if (xml.localName() !== "patternFill") continue;
+    const patternType = xml.getAttribute("patternType");
+    const pattern = patternType === void 0 ? "none" : patternType;
+    let foreground = null;
+    let background = null;
+    if (!xml.isEmptyElement()) {
+      const at = xml.depth();
+      while (xml.read() && xml.depth() > at) {
+        if (xml.nodeType() !== "element") continue;
+        if (xml.localName() === "fgColor") foreground = readColor(xml, part);
+        else if (xml.localName() === "bgColor") background = readColor(xml, part);
+      }
+    }
+    return Object.freeze({ pattern, foreground, background, isGradient: false });
+  }
+  return noFill;
+}
+function readBorder(xml, part) {
+  const diagonalUp = bool(xml.getAttribute("diagonalUp"));
+  const diagonalDown = bool(xml.getAttribute("diagonalDown"));
+  let left = noBorderEdge;
+  let right = noBorderEdge;
+  let top = noBorderEdge;
+  let bottom = noBorderEdge;
+  let diagonal = noBorderEdge;
+  subtree(xml, (depth) => {
+    if (xml.nodeType() !== "element" || depth !== 1) return;
+    const name = xml.localName();
+    const style = borderStyle(xml.getAttribute("style"), part);
+    let color = null;
+    if (!xml.isEmptyElement()) {
+      const at = xml.depth();
+      while (xml.read() && xml.depth() > at) {
+        if (xml.nodeType() === "element" && xml.localName() === "color") color = readColor(xml, part);
+      }
+    }
+    const edge = style === "none" && color === null ? noBorderEdge : Object.freeze({ style, color });
+    switch (name) {
+      case "left":
+      case "start":
+        left = edge;
+        break;
+      case "right":
+      case "end":
+        right = edge;
+        break;
+      case "top":
+        top = edge;
+        break;
+      case "bottom":
+        bottom = edge;
+        break;
+      case "diagonal":
+        diagonal = edge;
+        break;
+      default:
+        break;
+    }
+  });
+  return Object.freeze({ left, right, top, bottom, diagonal, diagonalUp, diagonalDown });
+}
+function borderStyle(name, part) {
+  if (name === void 0) return "none";
+  const style = borderStyleNames.find((s) => s === name);
+  if (style === void 0) throw new XlsxError("malformed", `'${name}' is not a border style.`, { part });
+  return style;
+}
+function readCellFormat(xml, part) {
+  const id = (attribute) => {
+    const v = xml.getAttribute(attribute);
+    return v === void 0 ? 0 : int(v, { part });
+  };
+  const numberFormatId = id("numFmtId");
+  const fontId = id("fontId");
+  const fillId = id("fillId");
+  const borderId = id("borderId");
+  let alignment = null;
+  subtree(xml, (depth) => {
+    if (xml.nodeType() === "element" && depth === 1 && xml.localName() === "alignment") alignment = readAlignment(xml, part);
+  });
+  return Object.freeze({ numberFormatId, fontId, fillId, borderId, alignment });
+}
+function readAlignment(xml, part) {
+  const hv = xml.getAttribute("horizontal");
+  const vv = xml.getAttribute("vertical");
+  const horizontal = hv === void 0 ? "general" : horizontalNames.find((n) => n === hv);
+  const vertical = vv === void 0 ? "bottom" : verticalNames.find((n) => n === vv);
+  if (horizontal === void 0 || vertical === void 0) throw new XlsxError("malformed", "A cell format names an alignment that is not one.", { part });
+  const indent = xml.getAttribute("indent");
+  const rotation = xml.getAttribute("textRotation");
+  return Object.freeze({
+    horizontal,
+    vertical,
+    wrapText: bool(xml.getAttribute("wrapText")),
+    indent: indent === void 0 ? 0 : int(indent, { part }),
+    textRotation: rotation === void 0 ? 0 : int(rotation, { part }),
+    shrinkToFit: bool(xml.getAttribute("shrinkToFit"))
+  });
+}
+function readIndexedColors(xml, part) {
+  let colors = null;
+  subtree(xml, () => {
+    if (xml.nodeType() !== "element") return;
+    if (xml.localName() === "indexedColors") {
+      colors = [];
+      return;
+    }
+    const rgb = xml.getAttribute("rgb");
+    if (xml.localName() === "rgbColor" && colors !== null && rgb !== void 0) colors.push(argb(rgb, part));
+  });
+  return colors;
+}
+function readColor(xml, part) {
+  const t = xml.getAttribute("tint");
+  const tint = t === void 0 ? 0 : double(t, part);
+  if (bool(xml.getAttribute("auto"))) return Object.freeze({ kind: "automatic", value: 0, tint });
+  const rgb = xml.getAttribute("rgb");
+  if (rgb !== void 0) return Object.freeze({ kind: "rgb", value: argb(rgb, part), tint });
+  const theme = xml.getAttribute("theme");
+  if (theme !== void 0) return Object.freeze({ kind: "theme", value: int(theme, { part }) >>> 0, tint });
+  const indexed = xml.getAttribute("indexed");
+  if (indexed !== void 0) return Object.freeze({ kind: "indexed", value: int(indexed, { part }) >>> 0, tint });
+  return Object.freeze({ kind: "automatic", value: 0, tint });
+}
+function argb(text, part) {
+  const value = parseHex32(text);
+  if (value === void 0 || text.length !== 6 && text.length !== 8) throw new XlsxError("malformed", `'${text}' is not an RGB colour.`, { part });
+  return text.length === 6 ? (4278190080 | value) >>> 0 : value;
+}
+
+// src/theme.ts
+var defaultIndexedColors = Object.freeze([
+  4278190080,
+  4294967295,
+  4294901760,
+  4278255360,
+  4278190335,
+  4294967040,
+  4294902015,
+  4278255615,
+  4278190080,
+  4294967295,
+  4294901760,
+  4278255360,
+  4278190335,
+  4294967040,
+  4294902015,
+  4278255615,
+  4286578688,
+  4278222848,
+  4278190208,
+  4286611456,
+  4286578816,
+  4278222976,
+  4290822336,
+  4286611584,
+  4288256511,
+  4288230246,
+  4294967244,
+  4291624959,
+  4284874854,
+  4294934656,
+  4278216396,
+  4291611903,
+  4278190208,
+  4294902015,
+  4294967040,
+  4278255615,
+  4286578816,
+  4286578688,
+  4278222976,
+  4278190335,
+  4278242559,
+  4291624959,
+  4291624908,
+  4294967193,
+  4288269567,
+  4294941132,
+  4291598847,
+  4294954137,
+  4281558783,
+  4281584844,
+  4288269312,
+  4294953984,
+  4294940928,
+  4294927872,
+  4284901017,
+  4288059030,
+  4278203238,
+  4281571686,
+  4278203136,
+  4281545472,
+  4288230144,
+  4288230246,
+  4281545625,
+  4281545523
+]);
+var XlsxTheme = class _XlsxTheme {
+  /**
+   * The theme of Office 2013–2022, which a workbook with no theme part takes: dark 1 `000000`, light 1 `FFFFFF`,
+   * `44546A`, `E7E6E6`, the accents `4472C4`, `ED7D31`, `A5A5A5`, `FFC000`, `5B9BD5`, `70AD47`, and the hyperlinks
+   * `0563C1` and `954F72`.
+   */
+  static office = new _XlsxTheme([
+    4278190080,
+    4294967295,
+    4282668138,
+    4293388006,
+    4282675908,
+    4293754161,
+    4289045925,
+    4294950912,
+    4284193749,
+    4285574471,
+    4278543297,
+    4287975282
+  ]);
+  /** The scheme's twelve colours as ARGB values, in the scheme's order: dark 1, light 1, dark 2, light 2, accents 1 to 6,
+   * hyperlink, followed hyperlink. */
+  schemeColors;
+  /** A theme of the twelve colours its scheme lists, as ARGB values in the scheme's own order. */
+  constructor(schemeColors) {
+    if (schemeColors.length !== 12) {
+      throw new TypeError("A theme's colour scheme has twelve colours: dark 1, light 1, dark 2, light 2, six accents and two hyperlinks.");
+    }
+    this.schemeColors = Object.freeze(schemeColors.map((c) => c >>> 0));
+  }
+  /**
+   * The colour a style's theme slot names. A style numbers the first four slots in another order than the scheme lists
+   * them — 0 is light 1 (Background 1), 1 dark 1 (Text 1), 2 light 2, 3 dark 2 — and the rest as listed.
+   */
+  slotColor(slot) {
+    switch (slot) {
+      case 0:
+        return elementAt(this.schemeColors, 1);
+      case 1:
+        return elementAt(this.schemeColors, 0);
+      case 2:
+        return elementAt(this.schemeColors, 3);
+      case 3:
+        return elementAt(this.schemeColors, 2);
+      default:
+        if (Number.isInteger(slot) && slot >= 4 && slot < 12) return elementAt(this.schemeColors, slot);
+        throw new RangeError(`A theme has twelve slots, 0 to 11, not ${String(slot)}.`);
+    }
+  }
+  /**
+   * The RGB value, as `0xFFRRGGBB`, that `color` paints, or `undefined` for the automatic colour (and the indexed entries
+   * 64 and 65, which name the window's text and background), whose meaning the place it colours decides.
+   * @param indexedColors - The styles part's own indexed palette, or none for the default one.
+   */
+  resolve(color, indexedColors) {
+    let argb2;
+    switch (color.kind) {
+      case "rgb":
+        argb2 = color.value;
+        break;
+      case "theme":
+        argb2 = color.value < 12 ? this.slotColor(color.value) : void 0;
+        break;
+      case "indexed": {
+        const palette = indexedColors ?? defaultIndexedColors;
+        argb2 = color.value < palette.length ? elementAt(palette, color.value) : void 0;
+        break;
+      }
+      case "automatic":
+        argb2 = void 0;
+        break;
+      default:
+        return unreachableKind(color.kind);
+    }
+    return argb2 !== void 0 && color.tint !== 0 ? applyTint(argb2, color.tint) : argb2;
+  }
+};
+function unreachableKind(kind) {
+  throw new Error(`Internal: ${String(kind)} is not a colour's kind.`);
+}
+function applyTint(argb2, tint) {
+  const t = Math.min(Math.max(tint, -1), 1);
+  const r = (argb2 >>> 16 & 255) / 255;
+  const g = (argb2 >>> 8 & 255) / 255;
+  const b = (argb2 & 255) / 255;
+  const max = Math.max(r, Math.max(g, b));
+  const min = Math.min(r, Math.min(g, b));
+  let l = (max + min) / 2;
+  let h = 0;
+  let s = 0;
+  if (max !== min) {
+    const d = max - min;
+    s = l <= 0.5 ? d / (max + min) : d / (2 - max - min);
+    h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
+    h /= 6;
+  }
+  l = t < 0 ? l * (1 + t) : l * (1 - t) + t;
+  let r2;
+  let g2;
+  let b2;
+  if (s === 0) {
+    r2 = g2 = b2 = l;
+  } else {
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r2 = hue(p, q, h + 1 / 3);
+    g2 = hue(p, q, h);
+    b2 = hue(p, q, h - 1 / 3);
+  }
+  return (argb2 & 4278190080 | channel(r2) << 16 | channel(g2) << 8 | channel(b2)) >>> 0;
+}
+function hue(p, q, given) {
+  let t = given;
+  if (t < 0) t += 1;
+  if (t > 1) t -= 1;
+  if (t < 1 / 6) return p + (q - p) * 6 * t;
+  if (t < 0.5) return q;
+  if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+  return p;
+}
+function channel(v) {
+  const x = v * 255;
+  const whole2 = Math.trunc(x);
+  const rounded = Math.abs(x - whole2) >= 0.5 ? whole2 + Math.sign(x) : whole2;
+  return Math.min(Math.max(rounded, 0), 255);
+}
+
+// src/reader.ts
+var sharedStringSlice = 256;
+var WorkbookReader = class _WorkbookReader {
+  #package;
+  #pacer;
+  #maxCells;
+  #dynamicArrayMetadata;
+  #owner;
+  #cells = 0;
+  #sheetBytesRead = 0;
+  #sharedStrings = XlsxSharedStrings.empty;
+  #sheetOpen = false;
+  /** The workbook part's name, as `xl/workbook.xml`. */
+  workbookPart;
+  /** The workbook's sheets, in its order: the order of its tabs. */
+  sheets;
+  /** The index into `sheets` of the sheet the workbook shows (`activeTab`), 0 when it names none. */
+  activeSheet;
+  /** Whether the workbook counts dates from 1904 (`date1904`), whose serials are 1,462 less than 1900's for the same day. */
+  date1904;
+  /** The workbook's defined names. */
+  definedNames;
+  /** The styles, as far as ADR-0330 §4 carries them; `defaultStyles` when the package has no styles part. */
+  styles;
+  /** The theme's colours; `XlsxTheme.office` when the package has no theme part (`hasTheme`). */
+  theme;
+  /** Whether the package has a theme part of its own. */
+  hasTheme;
+  /** The worksheets' uncompressed bytes, as the zip declares them. */
+  sheetBytes;
+  constructor(pkg, options, read) {
+    this.#package = pkg;
+    this.#pacer = new Pacer(options);
+    this.#maxCells = options.maxCells === void 0 ? defaultMaxCells : options.maxCells;
+    this.workbookPart = read.part;
+    this.sheets = read.sheets;
+    this.activeSheet = read.active;
+    this.date1904 = read.date1904;
+    this.definedNames = read.names;
+    this.styles = read.styles;
+    this.theme = read.theme;
+    this.hasTheme = read.hasTheme;
+    this.#dynamicArrayMetadata = read.dynamicArrayMetadata;
+    this.sheetBytes = read.sheets.reduce((sum, s) => s.part === null ? sum : sum + pkg.lengthOf(s.part), 0);
+    const progress = (sheet) => ({
+      sheet,
+      sheets: this.sheets.length,
+      cells: this.#cells,
+      bytes: this.#sheetBytesRead,
+      totalBytes: this.sheetBytes
+    });
+    this.#owner = {
+      styles: this.styles,
+      sharedStrings: () => this.#sharedStrings,
+      isDynamicArray: (cm) => this.#dynamicArrayMetadata.has(cm),
+      countCell: (sheet, row, column) => {
+        if (++this.#cells > this.#maxCells) {
+          throw new XlsxError(
+            "tooManyCells",
+            `The workbook holds more than the ${grouped(this.#maxCells)} cells a read is allowed (XlsxReadOptions.MaxCells).`,
+            { part: sheet.part === null ? void 0 : sheet.part, sheet: sheet.name, cell: formatCell(row, column) }
+          );
+        }
+      },
+      cells: () => this.#cells,
+      rewindCells: (to) => {
+        this.#cells = to;
+      },
+      countBytes: (bytes) => {
+        this.#sheetBytesRead += bytes;
+      },
+      checkpoint: (sheet) => this.#pacer.checkpoint(() => progress(sheet)),
+      report: (sheet) => this.#pacer.report(progress(sheet)),
+      closed: () => {
+        this.#sheetOpen = false;
+      }
+    };
+  }
+  /** Opens the workbook in `file`. */
+  static async open(file, options = {}) {
+    options.signal?.throwIfAborted();
+    const max = options.maxUncompressedBytes === void 0 ? defaultMaxUncompressedBytes : options.maxUncompressedBytes;
+    const source = byteSource(file);
+    const head = await source.read(0, 8);
+    if (isOle(head)) throw await classifyOle(source);
+    if (!isZip(head)) throw new XlsxError("notAZip", head.length === 0 ? "The file is empty." : "The file is not a zip package, so it is not an .xlsx.");
+    const pkg = await Package.open(source, max);
+    const read = await readWorkbookParts(pkg);
+    const reader = new _WorkbookReader(pkg, options, read);
+    if (read.sharedStringsPart !== void 0) await reader.#readSharedStrings(read.sharedStringsPart);
+    return reader;
+  }
+  /** The shared strings, held whole. */
+  get sharedStrings() {
+    return this.#sharedStrings;
+  }
+  /** Every part the package holds, by name, as `xl/comments1.xml`: what else it holds than what is read. */
+  get parts() {
+    return this.#package.partNames;
+  }
+  /** The cells read so far, every worksheet counted. */
+  get cellsRead() {
+    return this.#cells;
+  }
+  /**
+   * Opens the worksheet at `index` for reading its cells as a stream. One worksheet is read at a time: close the reader
+   * before opening the next.
+   */
+  async openSheet(index) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.sheets.length) {
+      throw new RangeError(`The workbook has ${String(this.sheets.length)} sheets; ${String(index)} is not the index of one.`);
+    }
+    const sheet = elementAt(this.sheets, index);
+    if (sheet.part === null) throw new Error(`The sheet '${sheet.name}' is not a worksheet and holds no cells.`);
+    if (this.#sheetOpen) throw new Error("Another worksheet is being read: close its reader first.");
+    const opened = await this.#package.openXml(sheet.part, sheet.name);
+    if (opened === void 0) {
+      throw new XlsxError("malformed", "The workbook names a worksheet part the package does not hold.", { part: sheet.part, sheet: sheet.name });
+    }
+    this.#sheetOpen = true;
+    return new SheetReader(this.#owner, index, sheet, sheet.part, opened);
+  }
+  /**
+   * Reads the worksheet at `index` whole: its columns, its cells and what else it holds. For a sheet that is small, or a
+   * test; a large one is read a batch at a time through `openSheet`.
+   */
+  async readSheet(index) {
+    const reader = await this.openSheet(index);
+    try {
+      const cells = [];
+      const rows = [];
+      while (await reader.read()) {
+        cells.push(...reader.cells);
+        rows.push(...reader.rows);
+      }
+      return Object.freeze({
+        sheet: reader.sheet,
+        columns: reader.columns,
+        cells: Object.freeze(cells),
+        otherElements: reader.otherElements,
+        rows: Object.freeze(rows),
+        customRowHeights: reader.customRowHeights,
+        hiddenRows: reader.hiddenRows,
+        frozenPanes: reader.frozenPanes
+      });
+    } finally {
+      await reader.close();
+    }
+  }
+  /**
+   * Reads the shared strings, the one part held whole, in slices as a worksheet is read (ADR-0330 §9): cancellation is
+   * looked at, progress reported and the read yields between them. Its progress names no worksheet (`sheet` is -1) and
+   * counts the part's bytes.
+   */
+  async #readSharedStrings(part) {
+    const opened = await this.#package.openXml(part);
+    if (opened === void 0) return;
+    const { xml, bytes } = opened;
+    const total = this.#package.lengthOf(part);
+    const progress = () => ({ sheet: -1, sheets: this.sheets.length, cells: 0, bytes: bytes.bytesRead, totalBytes: total });
+    const texts = [];
+    const rich = [];
+    let started = false;
+    const step = () => {
+      if (!started) {
+        xml.moveToContent();
+        started = true;
+      }
+      let slice = 0;
+      for (; ; ) {
+        if (low(xml)) return "more";
+        if (!xml.read()) return "done";
+        if (xml.nodeType() === "element" && xml.localName() === "si") {
+          const [text, isRich] = readText(xml);
+          if (isRich) rich.push(texts.length);
+          texts.push(text);
+          if (++slice === sharedStringSlice) return "pause";
+        }
+      }
+    };
+    const save = () => {
+      const count2 = texts.length;
+      const richCount = rich.length;
+      const wasStarted = started;
+      return () => {
+        texts.length = count2;
+        rich.length = richCount;
+        started = wasStarted;
+      };
+    };
+    try {
+      while (await runSteps(xml, save, step) === "pause") await this.#pacer.checkpoint(progress);
+    } catch (error) {
+      if (error instanceof XmlError) throw Package.refuse(error, opened, part);
+      throw error;
+    } finally {
+      await bytes.close();
+    }
+    this.#pacer.report(progress());
+    this.#sharedStrings = new XlsxSharedStrings(texts, new Set(rich));
+  }
+};
+function openXlsx(file, options) {
+  return WorkbookReader.open(file, options);
+}
+async function readWorkbookParts(pkg) {
+  const part = await workbookPartOf(pkg);
+  const rels = await relationships(pkg, part);
+  const { sheets, active, date1904, names } = await readWorkbook(pkg, part, rels);
+  const target = (type) => {
+    for (const r of rels.values()) if (r.type === type) return r.target;
+    return void 0;
+  };
+  const stylesPart = target(stylesType);
+  const themePart = target(themeType);
+  const metadataPart = target(sheetMetadataType);
+  return {
+    part,
+    sheets,
+    active,
+    date1904,
+    names,
+    styles: stylesPart === void 0 ? defaultStyles : await readStyles(pkg, stylesPart),
+    theme: themePart === void 0 ? XlsxTheme.office : await readTheme(pkg, themePart),
+    hasTheme: themePart !== void 0,
+    dynamicArrayMetadata: metadataPart === void 0 ? /* @__PURE__ */ new Set() : await readDynamicArrayMetadata(pkg, metadataPart),
+    sharedStringsPart: target(sharedStringsType)
+  };
+}
+function strict() {
+  return new XlsxError("strictOpenXml", "The workbook is saved as Strict Open XML, which is not read. Save it from Excel as an Excel Workbook (.xlsx).");
+}
+function extensionOf(name) {
+  const dot = name.lastIndexOf(".");
+  return dot < 0 || dot < name.lastIndexOf("/") ? "" : name.slice(dot + 1);
+}
+async function workbookPartOf(pkg) {
+  const { defaults, overrides } = await readContentTypes(pkg);
+  const root = await relationships(pkg, "");
+  let office;
+  for (const r of root.values()) {
+    if (r.type.endsWith("/officeDocument")) {
+      office = r;
+      break;
+    }
+  }
+  if (office === void 0) {
+    if ([...root.values()].some((r) => r.type.startsWith(strictPrefix))) throw strict();
+    throw new XlsxError("notAWorkbook", "The zip package holds no document, so it is not an .xlsx.");
+  }
+  if (office.type.startsWith(strictPrefix)) throw strict();
+  const part = office.target;
+  const contentType = overrides.get(foldCase(part)) ?? defaults.get(foldCase(extensionOf(part))) ?? "";
+  if (contentType === binaryContent || foldCase(part).endsWith(".bin")) {
+    throw new XlsxError("binary", "The file is an Excel Binary Workbook (.xlsb), not an .xlsx. Save it from Excel as an Excel Workbook (.xlsx).", { part });
+  }
+  if (foldCase(contentType).includes(foldCase("macroEnabled")) || [...overrides.values(), ...defaults.values()].includes(vbaProjectContent)) {
+    throw new XlsxError(
+      "macroEnabled",
+      "The file is a workbook with macros (.xlsm), which is not read. Save it from Excel as an Excel Workbook (.xlsx), which leaves the macros out.",
+      { part }
+    );
+  }
+  if (contentType !== workbookContent && contentType !== templateContent) {
+    throw new XlsxError("notAWorkbook", contentType === "" ? "The package's document has no content type, so it is not an .xlsx." : `The package's document is '${contentType}', not a workbook: the file is not an .xlsx.`, { part });
+  }
+  if (!pkg.has(part)) throw new XlsxError("malformed", "The package names a workbook part it does not hold.", { part });
+  return part;
+}
+async function readContentTypes(pkg) {
+  const part = "[Content_Types].xml";
+  const defaults = /* @__PURE__ */ new Map();
+  const overrides = /* @__PURE__ */ new Map();
+  const opened = await pkg.readXml(part);
+  if (opened === void 0) throw new XlsxError("notAWorkbook", "The zip package has no [Content_Types].xml, so it is not an Office document.");
+  const xml = opened.xml;
+  try {
+    while (xml.read()) {
+      if (xml.nodeType() !== "element") continue;
+      if (xml.localName() === "Default") {
+        const ext = xml.getAttribute("Extension");
+        const type = xml.getAttribute("ContentType");
+        if (ext !== void 0 && type !== void 0) defaults.set(foldCase(ext), type);
+      } else if (xml.localName() === "Override") {
+        const name = xml.getAttribute("PartName");
+        const type = xml.getAttribute("ContentType");
+        if (name !== void 0 && type !== void 0) overrides.set(foldCase(name.replace(/^\/+/, "")), type);
+      }
+    }
+  } catch (error) {
+    if (error instanceof XmlError) throw Package.refuse(error, opened, part);
+    throw error;
+  }
+  return { defaults, overrides };
+}
+async function relationships(pkg, source) {
+  const slash = source.lastIndexOf("/");
+  const dir = slash < 0 ? "" : source.slice(0, slash);
+  const part = `${dir === "" ? "" : `${dir}/`}_rels/${source.slice(slash + 1)}.rels`;
+  const found = /* @__PURE__ */ new Map();
+  const opened = await pkg.readXml(part);
+  if (opened === void 0) return found;
+  const xml = opened.xml;
+  try {
+    while (xml.read()) {
+      if (xml.nodeType() !== "element" || xml.localName() !== "Relationship") continue;
+      const id = xml.getAttribute("Id");
+      const type = xml.getAttribute("Type");
+      const target = xml.getAttribute("Target");
+      if (id === void 0 || type === void 0 || target === void 0 || xml.getAttribute("TargetMode") === "External") continue;
+      found.set(id, { type, target: resolve(dir, target) });
+    }
+  } catch (error) {
+    if (error instanceof XmlError) throw Package.refuse(error, opened, part);
+    throw error;
+  }
+  return found;
+}
+function unescapeData(text) {
+  return text.replace(/(?:%[0-9A-Fa-f]{2})+/g, (run) => {
+    const bytes = Uint8Array.from(run.match(/%[0-9A-Fa-f]{2}/g) ?? [], (h) => Number.parseInt(h.slice(1), 16));
+    let out = "";
+    let at = 0;
+    while (at < bytes.length) {
+      const length = utf8Length(bytes, at);
+      if (length === 0) {
+        out += run.slice(at * 3, at * 3 + 3);
+        at++;
+      } else {
+        out += new TextDecoder().decode(bytes.subarray(at, at + length));
+        at += length;
+      }
+    }
+    return out;
+  });
+}
+function utf8Length(bytes, at) {
+  const b = elementAt(bytes, at);
+  const length = b < 128 ? 1 : b >= 194 && b < 224 ? 2 : b >= 224 && b < 240 ? 3 : b >= 240 && b < 245 ? 4 : 0;
+  if (length === 0 || at + length > bytes.length) return 0;
+  for (let i = 1; i < length; i++) {
+    if ((elementAt(bytes, at + i) & 192) !== 128) return 0;
+  }
+  const second = length > 1 ? elementAt(bytes, at + 1) : 0;
+  if (b === 224 && second < 160 || b === 237 && second >= 160 || b === 240 && second < 144 || b === 244 && second >= 144) return 0;
+  return length;
+}
+function resolve(dir, given) {
+  const target = unescapeData(given.replaceAll("\\", "/"));
+  const path = target.startsWith("/") ? target.replace(/^\/+/, "") : dir === "" ? target : `${dir}/${target}`;
+  const parts = [];
+  for (const segment of path.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      parts.pop();
+      continue;
+    }
+    parts.push(segment);
+  }
+  return parts.join("/");
+}
+async function readWorkbook(pkg, part, rels) {
+  const sheets = [];
+  const names = [];
+  let active = 0;
+  let date1904 = false;
+  const opened = await pkg.readXml(part);
+  if (opened === void 0) throw new Error(`Internal: the package was checked to hold '${part}'.`);
+  const xml = opened.xml;
+  try {
+    xml.moveToContent();
+    if (xml.namespaceUri().startsWith(strictPrefix)) throw strict();
+    if (xml.localName() !== "workbook") throw new XlsxError("malformed", `The workbook part's root is <${xml.localName()}>, not <workbook>.`, { part });
+    let more = xml.read();
+    while (more) {
+      if (xml.nodeType() !== "element") {
+        more = xml.read();
+        continue;
+      }
+      let advanced = false;
+      switch (xml.localName()) {
+        case "workbookPr":
+          date1904 = bool(xml.getAttribute("date1904"));
+          break;
+        case "workbookView": {
+          const tab = xml.getAttribute("activeTab");
+          if (tab !== void 0) active = int(tab, { part });
+          break;
+        }
+        case "sheet": {
+          const name = xml.getAttribute("name");
+          if (name === void 0) throw new XlsxError("malformed", "A sheet has no name.", { part });
+          const id = xml.getAttributeNs("id", relationshipsNamespace);
+          const state = xml.getAttribute("state");
+          const visibility = state === "hidden" ? "hidden" : state === "veryHidden" ? "veryHidden" : "visible";
+          const sid = xml.getAttribute("sheetId");
+          const sheetId = sid === void 0 ? sheets.length + 1 : int(sid, { part });
+          const rel = id === void 0 ? void 0 : rels.get(id);
+          sheets.push(Object.freeze(rel !== void 0 && rel.type === worksheetType ? { name, sheetId, visibility, part: rel.target, kind: "worksheet" } : { name, sheetId, visibility, part: null, kind: "other" }));
+          break;
+        }
+        case "definedName": {
+          const given = xml.getAttribute("name");
+          const name = given === void 0 ? "" : given;
+          const l = xml.getAttribute("localSheetId");
+          const localSheet = l === void 0 ? null : int(l, { part });
+          const hidden = bool(xml.getAttribute("hidden"));
+          names.push(Object.freeze({ name, text: decodeXString(xml.readElementContentAsString()), localSheet, hidden }));
+          advanced = true;
+          break;
+        }
+        default:
+          break;
+      }
+      more = advanced ? !xml.eof() : xml.read();
+    }
+  } catch (error) {
+    if (error instanceof XmlError) throw Package.refuse(error, opened, part);
+    throw error;
+  }
+  if (sheets.length === 0) throw new XlsxError("malformed", "The workbook lists no sheets.", { part });
+  if (active < 0 || active >= sheets.length) active = 0;
+  return { sheets: Object.freeze(sheets), active, date1904, names: Object.freeze(names) };
+}
+var schemeOrder = ["dk1", "lt1", "dk2", "lt2", "accent1", "accent2", "accent3", "accent4", "accent5", "accent6", "hlink", "folHlink"];
+async function readTheme(pkg, part) {
+  const colors = [...XlsxTheme.office.schemeColors];
+  const opened = await pkg.readXml(part);
+  if (opened === void 0) return XlsxTheme.office;
+  const xml = opened.xml;
+  try {
+    if (!xml.readToFollowing("clrScheme", drawingNamespace)) return XlsxTheme.office;
+    const depth = xml.depth();
+    let slot = -1;
+    while (xml.read() && xml.depth() > depth) {
+      if (xml.nodeType() !== "element") continue;
+      if (xml.depth() === depth + 1) {
+        slot = schemeOrder.indexOf(xml.localName());
+        continue;
+      }
+      if (slot < 0) continue;
+      const value = xml.localName() === "srgbClr" ? xml.getAttribute("val") : xml.localName() === "sysClr" ? xml.getAttribute("lastClr") : void 0;
+      const rgb = value === void 0 ? void 0 : parseHex32(value);
+      if (rgb !== void 0) colors[slot] = (4278190080 | rgb & 16777215) >>> 0;
+    }
+  } catch (error) {
+    if (error instanceof XmlError) throw Package.refuse(error, opened, part);
+    throw error;
+  }
+  return new XlsxTheme(colors);
+}
+async function readDynamicArrayMetadata(pkg, part) {
+  const dynamic = /* @__PURE__ */ new Set();
+  const opened = await pkg.readXml(part);
+  if (opened === void 0) return dynamic;
+  const xml = opened.xml;
+  const types = [];
+  const futures = /* @__PURE__ */ new Map();
+  const cellBlocks = [];
+  try {
+    let future = null;
+    let inCellMetadata = false;
+    let pendingRecord = false;
+    while (xml.read()) {
+      if (xml.nodeType() === "endElement") {
+        if (xml.localName() === "futureMetadata") future = null;
+        else if (xml.localName() === "cellMetadata") inCellMetadata = false;
+        continue;
+      }
+      if (xml.nodeType() !== "element") continue;
+      const name = xml.localName();
+      if (name === "metadataType") {
+        const typeName = xml.getAttribute("name");
+        types.push(typeName === void 0 ? "" : typeName);
+      } else if (name === "futureMetadata") {
+        const futureName = xml.getAttribute("name");
+        const blocks2 = [];
+        futures.set(futureName === void 0 ? "" : futureName, blocks2);
+        future = xml.isEmptyElement() ? null : blocks2;
+      } else if (name === "bk" && future !== null) {
+        future.push(false);
+      } else if (name === "dynamicArrayProperties" && future !== null && future.length > 0) {
+        future[future.length - 1] = bool(xml.getAttribute("fDynamic"));
+      } else if (name === "cellMetadata") {
+        inCellMetadata = !xml.isEmptyElement();
+      } else if (name === "bk" && inCellMetadata) {
+        pendingRecord = true;
+        cellBlocks.push([-1, -1]);
+      } else if (name === "rc" && inCellMetadata && pendingRecord) {
+        pendingRecord = false;
+        const t = xml.getAttribute("t");
+        const v = xml.getAttribute("v");
+        cellBlocks[cellBlocks.length - 1] = [int(t === void 0 ? "0" : t, { part }), int(v === void 0 ? "0" : v, { part })];
+      }
+    }
+  } catch (error) {
+    if (error instanceof XmlError) throw Package.refuse(error, opened, part);
+    throw error;
+  }
+  const blocks = futures.get("XLDAPR");
+  cellBlocks.forEach(([type, value], i) => {
+    if (type < 1 || type > types.length || types[type - 1] !== "XLDAPR") return;
+    if (blocks !== void 0 && value >= 0 && value < blocks.length && blocks[value] === true) dynamic.add(i + 1);
+  });
+  return dynamic;
+}
+
+// src/styles-writer.ts
+function writeStyles(w, styles) {
+  w.start("styleSheet", mainNamespace);
+  if (styles.numberFormats.size > 0) {
+    w.start("numFmts");
+    count(w, styles.numberFormats.size);
+    for (const [id, code] of [...styles.numberFormats].toSorted(([a], [b]) => a - b)) {
+      w.start("numFmt");
+      w.attribute("numFmtId", String(id));
+      w.attribute("formatCode", encodeXString(code));
+      w.end();
+    }
+    w.end();
+  }
+  w.start("fonts");
+  count(w, styles.fonts.length);
+  for (const font of styles.fonts) writeFont(w, font);
+  w.end();
+  w.start("fills");
+  count(w, styles.fills.length);
+  for (const fill of styles.fills) writeFill(w, fill);
+  w.end();
+  w.start("borders");
+  count(w, styles.borders.length);
+  for (const border of styles.borders) writeBorder(w, border);
+  w.end();
+  w.start("cellStyleXfs");
+  count(w, 1);
+  w.start("xf");
+  w.attribute("numFmtId", "0");
+  w.attribute("fontId", "0");
+  w.attribute("fillId", "0");
+  w.attribute("borderId", "0");
+  w.end();
+  w.end();
+  w.start("cellXfs");
+  count(w, styles.cellFormats.length);
+  for (const format of styles.cellFormats) writeCellFormat(w, format);
+  w.end();
+  w.start("cellStyles");
+  count(w, 1);
+  w.start("cellStyle");
+  w.attribute("name", "Normal");
+  w.attribute("xfId", "0");
+  w.attribute("builtinId", "0");
+  w.end();
+  w.end();
+  const indexed = styles.indexedColors;
+  if (indexed !== null && indexed.length > 0) {
+    w.start("colors");
+    w.start("indexedColors");
+    for (const argb2 of indexed) {
+      w.start("rgbColor");
+      w.attribute("rgb", hex8(argb2));
+      w.end();
+    }
+    w.end();
+    w.end();
+  }
+  w.end();
+}
+function count(w, n) {
+  w.attribute("count", String(n));
+}
+function writeFont(w, font) {
+  w.start("font");
+  if (font.bold) w.element("b", null);
+  if (font.italic) w.element("i", null);
+  if (font.strike) w.element("strike", null);
+  if (font.underline !== "none") {
+    w.start("u");
+    if (font.underline !== "single") w.attribute("val", font.underline);
+    w.end();
+  }
+  if (font.size !== null) {
+    w.start("sz");
+    w.attribute("val", roundTrip(font.size));
+    w.end();
+  }
+  if (font.color !== null) writeColor(w, "color", font.color);
+  if (font.name !== null) {
+    w.start("name");
+    w.attribute("val", font.name);
+    w.end();
+  }
+  w.end();
+}
+function writeFill(w, fill) {
+  w.start("fill");
+  if (fill.isGradient) {
+    w.start("gradientFill");
+    w.end();
+  } else {
+    w.start("patternFill");
+    w.attribute("patternType", fill.pattern === null ? "none" : fill.pattern);
+    if (fill.foreground !== null) writeColor(w, "fgColor", fill.foreground);
+    if (fill.background !== null) writeColor(w, "bgColor", fill.background);
+    w.end();
+  }
+  w.end();
+}
+function writeBorder(w, border) {
+  w.start("border");
+  if (border.diagonalUp) w.attribute("diagonalUp", "1");
+  if (border.diagonalDown) w.attribute("diagonalDown", "1");
+  writeEdge(w, "left", border.left);
+  writeEdge(w, "right", border.right);
+  writeEdge(w, "top", border.top);
+  writeEdge(w, "bottom", border.bottom);
+  writeEdge(w, "diagonal", border.diagonal);
+  w.end();
+}
+function writeEdge(w, name, edge) {
+  w.start(name);
+  if (edge.style !== "none") w.attribute("style", edge.style);
+  if (edge.color !== null) writeColor(w, "color", edge.color);
+  w.end();
+}
+function writeCellFormat(w, format) {
+  w.start("xf");
+  w.attribute("numFmtId", String(format.numberFormatId));
+  w.attribute("fontId", String(format.fontId));
+  w.attribute("fillId", String(format.fillId));
+  w.attribute("borderId", String(format.borderId));
+  w.attribute("xfId", "0");
+  if (format.numberFormatId !== 0) w.attribute("applyNumberFormat", "1");
+  if (format.fontId !== 0) w.attribute("applyFont", "1");
+  if (format.fillId !== 0) w.attribute("applyFill", "1");
+  if (format.borderId !== 0) w.attribute("applyBorder", "1");
+  const a = format.alignment;
+  if (a !== null) {
+    w.attribute("applyAlignment", "1");
+    w.start("alignment");
+    if (a.horizontal !== "general") w.attribute("horizontal", a.horizontal);
+    if (a.vertical !== "bottom") w.attribute("vertical", a.vertical);
+    if (a.textRotation !== 0) w.attribute("textRotation", String(a.textRotation));
+    if (a.wrapText) w.attribute("wrapText", "1");
+    if (a.indent !== 0) w.attribute("indent", String(a.indent));
+    if (a.shrinkToFit) w.attribute("shrinkToFit", "1");
+    w.end();
+  }
+  w.end();
+}
+function writeColor(w, name, color) {
+  w.start(name);
+  switch (color.kind) {
+    case "automatic":
+      w.attribute("auto", "1");
+      break;
+    case "rgb":
+      w.attribute("rgb", hex8(color.value));
+      break;
+    case "theme":
+      w.attribute("theme", String(color.value));
+      break;
+    case "indexed":
+      w.attribute("indexed", String(color.value));
+      break;
+    default:
+      unreachable(color.kind);
+  }
+  if (color.tint !== 0) w.attribute("tint", roundTrip(color.tint));
+  w.end();
+}
+
+// src/xml-writer.ts
+var declaration = '<?xml version="1.0" encoding="utf-8" standalone="yes"?>';
+function escapeText(text) {
+  return text.replace(/[&<>]|\r\n?/g, (c) => {
+    switch (c) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      default:
+        return "\n";
+    }
+  });
+}
+function escapeAttribute(text) {
+  return text.replace(/[&<>"\t\n\r]/g, (c) => {
+    switch (c) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      case "	":
+        return "&#x9;";
+      case "\n":
+        return "&#xA;";
+      default:
+        return "&#xD;";
+    }
+  });
+}
+var XmlTextWriter = class {
+  #text = "";
+  #names = [];
+  /** Whether the last element's start tag is not closed yet: its attributes may still come. */
+  #open = false;
+  /** The default namespace the open start tag declares after its attributes, or `undefined`. */
+  #namespace;
+  /** The text written and not taken. */
+  get length() {
+    return this.#text.length;
+  }
+  /** Takes the text written so far. */
+  take() {
+    const text = this.#text;
+    this.#text = "";
+    return text;
+  }
+  /** `WriteStartDocument(standalone: true)`. */
+  startDocument() {
+    this.#text += declaration;
+  }
+  /** `WriteStartElement`: the element `name`, as written, declaring `namespace` as the default one when given. */
+  start(name, namespace) {
+    this.#close();
+    this.#text += `<${name}`;
+    this.#names.push(name);
+    this.#open = true;
+    this.#namespace = namespace;
+  }
+  /** `WriteAttributeString`: an attribute of the open start tag, its name as written (`r:id`, `xmlns:r`). */
+  attribute(name, value) {
+    if (!this.#open) throw new Error(`Internal: the attribute ${name} is written outside a start tag.`);
+    this.#text += ` ${name}="${escapeAttribute(value)}"`;
+  }
+  /** `WriteString`: text inside the element. Even empty, it closes the start tag, so the element ends with its own tag. */
+  text(value) {
+    this.#close();
+    this.#text += escapeText(value);
+  }
+  /** `WriteEndElement`. */
+  end() {
+    const name = this.#names.pop();
+    if (name === void 0) throw new Error("Internal: an element is ended where none is open.");
+    if (this.#open) {
+      this.#declare();
+      this.#text += " />";
+      this.#open = false;
+    } else {
+      this.#text += `</${name}>`;
+    }
+  }
+  /** `WriteElementString`: an element holding `value`, or empty for none or ''. */
+  element(name, value) {
+    this.start(name);
+    if (value !== null && value !== "") this.text(value);
+    this.end();
+  }
+  #declare() {
+    if (this.#namespace !== void 0) this.#text += ` xmlns="${escapeAttribute(this.#namespace)}"`;
+    this.#namespace = void 0;
+  }
+  #close() {
+    if (!this.#open) return;
+    this.#declare();
+    this.#text += ">";
+    this.#open = false;
+  }
+};
+
+// src/crc32.ts
+var table = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = (c & 1) !== 0 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(crc, bytes) {
+  let c = ~crc >>> 0;
+  for (let i = 0; i < bytes.length; i++) {
+    c = table[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  }
+  return ~c >>> 0;
+}
+
+// src/zip-write.ts
+var dosDate = 0 << 9 | 1 << 5 | 1;
+var encoder = new TextEncoder();
+var ZipEntryWriter = class {
+  #name;
+  #writer;
+  #compressed = [];
+  #pumped;
+  #written = Promise.resolve();
+  #compressedSize = 0;
+  #crc = 0;
+  #size = 0;
+  #closed = false;
+  #result;
+  constructor(name) {
+    this.#name = name;
+    const stream = new CompressionStream("deflate-raw");
+    this.#writer = stream.writable.getWriter();
+    const reader = stream.readable.getReader();
+    this.#pumped = (async () => {
+      for (; ; ) {
+        const result = await reader.read();
+        if (result.done) return;
+        this.#compressed.push(result.value);
+        this.#compressedSize += result.value.length;
+      }
+    })();
+  }
+  /** Adds `bytes` to the part. They are deflated in turn; `flush` awaits them. */
+  write(bytes) {
+    if (this.#closed) throw new Error(`Internal: the part '${this.#name}' is written after it was closed.`);
+    if (bytes.length === 0) return;
+    this.#crc = crc32(this.#crc, bytes);
+    this.#size += bytes.length;
+    const writer = this.#writer;
+    this.#written = this.#written.then(() => writer.write(bytes));
+  }
+  /** Awaits the deflating of every byte written so far, so that memory holds them compressed. */
+  async flush() {
+    await this.#written;
+  }
+  /** Ends the part: what it was given, deflated. */
+  async close() {
+    this.#closed = true;
+    await this.#written;
+    await this.#writer.close();
+    await this.#pumped;
+    this.#result = { name: encoder.encode(this.#name), crc: this.#crc, size: this.#size, compressed: this.#compressed, compressedSize: this.#compressedSize };
+  }
+  /** The part as closed. */
+  get result() {
+    if (this.#result === void 0) throw new Error(`Internal: the part '${this.#name}' is put in the package before it was closed.`);
+    return this.#result;
+  }
+};
+function header(size) {
+  const bytes = new Uint8Array(size);
+  return { bytes, view: new DataView(bytes.buffer) };
+}
+var ZipWriter = class {
+  #entries = [];
+  /** Begins the part `name`, after every part begun before it. */
+  entry(name) {
+    const entry = new ZipEntryWriter(name);
+    this.#entries.push(entry);
+    return entry;
+  }
+  /** The package, every part of it closed. */
+  finish() {
+    const entries = this.#entries.map((e) => e.result);
+    const parts = [];
+    const offsets = [];
+    let offset = 0;
+    for (const e of entries) {
+      offsets.push(offset);
+      const { bytes: bytes2, view: view2 } = header(30 + e.name.length);
+      view2.setUint32(0, 67324752, true);
+      view2.setUint16(4, 20, true);
+      view2.setUint16(6, 0, true);
+      view2.setUint16(8, 8, true);
+      view2.setUint16(10, 0, true);
+      view2.setUint16(12, dosDate, true);
+      view2.setUint32(14, e.crc, true);
+      view2.setUint32(18, e.compressedSize, true);
+      view2.setUint32(22, e.size, true);
+      view2.setUint16(26, e.name.length, true);
+      view2.setUint16(28, 0, true);
+      bytes2.set(e.name, 30);
+      parts.push(bytes2);
+      parts.push(...e.compressed);
+      offset += bytes2.length + e.compressedSize;
+    }
+    const directoryStart = offset;
+    entries.forEach((e, i) => {
+      const { bytes: bytes2, view: view2 } = header(46 + e.name.length);
+      view2.setUint32(0, 33639248, true);
+      view2.setUint16(4, 20, true);
+      view2.setUint16(6, 20, true);
+      view2.setUint16(8, 0, true);
+      view2.setUint16(10, 8, true);
+      view2.setUint16(12, 0, true);
+      view2.setUint16(14, dosDate, true);
+      view2.setUint32(16, e.crc, true);
+      view2.setUint32(20, e.compressedSize, true);
+      view2.setUint32(24, e.size, true);
+      view2.setUint16(28, e.name.length, true);
+      view2.setUint32(42, elementAt(offsets, i), true);
+      bytes2.set(e.name, 46);
+      parts.push(bytes2);
+      offset += bytes2.length;
+    });
+    const { bytes, view } = header(22);
+    view.setUint32(0, 101010256, true);
+    view.setUint16(8, entries.length, true);
+    view.setUint16(10, entries.length, true);
+    view.setUint32(12, offset - directoryStart, true);
+    view.setUint32(16, directoryStart, true);
+    parts.push(bytes);
+    return new Blob(parts, { type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" });
+  }
+};
+
+// src/writer.ts
+var pieceLength = 64 * 1024;
+var writeBatch = 4096;
+var encoder2 = new TextEncoder();
+function hasControl(text) {
+  for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) < 32) return true;
+  return false;
+}
+function isWhiteSpace(c) {
+  return c >= 9 && c <= 13 || c === 32 || c === 133 || c === 160 || c === 5760 || c >= 8192 && c <= 8202 || c === 8232 || c === 8233 || c === 8239 || c === 8287 || c === 12288;
+}
+function writeText(w, text) {
+  w.start("t");
+  if (text.length > 0 && (isWhiteSpace(text.charCodeAt(0)) || isWhiteSpace(text.charCodeAt(text.length - 1)) || text.includes("\n") || text.includes("	"))) {
+    w.attribute("xml:space", "preserve");
+  }
+  w.text(encodeXString(text));
+  w.end();
+}
+var WorkbookWriter = class {
+  #zip = new ZipWriter();
+  #styles;
+  #activeSheet;
+  #date1904;
+  #fullCalculation;
+  #definedNames;
+  #max;
+  #sheets = [];
+  #sharedIndex = /* @__PURE__ */ new Map();
+  #shared = [];
+  #tables = [];
+  #closing = [];
+  #side;
+  #current;
+  #completed = false;
+  #refused = false;
+  #sharedReferences = 0;
+  #uncompressed = 0;
+  #dynamic = false;
+  constructor(options = {}) {
+    this.#styles = options.styles === void 0 ? defaultStyles : options.styles;
+    this.#activeSheet = options.activeSheet === void 0 ? 0 : whole(options.activeSheet, "The active sheet");
+    this.#date1904 = options.date1904 === true;
+    this.#fullCalculation = options.fullCalculationOnLoad === true;
+    this.#definedNames = options.definedNames === void 0 ? [] : [...options.definedNames];
+    this.#max = options.maxUncompressedBytes === void 0 ? defaultMaxUncompressedBytes : options.maxUncompressedBytes;
+    if (!Number.isInteger(this.#max) || this.#max < 1 || this.#max > defaultMaxUncompressedBytes) {
+      throw new RangeError(`MaxUncompressedBytes is 1 to ${grouped(defaultMaxUncompressedBytes)}.`);
+    }
+    validateStyles(this.#styles);
+    validateNames(this.#definedNames);
+    this.#side = {
+      styles: this.#styles,
+      share: (text) => {
+        this.#sharedReferences++;
+        let at = this.#sharedIndex.get(text);
+        if (at === void 0) {
+          at = this.#shared.length;
+          this.#shared.push(text);
+          this.#sharedIndex.set(text, at);
+        }
+        return at;
+      },
+      dynamicArray: () => {
+        this.#dynamic = true;
+      },
+      addTable: (sheet, table2) => this.#addTable(sheet, table2),
+      put: (entry, text, part, sheet) => this.#put(entry, text, part, sheet),
+      checkUsable: () => {
+        if (this.#refused) throw new Error("The workbook was refused as too large and is abandoned: nothing more is written to it.");
+      }
+    };
+  }
+  /**
+   * Begins the next worksheet, after the ones before it, ending the one being written. Its cells are then written in the
+   * order of the sheet: row by row, left to right.
+   * @param name - The sheet's name: 1 to 31 characters, none of `[ ] : * ? / \` and no control character or half of a
+   * surrogate pair, not beginning or ending with `'`, and no other sheet's in any case.
+   * @param columns - The column widths: ranges that do not overlap, each naming a cell format the styles hold.
+   * @param visibility - Whether the sheet is shown; `visible` when left out.
+   */
+  addSheet(name, columns = [], visibility = "visible") {
+    this.#checkOpen();
+    this.#checkName(name);
+    const sorted = columns.toSorted((a, b) => a.first - b.first);
+    let last = -1;
+    for (const c of sorted) {
+      const style = c.styleIndex === void 0 ? 0 : c.styleIndex;
+      const range = `${String(c.first)} to ${String(c.last)}`;
+      if (!Number.isInteger(c.first) || !Number.isInteger(c.last) || c.first < 0 || c.last < c.first || c.last >= maxColumns) {
+        throw new TypeError(`The column range ${range} lies outside the sheet's columns.`);
+      }
+      if (c.first <= last) throw new TypeError(`The column range ${range} overlaps another, which ends at ${String(last)}.`);
+      if (!Number.isInteger(style) || style < 0 || style >= this.#styles.cellFormats.length) {
+        throw new TypeError(`The column range ${range} names the cell format ${String(style)}, which the styles do not hold.`);
+      }
+      last = c.last;
+    }
+    this.#endCurrent();
+    const index = this.#sheets.length;
+    this.#sheets.push({ name, visibility });
+    const part = `xl/worksheets/sheet${String(index + 1)}.xml`;
+    this.#current = new SheetWriter(
+      this.#side,
+      index,
+      name,
+      part,
+      this.#zip.entry(part),
+      sorted,
+      index === this.#activeSheet,
+      (closing) => this.#closing.push(closing)
+    );
+    return this.#current;
+  }
+  /**
+   * Ends the last worksheet, writes the parts that need every sheet, and returns the package. The workbook needs a sheet,
+   * and the options' active sheet must name one of them.
+   */
+  async complete() {
+    this.#checkOpen();
+    if (this.#sheets.length === 0) throw new Error("A workbook holds at least one sheet; add one before completing it.");
+    if (this.#activeSheet < 0 || this.#activeSheet >= this.#sheets.length) {
+      throw new Error(`The active sheet ${String(this.#activeSheet)} is not one of the workbook's ${String(this.#sheets.length)} sheets.`);
+    }
+    this.#completed = true;
+    this.#endCurrent();
+    this.#current = void 0;
+    const dynamic = this.#dynamic;
+    if (this.#shared.length > 0) this.#part("xl/sharedStrings.xml", (w) => this.#writeSharedStrings(w));
+    this.#part("xl/styles.xml", (w) => writeStyles(w, this.#styles));
+    if (dynamic) this.#part("xl/metadata.xml", writeMetadata);
+    this.#tables.forEach(({ table: table2 }, i) => {
+      const id = i + 1;
+      this.#part(`xl/tables/table${String(id)}.xml`, (w) => writeTable(w, table2, id));
+    });
+    for (const sheet of new Set(this.#tables.map((t) => t.sheet))) {
+      this.#part(`xl/worksheets/_rels/sheet${String(sheet + 1)}.xml.rels`, (w) => this.#writeSheetRelationships(w, sheet));
+    }
+    this.#part("xl/workbook.xml", (w) => this.#writeWorkbook(w));
+    this.#part("xl/_rels/workbook.xml.rels", (w) => this.#writeWorkbookRelationships(w, dynamic));
+    this.#part("_rels/.rels", writeRootRelationships);
+    this.#part("[Content_Types].xml", (w) => this.#writeContentTypes(w, dynamic));
+    await Promise.all(this.#closing);
+    return this.#zip.finish();
+  }
+  /** Abandons a workbook not completed, writing nothing more. */
+  async abandon() {
+    this.#completed = true;
+    this.#current?.abandon();
+    this.#current = void 0;
+    await Promise.allSettled(this.#closing);
+  }
+  #checkOpen() {
+    this.#side.checkUsable();
+    if (this.#completed) throw new Error("The workbook is completed or abandoned: nothing more is written to it.");
+  }
+  #endCurrent() {
+    this.#current?.end();
+  }
+  #put(entry, text, part, sheet) {
+    this.#side.checkUsable();
+    const bytes = encoder2.encode(text);
+    this.#uncompressed += bytes.length;
+    if (this.#uncompressed > this.#max) {
+      this.#refused = true;
+      throw new XlsxError(
+        "tooLarge",
+        `The workbook would hold more than the ${grouped(this.#max)} uncompressed bytes a file is written with (XlsxWriteOptions.MaxUncompressedBytes).`,
+        { part, sheet }
+      );
+    }
+    entry.write(bytes);
+  }
+  #part(name, write) {
+    const entry = this.#zip.entry(name);
+    const w = new XmlTextWriter();
+    w.startDocument();
+    write(w);
+    this.#put(entry, w.take(), name, void 0);
+    this.#closing.push(entry.close());
+  }
+  /** Records a table on the sheet `sheet`, checked against every other table and defined name of the workbook: the id of
+   * the relationship the sheet's `tablePart` names. */
+  #addTable(sheet, table2) {
+    checkTable(table2);
+    if (this.#tables.some((t) => equalsIgnoreCase(t.table.name, table2.name)) || this.#definedNames.some((n) => equalsIgnoreCase(n.name, table2.name))) {
+      throw new TypeError(`The workbook already has a table or a defined name named '${table2.name}', in some case.`);
+    }
+    const own = this.#tables.filter((t) => t.sheet === sheet).map((t) => t.table);
+    const other = own.find((t) => overlaps(t, table2));
+    if (other !== void 0) {
+      throw new TypeError(`The table '${table2.name}' (${tableReference(table2)}) overlaps the table '${other.name}' (${tableReference(other)}).`);
+    }
+    this.#tables.push({ sheet, table: table2 });
+    return `rId${String(own.length + 1)}`;
+  }
+  #checkName(name) {
+    if (typeof name !== "string") throw new TypeError("A sheet's name is text.");
+    if (name.length === 0 || name.length > 31) throw new TypeError(`A sheet's name is 1 to 31 characters; '${name}' is ${String(name.length)}.`);
+    if (!carries(name, false) || hasControl(name)) {
+      throw new TypeError("A sheet's name holds no control character and no half of a surrogate pair, which XML cannot carry.");
+    }
+    if (/[[\]:*?/\\]/.test(name)) throw new TypeError(`A sheet's name holds none of [ ] : * ? / \\; '${name}' does.`);
+    if (name.startsWith("'") || name.endsWith("'")) throw new TypeError(`A sheet's name does not begin or end with an apostrophe; '${name}' does.`);
+    if (this.#sheets.some((s) => equalsIgnoreCase(s.name, name))) throw new TypeError(`The workbook already has a sheet named '${name}', in some case.`);
+  }
+  #writeSharedStrings(w) {
+    w.start("sst", mainNamespace);
+    w.attribute("count", String(this.#sharedReferences));
+    w.attribute("uniqueCount", String(this.#shared.length));
+    for (const text of this.#shared) {
+      w.start("si");
+      writeText(w, text);
+      w.end();
+    }
+    w.end();
+  }
+  #writeSheetRelationships(w, sheet) {
+    w.start("Relationships", packageRelationshipsNamespace);
+    let id = 1;
+    this.#tables.forEach((t, i) => {
+      if (t.sheet !== sheet) return;
+      w.start("Relationship");
+      w.attribute("Id", `rId${String(id++)}`);
+      w.attribute("Type", tableType);
+      w.attribute("Target", `../tables/table${String(i + 1)}.xml`);
+      w.end();
+    });
+    w.end();
+  }
+  #writeWorkbook(w) {
+    w.start("workbook", mainNamespace);
+    w.attribute("xmlns:r", relationshipsNamespace);
+    if (this.#date1904) {
+      w.start("workbookPr");
+      w.attribute("date1904", "1");
+      w.end();
+    }
+    w.start("bookViews");
+    w.start("workbookView");
+    if (this.#activeSheet !== 0) w.attribute("activeTab", String(this.#activeSheet));
+    w.end();
+    w.end();
+    w.start("sheets");
+    this.#sheets.forEach((s, i) => {
+      w.start("sheet");
+      w.attribute("name", s.name);
+      w.attribute("sheetId", String(i + 1));
+      if (s.visibility !== "visible") w.attribute("state", s.visibility);
+      w.attribute("r:id", `rId${String(i + 1)}`);
+      w.end();
+    });
+    w.end();
+    if (this.#definedNames.length > 0) {
+      w.start("definedNames");
+      for (const n of this.#definedNames) {
+        w.start("definedName");
+        w.attribute("name", n.name);
+        if (n.localSheet !== void 0 && n.localSheet !== null) w.attribute("localSheetId", String(n.localSheet));
+        if (n.hidden === true) w.attribute("hidden", "1");
+        w.text(encodeXString(n.text));
+        w.end();
+      }
+      w.end();
+    }
+    w.start("calcPr");
+    w.attribute("calcId", "191029");
+    if (this.#fullCalculation) w.attribute("fullCalcOnLoad", "1");
+    w.end();
+    w.end();
+  }
+  #writeWorkbookRelationships(w, dynamic) {
+    w.start("Relationships", packageRelationshipsNamespace);
+    let id = 1;
+    const relationship = (type, target) => {
+      w.start("Relationship");
+      w.attribute("Id", `rId${String(id++)}`);
+      w.attribute("Type", type);
+      w.attribute("Target", target);
+      w.end();
+    };
+    this.#sheets.forEach((_, i) => relationship(worksheetType, `worksheets/sheet${String(i + 1)}.xml`));
+    relationship(stylesType, "styles.xml");
+    if (this.#shared.length > 0) relationship(sharedStringsType, "sharedStrings.xml");
+    if (dynamic) relationship(sheetMetadataType, "metadata.xml");
+    w.end();
+  }
+  #writeContentTypes(w, dynamic) {
+    w.start("Types", contentTypesNamespace);
+    const entry = (element, key, value, type) => {
+      w.start(element);
+      w.attribute(key, value);
+      w.attribute("ContentType", type);
+      w.end();
+    };
+    entry("Default", "Extension", "rels", relationshipsContent);
+    entry("Default", "Extension", "xml", "application/xml");
+    entry("Override", "PartName", "/xl/workbook.xml", workbookContent);
+    this.#sheets.forEach((_, i) => entry("Override", "PartName", `/xl/worksheets/sheet${String(i + 1)}.xml`, worksheetContent));
+    entry("Override", "PartName", "/xl/styles.xml", stylesContent);
+    if (this.#shared.length > 0) entry("Override", "PartName", "/xl/sharedStrings.xml", sharedStringsContent);
+    if (dynamic) entry("Override", "PartName", "/xl/metadata.xml", sheetMetadataContent);
+    this.#tables.forEach((_, i) => entry("Override", "PartName", `/xl/tables/table${String(i + 1)}.xml`, tableContent));
+    w.end();
+  }
+};
+function createXlsxWriter(options) {
+  return new WorkbookWriter(options);
+}
+function overlaps(a, b) {
+  return a.headerRow <= b.headerRow + b.dataRows && b.headerRow <= a.headerRow + a.dataRows && a.firstColumn < b.firstColumn + b.columns.length && b.firstColumn < a.firstColumn + a.columns.length;
+}
+function writeRootRelationships(w) {
+  w.start("Relationships", packageRelationshipsNamespace);
+  w.start("Relationship");
+  w.attribute("Id", "rId1");
+  w.attribute("Type", officeDocumentType);
+  w.attribute("Target", "xl/workbook.xml");
+  w.end();
+  w.end();
+}
+function writeMetadata(w) {
+  const xda = "http://schemas.microsoft.com/office/spreadsheetml/2017/dynamicarray";
+  w.start("metadata", mainNamespace);
+  w.attribute("xmlns:xda", xda);
+  w.start("metadataTypes");
+  w.attribute("count", "1");
+  w.start("metadataType");
+  for (const [name, value] of [
+    ["name", "XLDAPR"],
+    ["minSupportedVersion", "120000"],
+    ["copy", "1"],
+    ["pasteAll", "1"],
+    ["pasteValues", "1"],
+    ["merge", "1"],
+    ["splitFirst", "1"],
+    ["rowColShift", "1"],
+    ["clearFormats", "1"],
+    ["clearComments", "1"],
+    ["assign", "1"],
+    ["coerce", "1"],
+    ["cellMeta", "1"]
+  ]) {
+    w.attribute(name, value);
+  }
+  w.end();
+  w.end();
+  w.start("futureMetadata");
+  w.attribute("name", "XLDAPR");
+  w.attribute("count", "1");
+  w.start("bk");
+  w.start("extLst");
+  w.start("ext");
+  w.attribute("uri", dynamicArrayExtension);
+  w.start("xda:dynamicArrayProperties");
+  w.attribute("fDynamic", "1");
+  w.attribute("fCollapsed", "0");
+  w.end();
+  w.end();
+  w.end();
+  w.end();
+  w.end();
+  w.start("cellMetadata");
+  w.attribute("count", "1");
+  w.start("bk");
+  w.start("rc");
+  w.attribute("t", "1");
+  w.attribute("v", "0");
+  w.end();
+  w.end();
+  w.end();
+  w.end();
+}
+function writeTable(w, table2, id) {
+  const reference = tableReference(table2);
+  w.start("table", mainNamespace);
+  w.attribute("id", String(id));
+  w.attribute("name", table2.name);
+  w.attribute("displayName", table2.name);
+  w.attribute("ref", reference);
+  w.attribute("totalsRowShown", "0");
+  if (table2.autoFilter !== false) {
+    w.start("autoFilter");
+    w.attribute("ref", reference);
+    w.end();
+  }
+  w.start("tableColumns");
+  w.attribute("count", String(table2.columns.length));
+  table2.columns.forEach((column, i) => {
+    w.start("tableColumn");
+    w.attribute("id", String(i + 1));
+    w.attribute("name", encodeXString(column));
+    w.end();
+  });
+  w.end();
+  w.start("tableStyleInfo");
+  w.attribute("name", "TableStyleMedium2");
+  w.attribute("showFirstColumn", "0");
+  w.attribute("showLastColumn", "0");
+  w.attribute("showRowStripes", "1");
+  w.attribute("showColumnStripes", "0");
+  w.end();
+  w.end();
+}
+function checkTable(table2) {
+  if (!isValidTableName(table2.name)) {
+    throw new TypeError(
+      `'${table2.name}' is not a name a table can have: a letter, _ or \\, then letters, digits, _ and ., at most 255 characters, and not a cell's address.`
+    );
+  }
+  const name = table2.name;
+  if (table2.columns.length === 0) throw new TypeError(`The table '${name}' has at least one column.`);
+  const seen = /* @__PURE__ */ new Set();
+  for (const column of table2.columns) {
+    if (typeof column !== "string" || column === "") throw new TypeError(`A column of the table '${name}' has no name.`);
+    if (!carries(column, true)) throw new TypeError(`A column's name in the table '${name}' holds half of a surrogate pair, which XML cannot carry.`);
+    const folded = foldCase(column);
+    if (seen.has(folded)) throw new TypeError(`The table '${name}' names the column '${column}' twice, in some case.`);
+    seen.add(folded);
+  }
+  if (!Number.isInteger(table2.dataRows) || table2.dataRows < 1) {
+    throw new TypeError(`The table '${name}' has at least one row of data; Excel holds a table of none as one empty row.`);
+  }
+  if (!Number.isInteger(table2.headerRow) || !Number.isInteger(table2.firstColumn) || table2.headerRow < 0 || table2.firstColumn < 0 || table2.headerRow + table2.dataRows >= maxRows || table2.firstColumn + table2.columns.length > maxColumns) {
+    throw new TypeError(`The table '${name}' lies outside the sheet.`);
+  }
+}
+function whole(value, what) {
+  if (!Number.isInteger(value)) throw new TypeError(`${what} is a whole number, not ${String(value)}.`);
+  return value;
+}
+function validateStyles(styles) {
+  if (styles.fonts.length === 0 || styles.fills.length < 2 || styles.borders.length === 0 || styles.cellFormats.length === 0) {
+    throw new TypeError("A styles part has at least one font, two fills (none and gray125, which Excel reserves), one border and one cell format.");
+  }
+  styles.cellFormats.forEach((f, i) => {
+    for (const id of [f.numberFormatId, f.fontId, f.fillId, f.borderId]) whole(id, `An index of the cell format ${String(i)}`);
+    if (f.alignment !== null) {
+      whole(f.alignment.indent, `The indent of the cell format ${String(i)}`);
+      whole(f.alignment.textRotation, `The text rotation of the cell format ${String(i)}`);
+    }
+    if (f.fontId < 0 || f.fontId >= styles.fonts.length || f.fillId < 0 || f.fillId >= styles.fills.length || f.borderId < 0 || f.borderId >= styles.borders.length || f.numberFormatId < 0 || f.numberFormatId >= firstCustomNumberFormat && !styles.numberFormats.has(f.numberFormatId)) {
+      throw new TypeError(`The cell format ${String(i)} names a font, fill, border or Number Format the styles do not hold.`);
+    }
+  });
+  if ([...styles.numberFormats.values()].some((code) => typeof code !== "string" || !carries(code, true)) || styles.fonts.some((f) => f.name !== null && !carries(f.name, false)) || styles.fills.some((f) => f.pattern !== null && !carries(f.pattern, false))) {
+    throw new TypeError("A Number Format, a font's name or a fill's pattern holds text XML cannot carry: a control character, or half of a surrogate pair.");
+  }
+}
+function validateNames(names) {
+  for (const n of names) {
+    if (typeof n.name !== "string" || n.name === "" || typeof n.text !== "string") throw new TypeError("A defined name has a name and a text.");
+    if (n.localSheet !== void 0 && n.localSheet !== null) whole(n.localSheet, `The defined name '${n.name}''s sheet`);
+    if (!carries(n.name, false) || hasControl(n.name) || !carries(n.text, true)) {
+      throw new TypeError(`The defined name '${n.name}' holds a control character or half of a surrogate pair, which XML cannot carry.`);
+    }
+  }
+}
+var SheetWriter = class {
+  #owner;
+  #index;
+  #part;
+  #entry;
+  #xml = new XmlTextWriter();
+  #closed;
+  #tables = [];
+  #rowOpen = false;
+  #ended = false;
+  #row = -1;
+  #column = -1;
+  /** The sheet's name. */
+  name;
+  constructor(owner, index, name, part, entry, columns, active, closed) {
+    this.#owner = owner;
+    this.#index = index;
+    this.name = name;
+    this.#part = part;
+    this.#entry = entry;
+    this.#closed = closed;
+    const xml = this.#xml;
+    xml.startDocument();
+    xml.start("worksheet", mainNamespace);
+    xml.attribute("xmlns:r", relationshipsNamespace);
+    xml.start("sheetViews");
+    xml.start("sheetView");
+    if (active) xml.attribute("tabSelected", "1");
+    xml.attribute("workbookViewId", "0");
+    xml.end();
+    xml.end();
+    xml.start("sheetFormatPr");
+    xml.attribute("defaultRowHeight", "15");
+    xml.end();
+    if (columns.length > 0) {
+      xml.start("cols");
+      for (const c of columns) {
+        xml.start("col");
+        xml.attribute("min", String(c.first + 1));
+        xml.attribute("max", String(c.last + 1));
+        if (c.width !== void 0 && c.width !== null) {
+          xml.attribute("width", roundTrip(c.width));
+          if (c.customWidth !== false) xml.attribute("customWidth", "1");
+          if (c.bestFit === true) xml.attribute("bestFit", "1");
+        }
+        if (c.styleIndex !== void 0 && c.styleIndex !== 0) xml.attribute("style", String(c.styleIndex));
+        if (c.hidden === true) xml.attribute("hidden", "1");
+        xml.end();
+      }
+      xml.end();
+    }
+    xml.start("sheetData");
+  }
+  #checkOpen() {
+    this.#owner.checkUsable();
+    if (this.#ended) throw new Error(`The sheet '${this.name}' is ended: another sheet was begun, or the workbook completed.`);
+  }
+  /**
+   * Adds an Excel Table over cells of this sheet (`tableParts`, and a table part of its own), before the first cell of its
+   * header's row is written. Each cell of its header must then be written, as text equal to its column's name (a shared
+   * or inline string, no Formula), or the cell, or the sheet's end, is refused; its rows of data hold whatever is written
+   * there. A table whose name is another table's or a defined name's in the workbook, in any case, or that overlaps
+   * another table of the sheet, is refused.
+   */
+  addTable(table2) {
+    this.#checkOpen();
+    const copy = Object.freeze({ ...table2, columns: Object.freeze([...table2.columns]) });
+    if (copy.headerRow <= this.#row) {
+      throw new TypeError(`The table '${copy.name}' is added after row ${String(this.#row + 1)} was begun: a table is added before its header's row.`);
+    }
+    const id = this.#owner.addTable(this.#index, copy);
+    this.#tables.push({ table: copy, id, written: 0 });
+  }
+  /**
+   * Begins `row` with the cell format of its own that its empty cells take (`customFormat`), after every row written
+   * before it; the row's cells, if any, are then written as any others. A row written before, or one that already holds
+   * a cell, is refused.
+   */
+  writeRow(row) {
+    this.#checkOpen();
+    if (!Number.isInteger(row.row) || row.row < 0 || row.row >= maxRows) throw new TypeError(`The row ${String(row.row)} lies outside the sheet.`);
+    if (row.row <= this.#row) {
+      throw new TypeError(`The row ${String(row.row + 1)} is begun after row ${String(this.#row + 1)}: a sheet's rows are written in order, each once.`);
+    }
+    if (!Number.isInteger(row.styleIndex) || row.styleIndex < 0 || row.styleIndex >= this.#owner.styles.cellFormats.length) {
+      throw new TypeError(`The row ${String(row.row + 1)} names the cell format ${String(row.styleIndex)}, which the styles do not hold.`);
+    }
+    const xml = this.#xml;
+    if (this.#rowOpen) xml.end();
+    xml.start("row");
+    xml.attribute("r", String(row.row + 1));
+    xml.attribute("s", String(row.styleIndex));
+    xml.attribute("customFormat", "1");
+    this.#rowOpen = true;
+    this.#row = row.row;
+    this.#column = -1;
+    this.#spill();
+  }
+  /**
+   * Writes `cell`, after every cell written before it in the sheet's order. A shared string is written from its `text`
+   * into the workbook's shared strings, whatever its `value` says.
+   */
+  write(cell) {
+    this.#checkOpen();
+    if (!Number.isInteger(cell.row) || !Number.isInteger(cell.column) || cell.row < 0 || cell.row >= maxRows || cell.column < 0 || cell.column >= maxColumns) {
+      throw new TypeError(`The cell at row ${String(cell.row)}, column ${String(cell.column)} lies outside the sheet.`);
+    }
+    const reference = formatCell(cell.row, cell.column);
+    const type = typeAttribute(cell);
+    if (cell.row < this.#row || cell.row === this.#row && cell.column <= this.#column) {
+      const after = this.#column < 0 ? `row ${String(this.#row + 1)}` : formatCell(this.#row, this.#column);
+      throw new TypeError(`The cell ${reference} is written after ${after}: a sheet's cells are written row by row, left to right, each once.`);
+    }
+    const styleIndex = cell.styleIndex === void 0 ? 0 : cell.styleIndex;
+    if (!Number.isInteger(styleIndex) || styleIndex < 0 || styleIndex >= this.#owner.styles.cellFormats.length) {
+      throw new TypeError(`The cell ${reference} names the cell format ${String(styleIndex)}, which the styles do not hold.`);
+    }
+    const value = cell.value === void 0 ? null : cell.value;
+    const text = cell.text === void 0 ? null : cell.text;
+    const formula = cell.formula === void 0 ? null : cell.formula;
+    const kind = formula === null || formula.kind === void 0 ? "normal" : formula.kind;
+    const sharedIndex = formula === null || formula.sharedIndex === void 0 ? null : formula.sharedIndex;
+    if (kind === "shared" && sharedIndex === null) throw new TypeError(`The cell ${reference}'s shared formula names no group.`);
+    if (sharedIndex !== null) whole(sharedIndex, `The cell ${reference}'s shared formula group`);
+    if (formula !== null && (typeof formula.text !== "string" || !carries(formula.text, true) || formula.reference !== void 0 && formula.reference !== null && !carries(formula.reference, false))) {
+      throw new TypeError(`The cell ${reference}'s Formula holds text XML cannot carry.`);
+    }
+    const carried = cell.type === "sharedString" || cell.type === "inlineString" ? text === null || carries(text, true) : cell.type === "formulaString" ? value === null || carries(value, true) : value === null || carries(value, false);
+    if (!carried) throw new TypeError(`The cell ${reference} holds text XML cannot carry: a control character, or half of a surrogate pair.`);
+    const header2 = this.#headerOf(cell, reference, text, formula);
+    const xml = this.#xml;
+    if (cell.row !== this.#row) {
+      if (this.#rowOpen) xml.end();
+      xml.start("row");
+      xml.attribute("r", String(cell.row + 1));
+      this.#rowOpen = true;
+      this.#row = cell.row;
+    }
+    this.#column = cell.column;
+    if (header2 !== void 0) header2.written++;
+    xml.start("c");
+    xml.attribute("r", reference);
+    if (styleIndex !== 0) xml.attribute("s", String(styleIndex));
+    if (type !== void 0) xml.attribute("t", type);
+    if (formula !== null && formula.isDynamicArray === true) {
+      xml.attribute("cm", "1");
+      this.#owner.dynamicArray();
+    }
+    if (formula !== null) this.#writeFormula(formula, kind, sharedIndex, reference);
+    switch (cell.type) {
+      case "sharedString":
+        xml.element("v", String(this.#owner.share(text === null ? "" : text)));
+        break;
+      case "inlineString":
+        xml.start("is");
+        writeText(xml, text === null ? "" : text);
+        xml.end();
+        break;
+      case "formulaString":
+        if (value !== null) xml.element("v", encodeXString(value));
+        break;
+      case "number":
+      case "boolean":
+      case "error":
+      case "date":
+        if (value !== null) xml.element("v", value);
+        break;
+      default:
+        throw new TypeError(`'${String(cell.type)}' is not a cell's type.`);
+    }
+    xml.end();
+    this.#spill();
+  }
+  #writeFormula(formula, kind, sharedIndex, reference) {
+    const xml = this.#xml;
+    xml.start("f");
+    if (kind !== "normal") xml.attribute("t", kind);
+    if (formula.reference !== void 0 && formula.reference !== null) xml.attribute("ref", formula.reference);
+    else if (kind === "array") xml.attribute("ref", reference);
+    if (sharedIndex !== null) xml.attribute("si", String(sharedIndex));
+    if (formula.text.length > 0) xml.text(encodeXString(formula.text));
+    xml.end();
+  }
+  /** Writes every cell of `cells` in turn, flushing between batches. */
+  async writeAll(cells) {
+    let n = 0;
+    for (const cell of cells) {
+      this.write(cell);
+      if (++n % writeBatch === 0) await this.flush();
+    }
+  }
+  /** Awaits the deflating of what is written so far, so that memory holds it compressed: call it between batches of a
+   * large sheet. */
+  async flush() {
+    if (!this.#ended) this.#spill(true);
+    await this.#entry.flush();
+  }
+  /** The count of header cells written of the table whose header holds `cell`, or undefined when none does; a header's
+   * cell that does not hold its column's name as text is refused. */
+  #headerOf(cell, reference, text, formula) {
+    for (const t of this.#tables) {
+      const { table: table2 } = t;
+      if (cell.row !== table2.headerRow || cell.column < table2.firstColumn || cell.column >= table2.firstColumn + table2.columns.length) continue;
+      const name = elementAt(table2.columns, cell.column - table2.firstColumn);
+      if (cell.type !== "sharedString" && cell.type !== "inlineString" || formula !== null || text !== name) {
+        throw new TypeError(
+          `The cell ${reference} is in the header of the table '${table2.name}', and holds its column's name, '${name}', as text, with no Formula.`
+        );
+      }
+      return t;
+    }
+    return void 0;
+  }
+  /** Hands the text gathered to the package once it is long enough, or whatever there is when `all`. */
+  #spill(all = false) {
+    if (this.#xml.length === 0 || !all && this.#xml.length < pieceLength) return;
+    this.#owner.put(this.#entry, this.#xml.take(), this.#part, this.name);
+  }
+  /** Ends the sheet. */
+  end() {
+    if (this.#ended) return;
+    for (const { table: table2, written } of this.#tables) {
+      if (written !== table2.columns.length) {
+        throw new Error(`The sheet '${this.name}' ends with ${String(written)} of the ${String(table2.columns.length)} cells of the header of the table '${table2.name}' written; each holds its column's name.`);
+      }
+    }
+    this.#ended = true;
+    const xml = this.#xml;
+    if (this.#rowOpen) xml.end();
+    xml.end();
+    if (this.#tables.length > 0) {
+      xml.start("tableParts");
+      xml.attribute("count", String(this.#tables.length));
+      for (const { id } of this.#tables) {
+        xml.start("tablePart");
+        xml.attribute("r:id", id);
+        xml.end();
+      }
+      xml.end();
+    }
+    xml.end();
+    this.#owner.put(this.#entry, xml.take(), this.#part, this.name);
+    this.#closed(this.#entry.close());
+  }
+  /** Abandons the sheet. */
+  abandon() {
+    if (this.#ended) return;
+    this.#ended = true;
+    this.#closed(this.#entry.close());
+  }
+};
+function typeAttribute(cell) {
+  switch (cell.type) {
+    case "sharedString":
+      return "s";
+    case "inlineString":
+      return "inlineStr";
+    case "formulaString":
+      return "str";
+    case "boolean":
+      return "b";
+    case "error":
+      return "e";
+    case "date":
+      return "d";
+    case "number":
+      return void 0;
+    default:
+      throw new TypeError(`'${String(cell.type)}' is not a cell's type.`);
+  }
+}
+export {
+  XlsxError,
+  XlsxSharedStrings,
+  XlsxTheme,
+  applyTint,
+  automaticColor,
+  batchSize,
+  columnName,
+  createXlsxWriter,
+  defaultAlignment,
+  defaultIndexedColors,
+  defaultMaxCells,
+  defaultMaxUncompressedBytes,
+  defaultStyles,
+  elementMaxChildren,
+  elementMaxDepth,
+  elementMaxText,
+  firstCustomNumberFormat,
+  formatCell,
+  gray125Fill,
+  indexedColor,
+  isValidTableName,
+  maxColumns,
+  maxRows,
+  noBorder,
+  noBorderEdge,
+  noFill,
+  openXlsx,
+  parseCell,
+  referenceOf,
+  rgbColor,
+  solidFill,
+  tableReference,
+  themeColor
+};
+//# sourceMappingURL=index.js.map