@devmm/puredocs-excel 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2595 @@
+'use strict';
+
+var fflate = require('fflate');
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/io/xml-parser.ts
+function domElementToXml(el) {
+  const attributes = {};
+  for (let i = 0; i < el.attributes.length; i++) {
+    const attr = el.attributes[i];
+    attributes[attr.name] = attr.value;
+  }
+  const children = [];
+  for (let i = 0; i < el.children.length; i++) {
+    children.push(domElementToXml(el.children[i]));
+  }
+  return {
+    tagName: el.tagName,
+    attributes,
+    children,
+    textContent: el.textContent ?? ""
+  };
+}
+function parseDom(xmlString) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(xmlString, "application/xml");
+  const parseError = doc.querySelector("parsererror");
+  if (parseError) {
+    throw new Error(`XML parse error: ${parseError.textContent}`);
+  }
+  if (!doc.documentElement) {
+    throw new Error("XML parse error: no document element.");
+  }
+  return domElementToXml(doc.documentElement);
+}
+function parseMinimal(xmlString) {
+  const stack = [];
+  let pos = 0;
+  let root;
+  function skipUntil(ch) {
+    while (pos < xmlString.length && xmlString[pos] !== ch) pos++;
+  }
+  function parseAttributes(raw) {
+    const attrs = {};
+    const re = /(\S+?)\s*=\s*["']([^"']*)["']/g;
+    let m;
+    while ((m = re.exec(raw)) !== null) {
+      attrs[m[1]] = m[2].replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+    }
+    return attrs;
+  }
+  while (pos < xmlString.length) {
+    if (xmlString[pos] === "<") {
+      pos++;
+      if (xmlString[pos] === "?") {
+        skipUntil(">");
+        pos++;
+        continue;
+      }
+      if (xmlString[pos] === "!") {
+        if (xmlString.startsWith("![CDATA[", pos)) {
+          const cdataStart = pos + "![CDATA[".length;
+          const cdataEnd = xmlString.indexOf("]]>", cdataStart);
+          const end = cdataEnd === -1 ? xmlString.length : cdataEnd;
+          const cdata = xmlString.slice(cdataStart, end);
+          if (stack.length > 0) {
+            stack[stack.length - 1].textContent += cdata;
+          }
+          pos = cdataEnd === -1 ? xmlString.length : cdataEnd + 3;
+          continue;
+        }
+        skipUntil(">");
+        pos++;
+        continue;
+      }
+      const isClose = xmlString[pos] === "/";
+      if (isClose) pos++;
+      const tagStart = pos;
+      skipUntil(">");
+      const tagContent = xmlString.slice(tagStart, pos).trim();
+      pos++;
+      const isSelfClose = tagContent.endsWith("/");
+      const raw = isSelfClose ? tagContent.slice(0, -1).trim() : tagContent;
+      const spaceIdx = raw.search(/\s/);
+      const tagName = spaceIdx === -1 ? raw : raw.slice(0, spaceIdx);
+      const attrRaw = spaceIdx === -1 ? "" : raw.slice(spaceIdx);
+      const attributes = parseAttributes(attrRaw);
+      if (isClose) {
+        stack.pop();
+      } else {
+        const el = { tagName, attributes, children: [], textContent: "" };
+        if (stack.length > 0) {
+          stack[stack.length - 1].children.push(el);
+        } else {
+          root = el;
+        }
+        if (!isSelfClose) stack.push(el);
+      }
+    } else {
+      const textStart = pos;
+      skipUntil("<");
+      const text = xmlString.slice(textStart, pos).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+      if (stack.length > 0 && text.trim()) {
+        stack[stack.length - 1].textContent += text;
+      }
+    }
+  }
+  if (!root) throw new Error("XML parse error: empty document.");
+  return root;
+}
+function parseXml(xmlString) {
+  if (typeof DOMParser !== "undefined") {
+    return parseDom(xmlString);
+  }
+  return parseMinimal(xmlString);
+}
+function decodeUtf8(bytes) {
+  if (typeof TextDecoder !== "undefined") {
+    return new TextDecoder("utf-8").decode(bytes);
+  }
+  return Buffer.from(bytes).toString("utf-8");
+}
+function encodeUtf8(str) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(str);
+  }
+  return Buffer.from(str, "utf-8");
+}
+function getElementsByTagName(root, localName) {
+  const results = [];
+  const lname = localName.toLowerCase();
+  function walk(el) {
+    const tag = el.tagName.toLowerCase();
+    if (tag === lname || tag.endsWith(`:${lname}`)) {
+      results.push(el);
+    }
+    for (const child of el.children) walk(child);
+  }
+  walk(root);
+  return results;
+}
+function getAttr(el, name) {
+  if (name in el.attributes) return el.attributes[name];
+  const local = name.includes(":") ? name.split(":").pop() : name;
+  for (const [key, val] of Object.entries(el.attributes)) {
+    if (key === local || key.endsWith(`:${local}`)) return val;
+  }
+  return void 0;
+}
+
+// src/io/zip-reader.ts
+function unzipXlsx(buffer) {
+  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+  let raw;
+  try {
+    raw = fflate.unzipSync(bytes);
+  } catch (err) {
+    throw new Error(
+      `Failed to unzip xlsx: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const entries = /* @__PURE__ */ new Map();
+  for (const [path, data] of Object.entries(raw)) {
+    entries.set(path.replace(/\\/g, "/"), data);
+  }
+  return entries;
+}
+function readXmlEntry(entries, path) {
+  const bytes = entries.get(path);
+  if (!bytes) return void 0;
+  return decodeUtf8(bytes);
+}
+function requireXmlEntry(entries, path) {
+  const text = readXmlEntry(entries, path);
+  if (text === void 0) {
+    throw new Error(`Required xlsx entry not found: "${path}".`);
+  }
+  return text;
+}
+function listEntries(entries, prefix) {
+  const results = [];
+  for (const key of entries.keys()) {
+    if (key.startsWith(prefix)) results.push(key);
+  }
+  return results.sort();
+}
+function zipXlsx(entries) {
+  const zippable = {};
+  for (const [path, content] of entries) {
+    const bytes = typeof content === "string" ? encodeUtf8(content) : content;
+    zippable[path] = [bytes, { level: 6 }];
+  }
+  try {
+    return fflate.zipSync(zippable);
+  } catch (err) {
+    throw new Error(
+      `Failed to create xlsx: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function setXmlEntry(entries, path, xml2) {
+  entries.set(path, xml2);
+}
+function setBinaryEntry(entries, path, bytes) {
+  entries.set(path, bytes);
+}
+
+// src/io/xml-builder.ts
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function attrsToString(attrs) {
+  let result = "";
+  for (const [key, val] of Object.entries(attrs)) {
+    if (val === void 0 || val === null) continue;
+    result += ` ${key}="${escapeXml(String(val))}"`;
+  }
+  return result;
+}
+var XmlBuilder = class {
+  constructor() {
+    this.parts = [];
+  }
+  /** Appends the XML declaration header. */
+  xmlDeclaration() {
+    this.parts.push('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>');
+    return this;
+  }
+  /** Opens a tag with optional attributes. */
+  open(tag, attrs) {
+    this.parts.push(`<${tag}${attrsToString(attrs ?? {})}>`);
+    return this;
+  }
+  /** Closes a tag. */
+  close(tag) {
+    this.parts.push(`</${tag}>`);
+    return this;
+  }
+  /** Writes a self-closing tag. */
+  self(tag, attrs) {
+    this.parts.push(`<${tag}${attrsToString(attrs ?? {})} />`);
+    return this;
+  }
+  /** Writes a tag with text content. */
+  text(tag, content, attrs) {
+    this.parts.push(`<${tag}${attrsToString(attrs ?? {})}>${escapeXml(content)}</${tag}>`);
+    return this;
+  }
+  /** Writes raw (pre-escaped) XML — use with caution. */
+  raw(xml2) {
+    this.parts.push(xml2);
+    return this;
+  }
+  /** Returns the complete XML string. */
+  toString() {
+    return this.parts.join("");
+  }
+  /** Returns UTF-8 encoded bytes. */
+  toBytes() {
+    const str = this.toString();
+    if (typeof TextEncoder !== "undefined") {
+      return new TextEncoder().encode(str);
+    }
+    return Buffer.from(str, "utf-8");
+  }
+};
+function xml() {
+  return new XmlBuilder();
+}
+var NS = {
+  // SpreadsheetML
+  spreadsheetml: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+  // Relationships
+  relationships: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  relationshipsPackage: "http://schemas.openxmlformats.org/package/2006/relationships",
+  // Drawing
+  drawingml: "http://schemas.openxmlformats.org/drawingml/2006/main",
+  spreadsheetDrawing: "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing",
+  // Content types
+  contentTypes: "http://schemas.openxmlformats.org/package/2006/content-types",
+  // Core properties
+  coreProperties: "http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
+};
+var REL_TYPES = {
+  officeDocument: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+  worksheet: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet",
+  sharedStrings: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings",
+  styles: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles",
+  chart: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart",
+  drawing: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
+  hyperlink: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"
+};
+var CONTENT_TYPES = {
+  workbook: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
+  worksheet: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml",
+  sharedStrings: "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml",
+  styles: "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml",
+  drawing: "application/vnd.openxmlformats-officedocument.drawing+xml",
+  chart: "application/vnd.openxmlformats-officedocument.drawingml.chart+xml",
+  relationships: "application/vnd.openxmlformats-package.relationships+xml",
+  coreProperties: "application/vnd.openxmlformats-package.core-properties+xml"
+};
+
+// src/io/ooxml-templates.ts
+function buildContentTypes(sheetCount, extraOverrides = []) {
+  const overrides = Array.from(
+    { length: sheetCount },
+    (_, i) => `  <Override PartName="/xl/worksheets/sheet${i + 1}.xml" ContentType="${CONTENT_TYPES.worksheet}"/>`
+  );
+  for (const { partName, contentType } of extraOverrides) {
+    overrides.push(`  <Override PartName="${partName}" ContentType="${contentType}"/>`);
+  }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="${"http://schemas.openxmlformats.org/package/2006/content-types"}">
+  <Default Extension="rels" ContentType="${CONTENT_TYPES.relationships}"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/xl/workbook.xml" ContentType="${CONTENT_TYPES.workbook}"/>
+  <Override PartName="/xl/styles.xml" ContentType="${CONTENT_TYPES.styles}"/>
+  <Override PartName="/xl/sharedStrings.xml" ContentType="${CONTENT_TYPES.sharedStrings}"/>
+${overrides.join("\n")}
+</Types>`;
+}
+var ROOT_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="${REL_TYPES.officeDocument}" Target="xl/workbook.xml"/>
+</Relationships>`;
+function buildWorkbookRels(sheetCount) {
+  const sheetRels = Array.from(
+    { length: sheetCount },
+    (_, i) => `  <Relationship Id="rId${i + 1}" Type="${REL_TYPES.worksheet}" Target="worksheets/sheet${i + 1}.xml"/>`
+  ).join("\n");
+  const stylesId = sheetCount + 1;
+  const sharedId = sheetCount + 2;
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+${sheetRels}
+  <Relationship Id="rId${stylesId}" Type="${REL_TYPES.styles}" Target="styles.xml"/>
+  <Relationship Id="rId${sharedId}" Type="${REL_TYPES.sharedStrings}" Target="sharedStrings.xml"/>
+</Relationships>`;
+}
+function buildWorkbookXml(sheets) {
+  const sheetElems = sheets.map(({ name, sheetId, relationshipId, state }) => {
+    const stateAttr = state && state !== "visible" ? ` state="${state}"` : "";
+    return `    <sheet name="${escapeAttr(name)}" sheetId="${sheetId}" r:id="${relationshipId}"${stateAttr}/>`;
+  }).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+          xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <fileVersion appName="xl" lastEdited="7" lowestEdited="7" rupBuild="22228"/>
+  <workbookPr defaultThemeVersion="124226"/>
+  <bookViews>
+    <workbookView xWindow="240" yWindow="105" windowWidth="14805" windowHeight="8010"/>
+  </bookViews>
+  <sheets>
+${sheetElems}
+  </sheets>
+  <calcPr calcId="191028" fullCalcOnLoad="1"/>
+</workbook>`;
+}
+var EMPTY_WORKSHEET_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+           xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <sheetData/>
+</worksheet>`;
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/io/drawing-part.ts
+var WORKSHEET_DRAWING_REL_ID = "rId1";
+function buildDrawingXml(anchorsXml) {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<xdr:wsDr xmlns:xdr="${NS.spreadsheetDrawing}" xmlns:a="${NS.drawingml}">${anchorsXml}</xdr:wsDr>`;
+}
+function buildRelsXml(relationships) {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+${relationships.join("\n")}
+</Relationships>`;
+}
+
+// src/model/shared-string-manager.ts
+var _stringToIndex, _indexToString;
+var SharedStringManager = class {
+  constructor() {
+    /** Forward map: string value → index */
+    __privateAdd(this, _stringToIndex, /* @__PURE__ */ new Map());
+    /** Reverse map: index → string value */
+    __privateAdd(this, _indexToString, []);
+  }
+  // ── Public API ─────────────────────────────────────────────────────────────
+  /** Total number of unique strings. */
+  get count() {
+    return __privateGet(this, _indexToString).length;
+  }
+  /**
+   * Adds a string to the table (if not already present) and returns its index.
+   * O(1) average case.
+   */
+  addOrGet(value) {
+    const existing = __privateGet(this, _stringToIndex).get(value);
+    if (existing !== void 0) return existing;
+    const idx = __privateGet(this, _indexToString).length;
+    __privateGet(this, _indexToString).push(value);
+    __privateGet(this, _stringToIndex).set(value, idx);
+    return idx;
+  }
+  /**
+   * Returns the string at the given index.
+   * Throws if index is out of range.
+   */
+  getString(index) {
+    const s = __privateGet(this, _indexToString)[index];
+    if (s === void 0) {
+      throw new RangeError(
+        `Shared string index ${index} out of range [0, ${__privateGet(this, _indexToString).length - 1}].`
+      );
+    }
+    return s;
+  }
+  /**
+   * Returns the string at index, or undefined if not found.
+   * Safe alternative to getString().
+   */
+  tryGetString(index) {
+    return __privateGet(this, _indexToString)[index];
+  }
+  /** Returns true if the string is already in the table. */
+  has(value) {
+    return __privateGet(this, _stringToIndex).has(value);
+  }
+  // ── XML serialisation ──────────────────────────────────────────────────────
+  /**
+   * Builds the xl/sharedStrings.xml string.
+   */
+  buildXml() {
+    const count = __privateGet(this, _indexToString).length;
+    const items = __privateGet(this, _indexToString).map((s) => {
+      const preserveSpace = s.startsWith(" ") || s.endsWith(" ") ? ' xml:space="preserve"' : "";
+      return `<si><t${preserveSpace}>${escContent(s)}</t></si>`;
+    }).join("");
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="${count}" uniqueCount="${count}">
+${items}
+</sst>`;
+  }
+  /**
+   * Parses an existing xl/sharedStrings.xml and loads strings into the table.
+   */
+  loadFromXml(xml2) {
+    __privateGet(this, _stringToIndex).clear();
+    __privateGet(this, _indexToString).length = 0;
+    const root = parseXml(xml2);
+    for (const si of getElementsByTagName(root, "si")) {
+      const tNodes = getElementsByTagName(si, "t");
+      const text = tNodes.map((t) => t.textContent).join("");
+      this.addOrGet(text);
+    }
+  }
+};
+_stringToIndex = new WeakMap();
+_indexToString = new WeakMap();
+function escContent(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/style/excel-color.ts
+var _ExcelColor = class _ExcelColor {
+  constructor(opts) {
+    this.hex = opts.hex;
+    this.theme = opts.theme;
+    this.tint = opts.tint;
+    this.indexed = opts.indexed;
+  }
+  // ── Factory methods ────────────────────────────────────────────────────────
+  /**
+   * Creates a color from a hex string.
+   * Accepts "#RGB", "#RRGGBB", "RRGGBB", or "AARRGGBB" formats.
+   */
+  static fromHex(hex) {
+    if (!hex) throw new Error("Hex color cannot be empty.");
+    let h = hex.startsWith("#") ? hex.slice(1) : hex;
+    if (h.length === 3) {
+      h = `FF${h[0]}${h[0]}${h[1]}${h[1]}${h[2]}${h[2]}`;
+    } else if (h.length === 6) {
+      h = `FF${h}`;
+    } else if (h.length !== 8) {
+      throw new Error(
+        `Invalid hex color "${hex}". Expected 3, 6, or 8 hex characters (with optional # prefix).`
+      );
+    }
+    const upper = h.toUpperCase();
+    if (!/^[0-9A-F]{8}$/.test(upper)) {
+      throw new Error(`Invalid hex color "${hex}": contains non-hex characters.`);
+    }
+    return new _ExcelColor({ hex: upper });
+  }
+  /** Creates a color from RGB values (0–255). Alpha is set to 255 (opaque). */
+  static fromRgb(red, green, blue) {
+    return new _ExcelColor({
+      hex: `FF${byteHex(red)}${byteHex(green)}${byteHex(blue)}`
+    });
+  }
+  /** Creates a color from ARGB values (0–255). */
+  static fromArgb(alpha, red, green, blue) {
+    return new _ExcelColor({
+      hex: `${byteHex(alpha)}${byteHex(red)}${byteHex(green)}${byteHex(blue)}`
+    });
+  }
+  /** Creates a theme color with optional tint value (-1.0 to 1.0). */
+  static fromTheme(themeIndex, tint = 0) {
+    return new _ExcelColor({
+      theme: themeIndex,
+      tint: tint !== 0 ? tint : void 0
+    });
+  }
+  /** Creates an indexed color. */
+  static fromIndexed(index) {
+    return new _ExcelColor({ indexed: index });
+  }
+  // ── Serialisation ─────────────────────────────────────────────────────────
+  /** Returns XML attribute key-value pairs for embedding in OOXML elements. */
+  toXmlAttrs() {
+    if (this.hex !== void 0) return { rgb: this.hex };
+    if (this.theme !== void 0) {
+      const attrs = { theme: this.theme };
+      if (this.tint !== void 0) attrs.tint = this.tint;
+      return attrs;
+    }
+    if (this.indexed !== void 0) return { indexed: this.indexed };
+    return {};
+  }
+  /** Builds an XML color element string for use inside other elements. */
+  toXmlElement(tagName) {
+    const attrs = this.toXmlAttrs();
+    const parts = [];
+    if (attrs.rgb !== void 0) parts.push(`rgb="${attrs.rgb}"`);
+    if (attrs.theme !== void 0) parts.push(`theme="${attrs.theme}"`);
+    if (attrs.tint !== void 0) parts.push(`tint="${attrs.tint}"`);
+    if (attrs.indexed !== void 0) parts.push(`indexed="${attrs.indexed}"`);
+    return `<${tagName} ${parts.join(" ")}/>`;
+  }
+  /** Parses a color from OOXML XML attributes. Returns undefined if no color data. */
+  static fromXmlAttrs(attrs) {
+    const rgb = attrs["rgb"];
+    if (rgb) return _ExcelColor.fromHex(rgb);
+    const themeStr = attrs["theme"];
+    if (themeStr !== void 0) {
+      const tintStr = attrs["tint"];
+      return _ExcelColor.fromTheme(parseInt(themeStr, 10), tintStr ? parseFloat(tintStr) : 0);
+    }
+    const indexedStr = attrs["indexed"];
+    if (indexedStr !== void 0) return _ExcelColor.fromIndexed(parseInt(indexedStr, 10));
+    return void 0;
+  }
+  toString() {
+    if (this.hex !== void 0) return `#${this.hex}`;
+    if (this.theme !== void 0) return `Theme(${this.theme}${this.tint ? `,${this.tint}` : ""})`;
+    if (this.indexed !== void 0) return `Indexed(${this.indexed})`;
+    return "None";
+  }
+};
+// ── Predefined colors (camelCase, per TypeScript convention) ─────────────
+_ExcelColor.black = _ExcelColor.fromHex("FF000000");
+_ExcelColor.white = _ExcelColor.fromHex("FFFFFFFF");
+_ExcelColor.red = _ExcelColor.fromHex("FFFF0000");
+_ExcelColor.green = _ExcelColor.fromHex("FF00FF00");
+_ExcelColor.blue = _ExcelColor.fromHex("FF0000FF");
+_ExcelColor.yellow = _ExcelColor.fromHex("FFFFFF00");
+_ExcelColor.magenta = _ExcelColor.fromHex("FFFF00FF");
+_ExcelColor.cyan = _ExcelColor.fromHex("FF00FFFF");
+_ExcelColor.orange = _ExcelColor.fromHex("FFFF8C00");
+_ExcelColor.purple = _ExcelColor.fromHex("FF800080");
+_ExcelColor.darkRed = _ExcelColor.fromHex("FF8B0000");
+_ExcelColor.darkGreen = _ExcelColor.fromHex("FF006400");
+_ExcelColor.darkBlue = _ExcelColor.fromHex("FF00008B");
+_ExcelColor.lightGray = _ExcelColor.fromHex("FFD3D3D3");
+_ExcelColor.darkGray = _ExcelColor.fromHex("FFA9A9A9");
+_ExcelColor.gray = _ExcelColor.fromHex("FF808080");
+_ExcelColor.lightBlue = _ExcelColor.fromHex("FFADD8E6");
+_ExcelColor.lightGreen = _ExcelColor.fromHex("FF90EE90");
+_ExcelColor.lightYellow = _ExcelColor.fromHex("FFFFFFED");
+_ExcelColor.lightPink = _ExcelColor.fromHex("FFFFB6C1");
+_ExcelColor.transparent = _ExcelColor.fromArgb(0, 0, 0, 0);
+var ExcelColor = _ExcelColor;
+function byteHex(n) {
+  return Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0").toUpperCase();
+}
+
+// src/style/excel-font.ts
+var ExcelUnderline = /* @__PURE__ */ ((ExcelUnderline2) => {
+  ExcelUnderline2["None"] = "none";
+  ExcelUnderline2["Single"] = "single";
+  ExcelUnderline2["Double"] = "double";
+  ExcelUnderline2["SingleAccounting"] = "singleAccounting";
+  ExcelUnderline2["DoubleAccounting"] = "doubleAccounting";
+  return ExcelUnderline2;
+})(ExcelUnderline || {});
+var ExcelVerticalAlignRun = /* @__PURE__ */ ((ExcelVerticalAlignRun3) => {
+  ExcelVerticalAlignRun3["Baseline"] = "baseline";
+  ExcelVerticalAlignRun3["Superscript"] = "superscript";
+  ExcelVerticalAlignRun3["Subscript"] = "subscript";
+  return ExcelVerticalAlignRun3;
+})(ExcelVerticalAlignRun || {});
+var ExcelFont = class _ExcelFont {
+  constructor(opts = {}) {
+    Object.assign(this, opts);
+  }
+  // ── Serialisation ─────────────────────────────────────────────────────────
+  toXml() {
+    const parts = [];
+    if (this.bold) parts.push("<b/>");
+    if (this.italic) parts.push("<i/>");
+    if (this.strikethrough) parts.push("<strike/>");
+    if (this.underline && this.underline !== "none" /* None */) {
+      parts.push(`<u val="${this.underline}"/>`);
+    }
+    if (this.verticalAlign && this.verticalAlign !== "baseline" /* Baseline */) {
+      parts.push(`<vertAlign val="${this.verticalAlign}"/>`);
+    }
+    parts.push(`<sz val="${this.size ?? 11}"/>`);
+    if (this.color) {
+      parts.push(this.color.toXmlElement("color"));
+    } else {
+      parts.push('<color theme="1"/>');
+    }
+    parts.push(`<name val="${this.name ?? "Calibri"}"/>`);
+    return `<font>${parts.join("")}</font>`;
+  }
+  /** Parses font from parsed XML child elements. */
+  static fromXmlChildren(children) {
+    const font = new _ExcelFont();
+    for (const el of children) {
+      const tag = el.tagName.replace(/^.*:/, "");
+      switch (tag) {
+        case "b":
+          font.bold = true;
+          break;
+        case "i":
+          font.italic = true;
+          break;
+        case "strike":
+          font.strikethrough = true;
+          break;
+        case "sz":
+          font.size = parseFloat(el.attributes["val"] ?? "11");
+          break;
+        case "name":
+          font.name = el.attributes["val"];
+          break;
+        case "u": {
+          const val = el.attributes["val"] ?? "single";
+          font.underline = Object.values(ExcelUnderline).includes(val) ? val : "single" /* Single */;
+          break;
+        }
+        case "vertAlign": {
+          const val = el.attributes["val"] ?? "baseline";
+          font.verticalAlign = Object.values(ExcelVerticalAlignRun).includes(val) ? val : "baseline" /* Baseline */;
+          break;
+        }
+        case "color":
+          font.color = ExcelColor.fromXmlAttrs(el.attributes);
+          break;
+      }
+    }
+    return font;
+  }
+  /** Builds a canonical cache key for deduplication in StyleManager. */
+  cacheKey() {
+    return [
+      `n:${this.name ?? "Calibri"}`,
+      `s:${this.size ?? 11}`,
+      `b:${this.bold ?? false}`,
+      `i:${this.italic ?? false}`,
+      `u:${this.underline ?? "none" /* None */}`,
+      `st:${this.strikethrough ?? false}`,
+      `va:${this.verticalAlign ?? "baseline" /* Baseline */}`,
+      `c:${this.color?.toString() ?? "null"}`
+    ].join("|");
+  }
+  clone() {
+    return new _ExcelFont({
+      name: this.name,
+      size: this.size,
+      bold: this.bold,
+      italic: this.italic,
+      underline: this.underline,
+      strikethrough: this.strikethrough,
+      color: this.color,
+      verticalAlign: this.verticalAlign
+    });
+  }
+};
+
+// src/style/excel-fill.ts
+var ExcelPatternType = /* @__PURE__ */ ((ExcelPatternType3) => {
+  ExcelPatternType3["None"] = "none";
+  ExcelPatternType3["Solid"] = "solid";
+  ExcelPatternType3["DarkGray"] = "darkGray";
+  ExcelPatternType3["MediumGray"] = "mediumGray";
+  ExcelPatternType3["LightGray"] = "lightGray";
+  ExcelPatternType3["Gray125"] = "gray125";
+  ExcelPatternType3["Gray0625"] = "gray0625";
+  ExcelPatternType3["DarkHorizontal"] = "darkHorizontal";
+  ExcelPatternType3["DarkVertical"] = "darkVertical";
+  ExcelPatternType3["DarkDown"] = "darkDown";
+  ExcelPatternType3["DarkUp"] = "darkUp";
+  ExcelPatternType3["DarkGrid"] = "darkGrid";
+  ExcelPatternType3["DarkTrellis"] = "darkTrellis";
+  ExcelPatternType3["LightHorizontal"] = "lightHorizontal";
+  ExcelPatternType3["LightVertical"] = "lightVertical";
+  ExcelPatternType3["LightDown"] = "lightDown";
+  ExcelPatternType3["LightUp"] = "lightUp";
+  ExcelPatternType3["LightGrid"] = "lightGrid";
+  ExcelPatternType3["LightTrellis"] = "lightTrellis";
+  return ExcelPatternType3;
+})(ExcelPatternType || {});
+var _ExcelFill = class _ExcelFill {
+  constructor(patternType = "none" /* None */, foregroundColor, backgroundColor) {
+    this.patternType = patternType;
+    this.foregroundColor = foregroundColor;
+    this.backgroundColor = backgroundColor;
+  }
+  // ── Factory methods ────────────────────────────────────────────────────────
+  /**
+   * Creates a solid fill with the given color.
+   * Excel requires the magic indexed(64) background color for solid fills.
+   */
+  static solid(color) {
+    return new _ExcelFill(
+      "solid" /* Solid */,
+      color,
+      ExcelColor.fromIndexed(64)
+      // required by Excel spec
+    );
+  }
+  /** Creates a pattern fill. */
+  static pattern(pattern, foreground, background) {
+    return new _ExcelFill(pattern, foreground, background);
+  }
+  // ── Serialisation ─────────────────────────────────────────────────────────
+  toXml() {
+    let inner = `<patternFill patternType="${this.patternType}">`;
+    if (this.foregroundColor) {
+      const attrs = this.foregroundColor.toXmlAttrs();
+      const parts = [];
+      if (attrs.rgb) parts.push(`rgb="${attrs.rgb}"`);
+      if (attrs.theme !== void 0) parts.push(`theme="${attrs.theme}"`);
+      if (attrs.tint !== void 0) parts.push(`tint="${attrs.tint}"`);
+      if (attrs.indexed !== void 0) parts.push(`indexed="${attrs.indexed}"`);
+      inner += `<fgColor ${parts.join(" ")}/>`;
+    }
+    if (this.backgroundColor) {
+      const attrs = this.backgroundColor.toXmlAttrs();
+      const parts = [];
+      if (attrs.rgb) parts.push(`rgb="${attrs.rgb}"`);
+      if (attrs.theme !== void 0) parts.push(`theme="${attrs.theme}"`);
+      if (attrs.tint !== void 0) parts.push(`tint="${attrs.tint}"`);
+      if (attrs.indexed !== void 0) parts.push(`indexed="${attrs.indexed}"`);
+      inner += `<bgColor ${parts.join(" ")}/>`;
+    }
+    inner += "</patternFill>";
+    return `<fill>${inner}</fill>`;
+  }
+  static fromXmlChildren(children) {
+    const fill = new _ExcelFill();
+    for (const el of children) {
+      const tag = el.tagName.replace(/^.*:/, "");
+      if (tag === "patternFill") {
+        const pt = el.attributes["patternType"];
+        if (pt && Object.values(ExcelPatternType).includes(pt)) {
+          fill.patternType = pt;
+        }
+        for (const child of el.children) {
+          const ctag = child.tagName.replace(/^.*:/, "");
+          const color = ExcelColor.fromXmlAttrs(child.attributes);
+          if (ctag === "fgColor" && color) fill.foregroundColor = color;
+          if (ctag === "bgColor" && color) fill.backgroundColor = color;
+        }
+      }
+    }
+    return fill;
+  }
+  cacheKey() {
+    return [
+      `p:${this.patternType}`,
+      `fg:${this.foregroundColor?.toString() ?? "null"}`,
+      `bg:${this.backgroundColor?.toString() ?? "null"}`
+    ].join("|");
+  }
+};
+/** No fill (default). */
+_ExcelFill.none = new _ExcelFill("none" /* None */);
+var ExcelFill = _ExcelFill;
+
+// src/style/excel-border.ts
+var ExcelBorderStyle = /* @__PURE__ */ ((ExcelBorderStyle3) => {
+  ExcelBorderStyle3["None"] = "none";
+  ExcelBorderStyle3["Thin"] = "thin";
+  ExcelBorderStyle3["Medium"] = "medium";
+  ExcelBorderStyle3["Thick"] = "thick";
+  ExcelBorderStyle3["Dashed"] = "dashed";
+  ExcelBorderStyle3["Dotted"] = "dotted";
+  ExcelBorderStyle3["Double"] = "double";
+  ExcelBorderStyle3["Hair"] = "hair";
+  ExcelBorderStyle3["MediumDashed"] = "mediumDashed";
+  ExcelBorderStyle3["DashDot"] = "dashDot";
+  ExcelBorderStyle3["MediumDashDot"] = "mediumDashDot";
+  ExcelBorderStyle3["DashDotDot"] = "dashDotDot";
+  ExcelBorderStyle3["MediumDashDotDot"] = "mediumDashDotDot";
+  ExcelBorderStyle3["SlantDashDot"] = "slantDashDot";
+  return ExcelBorderStyle3;
+})(ExcelBorderStyle || {});
+var ExcelBorderEdge = class _ExcelBorderEdge {
+  constructor(style = "none" /* None */, color) {
+    this.style = style;
+    this.color = color;
+  }
+  toXml(tag) {
+    if (this.style === "none" /* None */) return `<${tag}/>`;
+    let inner = "";
+    if (this.color) inner = this.color.toXmlElement("color");
+    return `<${tag} style="${this.style}">${inner}</${tag}>`;
+  }
+  static fromXmlElement(el) {
+    const styleStr = el.attributes["style"] ?? "none";
+    const style = Object.values(ExcelBorderStyle).includes(styleStr) ? styleStr : "none" /* None */;
+    let color;
+    for (const child of el.children) {
+      const tag = child.tagName.replace(/^.*:/, "");
+      if (tag === "color") {
+        color = ExcelColor.fromXmlAttrs(child.attributes) ?? void 0;
+      }
+    }
+    return new _ExcelBorderEdge(style, color);
+  }
+  cacheKey() {
+    return `${this.style}:${this.color?.toString() ?? "null"}`;
+  }
+};
+var _ExcelBorder = class _ExcelBorder {
+  constructor() {
+    this.left = new ExcelBorderEdge();
+    this.right = new ExcelBorderEdge();
+    this.top = new ExcelBorderEdge();
+    this.bottom = new ExcelBorderEdge();
+    this.diagonal = new ExcelBorderEdge();
+    this.diagonalDown = false;
+    this.diagonalUp = false;
+  }
+  // ── Factory methods ────────────────────────────────────────────────────────
+  /** Sets all four sides to the same style and color. */
+  static box(style, color) {
+    const b = new _ExcelBorder();
+    b.left = new ExcelBorderEdge(style, color);
+    b.right = new ExcelBorderEdge(style, color);
+    b.top = new ExcelBorderEdge(style, color);
+    b.bottom = new ExcelBorderEdge(style, color);
+    return b;
+  }
+  static bottomOnly(style, color) {
+    const b = new _ExcelBorder();
+    b.bottom = new ExcelBorderEdge(style, color);
+    return b;
+  }
+  static topOnly(style, color) {
+    const b = new _ExcelBorder();
+    b.top = new ExcelBorderEdge(style, color);
+    return b;
+  }
+  static leftOnly(style, color) {
+    const b = new _ExcelBorder();
+    b.left = new ExcelBorderEdge(style, color);
+    return b;
+  }
+  static rightOnly(style, color) {
+    const b = new _ExcelBorder();
+    b.right = new ExcelBorderEdge(style, color);
+    return b;
+  }
+  // ── Serialisation ─────────────────────────────────────────────────────────
+  toXml() {
+    const dd = this.diagonalDown ? ' diagonalDown="1"' : "";
+    const du = this.diagonalUp ? ' diagonalUp="1"' : "";
+    return `<border${dd}${du}>${this.left.toXml("left")}${this.right.toXml("right")}${this.top.toXml("top")}${this.bottom.toXml("bottom")}${this.diagonal.toXml("diagonal")}</border>`;
+  }
+  static fromXmlChildren(children, borderAttrs) {
+    const b = new _ExcelBorder();
+    b.diagonalDown = borderAttrs["diagonalDown"] === "1";
+    b.diagonalUp = borderAttrs["diagonalUp"] === "1";
+    for (const el of children) {
+      const tag = el.tagName.replace(/^.*:/, "");
+      const edge = ExcelBorderEdge.fromXmlElement(el);
+      switch (tag) {
+        case "left":
+          b.left = edge;
+          break;
+        case "right":
+          b.right = edge;
+          break;
+        case "top":
+          b.top = edge;
+          break;
+        case "bottom":
+          b.bottom = edge;
+          break;
+        case "diagonal":
+          b.diagonal = edge;
+          break;
+      }
+    }
+    return b;
+  }
+  cacheKey() {
+    return [
+      `l:${this.left.cacheKey()}`,
+      `r:${this.right.cacheKey()}`,
+      `t:${this.top.cacheKey()}`,
+      `b:${this.bottom.cacheKey()}`,
+      `d:${this.diagonal.cacheKey()}`,
+      `dd:${this.diagonalDown}`,
+      `du:${this.diagonalUp}`
+    ].join("|");
+  }
+};
+_ExcelBorder.none = new _ExcelBorder();
+var ExcelBorder = _ExcelBorder;
+
+// src/style/excel-alignment.ts
+var ExcelHorizontalAlignment = /* @__PURE__ */ ((ExcelHorizontalAlignment3) => {
+  ExcelHorizontalAlignment3["General"] = "general";
+  ExcelHorizontalAlignment3["Left"] = "left";
+  ExcelHorizontalAlignment3["Center"] = "center";
+  ExcelHorizontalAlignment3["Right"] = "right";
+  ExcelHorizontalAlignment3["Fill"] = "fill";
+  ExcelHorizontalAlignment3["Justify"] = "justify";
+  ExcelHorizontalAlignment3["CenterContinuous"] = "centerContinuous";
+  ExcelHorizontalAlignment3["Distributed"] = "distributed";
+  return ExcelHorizontalAlignment3;
+})(ExcelHorizontalAlignment || {});
+var ExcelVerticalAlignment = /* @__PURE__ */ ((ExcelVerticalAlignment3) => {
+  ExcelVerticalAlignment3["Top"] = "top";
+  ExcelVerticalAlignment3["Center"] = "center";
+  ExcelVerticalAlignment3["Bottom"] = "bottom";
+  ExcelVerticalAlignment3["Justify"] = "justify";
+  ExcelVerticalAlignment3["Distributed"] = "distributed";
+  return ExcelVerticalAlignment3;
+})(ExcelVerticalAlignment || {});
+var ExcelReadingOrder = /* @__PURE__ */ ((ExcelReadingOrder2) => {
+  ExcelReadingOrder2[ExcelReadingOrder2["ContextDependent"] = 0] = "ContextDependent";
+  ExcelReadingOrder2[ExcelReadingOrder2["LeftToRight"] = 1] = "LeftToRight";
+  ExcelReadingOrder2[ExcelReadingOrder2["RightToLeft"] = 2] = "RightToLeft";
+  return ExcelReadingOrder2;
+})(ExcelReadingOrder || {});
+var ExcelAlignment = class _ExcelAlignment {
+  toXml() {
+    const parts = [];
+    if (this.horizontal) parts.push(`horizontal="${this.horizontal}"`);
+    if (this.vertical) parts.push(`vertical="${this.vertical}"`);
+    if (this.wrapText) parts.push('wrapText="1"');
+    if (this.shrinkToFit) parts.push('shrinkToFit="1"');
+    if (this.textRotation !== void 0) parts.push(`textRotation="${this.textRotation}"`);
+    if (this.indent !== void 0) parts.push(`indent="${this.indent}"`);
+    if (this.readingOrder !== void 0) parts.push(`readingOrder="${this.readingOrder}"`);
+    if (parts.length === 0) return "";
+    return `<alignment ${parts.join(" ")}/>`;
+  }
+  static fromXmlAttrs(attrs) {
+    const a = new _ExcelAlignment();
+    const h = attrs["horizontal"];
+    const v = attrs["vertical"];
+    if (h && Object.values(ExcelHorizontalAlignment).includes(h)) {
+      a.horizontal = h;
+    }
+    if (v && Object.values(ExcelVerticalAlignment).includes(v)) {
+      a.vertical = v;
+    }
+    if (attrs["wrapText"] === "1" || attrs["wrapText"] === "true") a.wrapText = true;
+    if (attrs["shrinkToFit"] === "1" || attrs["shrinkToFit"] === "true") a.shrinkToFit = true;
+    if (attrs["textRotation"] !== void 0) a.textRotation = parseInt(attrs["textRotation"], 10);
+    if (attrs["indent"] !== void 0) a.indent = parseInt(attrs["indent"], 10);
+    if (attrs["readingOrder"] !== void 0) a.readingOrder = parseInt(attrs["readingOrder"], 10);
+    return a;
+  }
+  cacheKey() {
+    return [
+      `h:${this.horizontal ?? ""}`,
+      `v:${this.vertical ?? ""}`,
+      `w:${this.wrapText ?? false}`,
+      `s:${this.shrinkToFit ?? false}`,
+      `r:${this.textRotation ?? 0}`,
+      `i:${this.indent ?? 0}`,
+      `ro:${this.readingOrder ?? 0}`
+    ].join("|");
+  }
+};
+
+// src/style/excel-number-format.ts
+var BUILT_IN_FORMAT_CODES = {
+  0: "General",
+  1: "0",
+  2: "0.00",
+  3: "#,##0",
+  4: "#,##0.00",
+  5: "$#,##0_);($#,##0)",
+  6: "$#,##0_);[Red]($#,##0)",
+  7: "$#,##0.00_);($#,##0.00)",
+  8: "$#,##0.00_);[Red]($#,##0.00)",
+  9: "0%",
+  10: "0.00%",
+  11: "0.00E+00",
+  12: "# ?/?",
+  13: "# ??/??",
+  14: "mm-dd-yy",
+  15: "d-mmm-yy",
+  16: "d-mmm",
+  17: "mmm-yy",
+  18: "h:mm AM/PM",
+  19: "h:mm:ss AM/PM",
+  20: "h:mm",
+  21: "h:mm:ss",
+  22: "m/d/yy h:mm",
+  37: "#,##0 ;(#,##0)",
+  38: "#,##0 ;[Red](#,##0)",
+  39: "#,##0.00;(#,##0.00)",
+  40: "#,##0.00;[Red](#,##0.00)",
+  45: "mm:ss",
+  46: "[h]:mm:ss",
+  47: "mmss.0",
+  48: "##0.0E+0",
+  49: "@"
+};
+var CODE_TO_BUILT_IN_ID = new Map(
+  Object.entries(BUILT_IN_FORMAT_CODES).map(([id, code]) => [code, Number(id)])
+);
+var _ExcelNumberFormat = class _ExcelNumberFormat {
+  constructor(formatCode, formatId) {
+    this.formatCode = formatCode;
+    this.formatId = formatId;
+  }
+  // ── Factory methods ────────────────────────────────────────────────────────
+  /** Creates a number format from a custom format code string. */
+  static custom(formatCode) {
+    if (!formatCode) throw new Error("Format code cannot be empty.");
+    const builtInId = CODE_TO_BUILT_IN_ID.get(formatCode);
+    if (builtInId !== void 0) {
+      return new _ExcelNumberFormat(formatCode, builtInId);
+    }
+    return new _ExcelNumberFormat(formatCode, 0);
+  }
+  /** Creates from format ID and optional custom formats map. */
+  static fromFormatId(formatId, customFormats) {
+    if (customFormats && formatId >= 164) {
+      const code2 = customFormats.get(formatId);
+      if (code2) return new _ExcelNumberFormat(code2, formatId);
+    }
+    const code = BUILT_IN_FORMAT_CODES[formatId] ?? "General";
+    return new _ExcelNumberFormat(code, formatId);
+  }
+  /** Returns true if this format code represents a date/time value. */
+  isDateFormat() {
+    const id = this.formatId;
+    if (id >= 14 && id <= 22 || id >= 45 && id <= 47) return true;
+    const lower = this.formatCode.toLowerCase();
+    return lower.includes("y") || lower.includes("d") || lower.includes("m") && !lower.startsWith("mm:") && !lower.startsWith("[") || lower.includes("h") && !lower.startsWith("[h]");
+  }
+  toString() {
+    return this.formatCode;
+  }
+};
+// ── Predefined formats (camelCase, per TypeScript convention) ─────────────
+_ExcelNumberFormat.general = new _ExcelNumberFormat("General", 0);
+_ExcelNumberFormat.integer = new _ExcelNumberFormat("0", 1);
+_ExcelNumberFormat.decimal2 = new _ExcelNumberFormat("0.00", 2);
+_ExcelNumberFormat.thousandsSeparator = new _ExcelNumberFormat("#,##0", 3);
+_ExcelNumberFormat.thousandsDecimal2 = new _ExcelNumberFormat("#,##0.00", 4);
+_ExcelNumberFormat.percentage = new _ExcelNumberFormat("0%", 9);
+_ExcelNumberFormat.percentageDecimal2 = new _ExcelNumberFormat("0.00%", 10);
+_ExcelNumberFormat.scientific = new _ExcelNumberFormat("0.00E+00", 11);
+_ExcelNumberFormat.fraction = new _ExcelNumberFormat("# ?/?", 12);
+_ExcelNumberFormat.fractionTwoDigits = new _ExcelNumberFormat("# ??/??", 13);
+_ExcelNumberFormat.shortDate = new _ExcelNumberFormat("mm-dd-yy", 14);
+_ExcelNumberFormat.longDate = new _ExcelNumberFormat("d-mmm-yy", 15);
+_ExcelNumberFormat.dayMonth = new _ExcelNumberFormat("d-mmm", 16);
+_ExcelNumberFormat.monthYear = new _ExcelNumberFormat("mmm-yy", 17);
+_ExcelNumberFormat.time12h = new _ExcelNumberFormat("h:mm AM/PM", 18);
+_ExcelNumberFormat.time12hSeconds = new _ExcelNumberFormat("h:mm:ss AM/PM", 19);
+_ExcelNumberFormat.time24h = new _ExcelNumberFormat("h:mm", 20);
+_ExcelNumberFormat.time24hSeconds = new _ExcelNumberFormat("h:mm:ss", 21);
+_ExcelNumberFormat.dateTime = new _ExcelNumberFormat("m/d/yy h:mm", 22);
+_ExcelNumberFormat.accounting = new _ExcelNumberFormat("#,##0 ;(#,##0)", 37);
+_ExcelNumberFormat.accountingRed = new _ExcelNumberFormat("#,##0 ;[Red](#,##0)", 38);
+_ExcelNumberFormat.accountingDecimal2 = new _ExcelNumberFormat("#,##0.00;(#,##0.00)", 39);
+_ExcelNumberFormat.text = new _ExcelNumberFormat("@", 49);
+_ExcelNumberFormat.currency = _ExcelNumberFormat.custom("$#,##0.00");
+_ExcelNumberFormat.currencyNoDecimal = _ExcelNumberFormat.custom("$#,##0");
+_ExcelNumberFormat.isoDate = _ExcelNumberFormat.custom("yyyy-mm-dd");
+_ExcelNumberFormat.isoDateTime = _ExcelNumberFormat.custom("yyyy-mm-dd hh:mm:ss");
+_ExcelNumberFormat.phoneNumber = _ExcelNumberFormat.custom("[<=9999999]###-####;(###) ###-####");
+_ExcelNumberFormat.zipCode = _ExcelNumberFormat.custom("00000");
+var ExcelNumberFormat = _ExcelNumberFormat;
+
+// src/style/cell-style.ts
+var _CellStyle_instances, ensureFont_fn, ensureBorder_fn, ensureAlignment_fn;
+var _CellStyle = class _CellStyle {
+  constructor() {
+    __privateAdd(this, _CellStyle_instances);
+  }
+  // ── Font fluent API ────────────────────────────────────────────────────────
+  setFontName(name) {
+    __privateMethod(this, _CellStyle_instances, ensureFont_fn).call(this).name = name;
+    return this;
+  }
+  setFontSize(size) {
+    __privateMethod(this, _CellStyle_instances, ensureFont_fn).call(this).size = size;
+    return this;
+  }
+  setBold(bold = true) {
+    __privateMethod(this, _CellStyle_instances, ensureFont_fn).call(this).bold = bold;
+    return this;
+  }
+  setItalic(italic = true) {
+    __privateMethod(this, _CellStyle_instances, ensureFont_fn).call(this).italic = italic;
+    return this;
+  }
+  setUnderline(underline = "single" /* Single */) {
+    __privateMethod(this, _CellStyle_instances, ensureFont_fn).call(this).underline = underline;
+    return this;
+  }
+  setStrikethrough(strikethrough = true) {
+    __privateMethod(this, _CellStyle_instances, ensureFont_fn).call(this).strikethrough = strikethrough;
+    return this;
+  }
+  setFontColor(colorOrHex) {
+    __privateMethod(this, _CellStyle_instances, ensureFont_fn).call(this).color = typeof colorOrHex === "string" ? ExcelColor.fromHex(colorOrHex) : colorOrHex;
+    return this;
+  }
+  setVerticalAlign(align) {
+    __privateMethod(this, _CellStyle_instances, ensureFont_fn).call(this).verticalAlign = align;
+    return this;
+  }
+  setBackgroundColor(colorOrHex) {
+    const color = typeof colorOrHex === "string" ? ExcelColor.fromHex(colorOrHex) : colorOrHex;
+    this.fill = ExcelFill.solid(color);
+    return this;
+  }
+  setPatternFill(pattern, foreground, background) {
+    this.fill = ExcelFill.pattern(pattern, foreground, background);
+    return this;
+  }
+  // ── Border fluent API ──────────────────────────────────────────────────────
+  setAllBorders(style, color) {
+    this.border = ExcelBorder.box(style, color);
+    return this;
+  }
+  setBorder(border) {
+    this.border = border;
+    return this;
+  }
+  setLeftBorder(style, color) {
+    __privateMethod(this, _CellStyle_instances, ensureBorder_fn).call(this).left = new ExcelBorderEdge(style, color);
+    return this;
+  }
+  setRightBorder(style, color) {
+    __privateMethod(this, _CellStyle_instances, ensureBorder_fn).call(this).right = new ExcelBorderEdge(style, color);
+    return this;
+  }
+  setTopBorder(style, color) {
+    __privateMethod(this, _CellStyle_instances, ensureBorder_fn).call(this).top = new ExcelBorderEdge(style, color);
+    return this;
+  }
+  setBottomBorder(style, color) {
+    __privateMethod(this, _CellStyle_instances, ensureBorder_fn).call(this).bottom = new ExcelBorderEdge(style, color);
+    return this;
+  }
+  // ── Alignment fluent API ───────────────────────────────────────────────────
+  setHorizontalAlignment(alignment) {
+    __privateMethod(this, _CellStyle_instances, ensureAlignment_fn).call(this).horizontal = alignment;
+    return this;
+  }
+  setVerticalAlignment(alignment) {
+    __privateMethod(this, _CellStyle_instances, ensureAlignment_fn).call(this).vertical = alignment;
+    return this;
+  }
+  setWrapText(wrap = true) {
+    __privateMethod(this, _CellStyle_instances, ensureAlignment_fn).call(this).wrapText = wrap;
+    return this;
+  }
+  setShrinkToFit(shrink = true) {
+    __privateMethod(this, _CellStyle_instances, ensureAlignment_fn).call(this).shrinkToFit = shrink;
+    return this;
+  }
+  setTextRotation(degrees) {
+    __privateMethod(this, _CellStyle_instances, ensureAlignment_fn).call(this).textRotation = degrees;
+    return this;
+  }
+  setIndent(indent) {
+    __privateMethod(this, _CellStyle_instances, ensureAlignment_fn).call(this).indent = indent;
+    return this;
+  }
+  setNumberFormat(formatOrCode) {
+    this.numberFormat = typeof formatOrCode === "string" ? ExcelNumberFormat.custom(formatOrCode) : formatOrCode;
+    return this;
+  }
+  // ── Protection fluent API ──────────────────────────────────────────────────
+  setLocked(locked = true) {
+    this.isLocked = locked;
+    return this;
+  }
+  setFormulaHidden(hidden = true) {
+    this.isHidden = hidden;
+    return this;
+  }
+  // ── Helpers ────────────────────────────────────────────────────────────────
+  /** Creates a deep copy of this style. */
+  clone() {
+    const s = new _CellStyle();
+    if (this.font) s.font = this.font.clone();
+    s.fill = this.fill;
+    s.border = this.border;
+    s.alignment = this.alignment ? Object.assign(new ExcelAlignment(), this.alignment) : void 0;
+    s.numberFormat = this.numberFormat;
+    s.isLocked = this.isLocked;
+    s.isHidden = this.isHidden;
+    return s;
+  }
+};
+_CellStyle_instances = new WeakSet();
+ensureFont_fn = function() {
+  if (!this.font) this.font = new ExcelFont();
+  return this.font;
+};
+ensureBorder_fn = function() {
+  if (!this.border) this.border = new ExcelBorder();
+  return this.border;
+};
+ensureAlignment_fn = function() {
+  if (!this.alignment) this.alignment = new ExcelAlignment();
+  return this.alignment;
+};
+var CellStyle = _CellStyle;
+
+// src/style/style-manager.ts
+var _StyleManager_instances, initDefaults_fn, getOrCreateFont_fn, getOrCreateFill_fn, getOrCreateBorder_fn, getOrCreateNumFmt_fn, cellFormatKey_fn, cfToXml_fn;
+var StyleManager = class {
+  constructor() {
+    __privateAdd(this, _StyleManager_instances);
+    // Index arrays — position = index
+    this.fonts = [];
+    this.fills = [];
+    this.borders = [];
+    this.numFmts = [];
+    this.cellXfs = [];
+    // Dedup caches: key → index
+    this.fontCache = /* @__PURE__ */ new Map();
+    this.fillCache = /* @__PURE__ */ new Map();
+    this.borderCache = /* @__PURE__ */ new Map();
+    this.numFmtCache = /* @__PURE__ */ new Map();
+    // code → id
+    this.cellXfCache = /* @__PURE__ */ new Map();
+    this.nextCustomNumFmtId = 164;
+    this.isDirty = false;
+    __privateMethod(this, _StyleManager_instances, initDefaults_fn).call(this);
+  }
+  // ── Public API ─────────────────────────────────────────────────────────────
+  /**
+   * Returns the cellXf index for the given CellStyle.
+   * Creates new font/fill/border entries as needed (with deduplication).
+   */
+  getOrCreateCellFormatIndex(style) {
+    const fontId = style.font ? __privateMethod(this, _StyleManager_instances, getOrCreateFont_fn).call(this, style.font) : 0;
+    const fillId = style.fill ? __privateMethod(this, _StyleManager_instances, getOrCreateFill_fn).call(this, style.fill) : 0;
+    const borderId = style.border ? __privateMethod(this, _StyleManager_instances, getOrCreateBorder_fn).call(this, style.border) : 0;
+    const numFmtId = style.numberFormat ? __privateMethod(this, _StyleManager_instances, getOrCreateNumFmt_fn).call(this, style.numberFormat) : 0;
+    const cf = {
+      fontId,
+      fillId,
+      borderId,
+      numFmtId,
+      applyFont: style.font != null,
+      applyFill: style.fill != null,
+      applyBorder: style.border != null,
+      applyNumFmt: style.numberFormat != null,
+      alignment: style.alignment,
+      applyAlign: style.alignment != null,
+      isLocked: style.isLocked,
+      isHidden: style.isHidden,
+      applyProt: style.isLocked != null || style.isHidden != null
+    };
+    const key = __privateMethod(this, _StyleManager_instances, cellFormatKey_fn).call(this, cf);
+    const existing = this.cellXfCache.get(key);
+    if (existing !== void 0) return existing;
+    const idx = this.cellXfs.length;
+    this.cellXfs.push(cf);
+    this.cellXfCache.set(key, idx);
+    this.isDirty = true;
+    return idx;
+  }
+  /**
+   * Reconstructs a CellStyle from a cellXf index.
+   * Used by Cell.style getter.
+   */
+  getCellStyle(styleIndex) {
+    const cf = this.cellXfs[styleIndex];
+    if (!cf) return new CellStyle();
+    const s = new CellStyle();
+    const fontEntry = this.fonts[cf.fontId];
+    if (fontEntry && cf.applyFont) s.font = fontEntry.font;
+    const fillEntry = this.fills[cf.fillId];
+    if (fillEntry && cf.applyFill) s.fill = fillEntry.fill;
+    const borderEntry = this.borders[cf.borderId];
+    if (borderEntry && cf.applyBorder) s.border = borderEntry.border;
+    if (cf.applyNumFmt) {
+      const customMap = new Map(
+        this.numFmts.map((n) => [n.id, n.code])
+      );
+      s.numberFormat = ExcelNumberFormat.fromFormatId(cf.numFmtId, customMap);
+    }
+    if (cf.alignment && cf.applyAlign) s.alignment = cf.alignment;
+    if (cf.applyProt) {
+      s.isLocked = cf.isLocked;
+      s.isHidden = cf.isHidden;
+    }
+    return s;
+  }
+  // ── XML serialisation ──────────────────────────────────────────────────────
+  /** Builds the complete xl/styles.xml string. */
+  buildStylesXml() {
+    const numFmtsXml = this.numFmts.length > 0 ? `<numFmts count="${this.numFmts.length}">${this.numFmts.map((n) => `<numFmt numFmtId="${n.id}" formatCode="${escAttr(n.code)}"/>`).join("")}</numFmts>` : "";
+    const fontsXml = `<fonts count="${this.fonts.length}">${this.fonts.map((f) => f.font.toXml()).join("")}</fonts>`;
+    const fillsXml = `<fills count="${this.fills.length}">${this.fills.map((f) => f.fill.toXml()).join("")}</fills>`;
+    const bordersXml = `<borders count="${this.borders.length}">${this.borders.map((b) => b.border.toXml()).join("")}</borders>`;
+    const cellXfsXml = `<cellXfs count="${this.cellXfs.length}">${this.cellXfs.map((cf) => __privateMethod(this, _StyleManager_instances, cfToXml_fn).call(this, cf)).join("")}</cellXfs>`;
+    this.isDirty = false;
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+${numFmtsXml}${fontsXml}${fillsXml}${bordersXml}
+<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>
+${cellXfsXml}
+</styleSheet>`;
+  }
+  /** Loads an existing styles.xml, rebuilding all caches. */
+  loadFromXml(stylesXml) {
+    this.fonts = [];
+    this.fills = [];
+    this.borders = [];
+    this.numFmts = [];
+    this.cellXfs = [];
+    this.fontCache.clear();
+    this.fillCache.clear();
+    this.borderCache.clear();
+    this.numFmtCache.clear();
+    this.cellXfCache.clear();
+    this.nextCustomNumFmtId = 164;
+    const root = parseXml(stylesXml);
+    for (const el of getElementsByTagName(root, "numFmt")) {
+      const id = parseInt(getAttr(el, "numFmtId") ?? "0", 10);
+      const code = getAttr(el, "formatCode") ?? "";
+      this.numFmts.push({ id, code });
+      this.numFmtCache.set(code, id);
+      if (id >= this.nextCustomNumFmtId) this.nextCustomNumFmtId = id + 1;
+    }
+    for (const el of getElementsByTagName(root, "fonts")) {
+      for (const fontEl of el.children) {
+        const font = ExcelFont.fromXmlChildren(fontEl.children);
+        const key = font.cacheKey();
+        this.fonts.push({ font, key });
+        this.fontCache.set(key, this.fonts.length - 1);
+      }
+    }
+    for (const el of getElementsByTagName(root, "fills")) {
+      for (const fillEl of el.children) {
+        const fill = ExcelFill.fromXmlChildren(fillEl.children);
+        const key = fill.cacheKey();
+        this.fills.push({ fill, key });
+        this.fillCache.set(key, this.fills.length - 1);
+      }
+    }
+    for (const el of getElementsByTagName(root, "borders")) {
+      for (const borderEl of el.children) {
+        const border = ExcelBorder.fromXmlChildren(
+          borderEl.children,
+          borderEl.attributes
+        );
+        const key = border.cacheKey();
+        this.borders.push({ border, key });
+        this.borderCache.set(key, this.borders.length - 1);
+      }
+    }
+    for (const el of getElementsByTagName(root, "cellXfs")) {
+      for (const xfEl of el.children) {
+        const cf = {
+          fontId: parseInt(getAttr(xfEl, "fontId") ?? "0", 10),
+          fillId: parseInt(getAttr(xfEl, "fillId") ?? "0", 10),
+          borderId: parseInt(getAttr(xfEl, "borderId") ?? "0", 10),
+          numFmtId: parseInt(getAttr(xfEl, "numFmtId") ?? "0", 10),
+          applyFont: getAttr(xfEl, "applyFont") === "1",
+          applyFill: getAttr(xfEl, "applyFill") === "1",
+          applyBorder: getAttr(xfEl, "applyBorder") === "1",
+          applyNumFmt: getAttr(xfEl, "applyNumberFormat") === "1",
+          applyAlign: getAttr(xfEl, "applyAlignment") === "1",
+          applyProt: getAttr(xfEl, "applyProtection") === "1"
+        };
+        const alignEl = xfEl.children.find((c) => c.tagName.replace(/^.*:/, "") === "alignment");
+        if (alignEl) cf.alignment = ExcelAlignment.fromXmlAttrs(alignEl.attributes);
+        const key = __privateMethod(this, _StyleManager_instances, cellFormatKey_fn).call(this, cf);
+        this.cellXfs.push(cf);
+        this.cellXfCache.set(key, this.cellXfs.length - 1);
+      }
+    }
+    if (this.fonts.length === 0) __privateMethod(this, _StyleManager_instances, initDefaults_fn).call(this);
+    if (this.cellXfs.length === 0) __privateMethod(this, _StyleManager_instances, initDefaults_fn).call(this);
+  }
+};
+_StyleManager_instances = new WeakSet();
+// ── Private helpers ────────────────────────────────────────────────────────
+initDefaults_fn = function() {
+  const defaultFont = new ExcelFont({ name: "Calibri", size: 11 });
+  const fontKey = defaultFont.cacheKey();
+  this.fonts = [{ font: defaultFont, key: fontKey }];
+  this.fontCache.set(fontKey, 0);
+  const noneFill = new ExcelFill("none" /* None */);
+  const grayFill = new ExcelFill("gray125" /* Gray125 */);
+  this.fills = [
+    { fill: noneFill, key: noneFill.cacheKey() },
+    { fill: grayFill, key: grayFill.cacheKey() }
+  ];
+  this.fillCache.set(noneFill.cacheKey(), 0);
+  this.fillCache.set(grayFill.cacheKey(), 1);
+  const defaultBorder = new ExcelBorder();
+  const borderKey = defaultBorder.cacheKey();
+  this.borders = [{ border: defaultBorder, key: borderKey }];
+  this.borderCache.set(borderKey, 0);
+  const defaultCf = {
+    fontId: 0,
+    fillId: 0,
+    borderId: 0,
+    numFmtId: 0,
+    applyFont: false,
+    applyFill: false,
+    applyBorder: false,
+    applyNumFmt: false,
+    applyAlign: false,
+    applyProt: false
+  };
+  const cfKey = __privateMethod(this, _StyleManager_instances, cellFormatKey_fn).call(this, defaultCf);
+  this.cellXfs = [defaultCf];
+  this.cellXfCache.set(cfKey, 0);
+};
+getOrCreateFont_fn = function(font) {
+  const key = font.cacheKey();
+  const existing = this.fontCache.get(key);
+  if (existing !== void 0) return existing;
+  const idx = this.fonts.length;
+  this.fonts.push({ font, key });
+  this.fontCache.set(key, idx);
+  this.isDirty = true;
+  return idx;
+};
+getOrCreateFill_fn = function(fill) {
+  const key = fill.cacheKey();
+  const existing = this.fillCache.get(key);
+  if (existing !== void 0) return existing;
+  const idx = this.fills.length;
+  this.fills.push({ fill, key });
+  this.fillCache.set(key, idx);
+  this.isDirty = true;
+  return idx;
+};
+getOrCreateBorder_fn = function(border) {
+  const key = border.cacheKey();
+  const existing = this.borderCache.get(key);
+  if (existing !== void 0) return existing;
+  const idx = this.borders.length;
+  this.borders.push({ border, key });
+  this.borderCache.set(key, idx);
+  this.isDirty = true;
+  return idx;
+};
+getOrCreateNumFmt_fn = function(fmt) {
+  if (fmt.formatId > 0 && fmt.formatId < 164) return fmt.formatId;
+  if (fmt.formatCode === "General") return 0;
+  const existing = this.numFmtCache.get(fmt.formatCode);
+  if (existing !== void 0) return existing;
+  const id = this.nextCustomNumFmtId++;
+  this.numFmts.push({ id, code: fmt.formatCode });
+  this.numFmtCache.set(fmt.formatCode, id);
+  this.isDirty = true;
+  return id;
+};
+cellFormatKey_fn = function(cf) {
+  return [
+    cf.fontId,
+    cf.fillId,
+    cf.borderId,
+    cf.numFmtId,
+    cf.applyFont,
+    cf.applyFill,
+    cf.applyBorder,
+    cf.applyNumFmt,
+    cf.applyAlign,
+    cf.applyProt,
+    cf.alignment?.cacheKey() ?? "",
+    cf.isLocked ?? "",
+    cf.isHidden ?? ""
+  ].join("|");
+};
+cfToXml_fn = function(cf) {
+  const attrs = [
+    `numFmtId="${cf.numFmtId}"`,
+    `fontId="${cf.fontId}"`,
+    `fillId="${cf.fillId}"`,
+    `borderId="${cf.borderId}"`,
+    `xfId="0"`,
+    cf.applyFont ? 'applyFont="1"' : "",
+    cf.applyFill ? 'applyFill="1"' : "",
+    cf.applyBorder ? 'applyBorder="1"' : "",
+    cf.applyNumFmt ? 'applyNumberFormat="1"' : "",
+    cf.applyAlign ? 'applyAlignment="1"' : "",
+    cf.applyProt ? 'applyProtection="1"' : ""
+  ].filter(Boolean).join(" ");
+  const alignXml = cf.alignment?.toXml() ?? "";
+  const protXml = cf.applyProt ? `<protection${cf.isLocked !== void 0 ? ` locked="${cf.isLocked ? "1" : "0"}"` : ""}${cf.isHidden !== void 0 ? ` hidden="${cf.isHidden ? "1" : "0"}"` : ""}/>` : "";
+  const inner = alignXml + protXml;
+  return inner ? `<xf ${attrs}>${inner}</xf>` : `<xf ${attrs}/>`;
+};
+function escAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/model/cell-reference.ts
+function parseCellRef(cellReference) {
+  if (!cellReference) {
+    throw new Error("Cell reference cannot be null or empty.");
+  }
+  const ref = cellReference.replace(/\$/g, "").toUpperCase();
+  let i = 0;
+  let column = 0;
+  while (i < ref.length && ref.charCodeAt(i) >= 65 && ref.charCodeAt(i) <= 90) {
+    column = column * 26 + (ref.charCodeAt(i) - 64);
+    i++;
+  }
+  if (column === 0) {
+    throw new Error(`Invalid cell reference: "${cellReference}" \u2014 no column letters found.`);
+  }
+  const rowStr = ref.slice(i);
+  const row = parseInt(rowStr, 10);
+  if (isNaN(row) || row < 1 || rowStr === "") {
+    throw new Error(`Invalid cell reference: "${cellReference}" \u2014 no valid row number found.`);
+  }
+  return { row, column };
+}
+function cellRefFromRowCol(row, column) {
+  if (row < 1) throw new RangeError(`Row must be >= 1, got ${row}.`);
+  if (column < 1) throw new RangeError(`Column must be >= 1, got ${column}.`);
+  return `${columnLetter(column)}${row}`;
+}
+function columnLetter(column) {
+  if (column < 1) throw new RangeError(`Column must be >= 1, got ${column}.`);
+  let result = "";
+  let col = column;
+  while (col > 0) {
+    const remainder = (col - 1) % 26;
+    result = String.fromCharCode(65 + remainder) + result;
+    col = Math.floor((col - remainder) / 26);
+  }
+  return result;
+}
+function columnNumber(letters) {
+  if (!letters) throw new Error("Column letter cannot be empty.");
+  const upper = letters.toUpperCase();
+  let col = 0;
+  for (let i = 0; i < upper.length; i++) {
+    const code = upper.charCodeAt(i);
+    if (code < 65 || code > 90) {
+      throw new Error(`Invalid column letter: "${letters}".`);
+    }
+    col = col * 26 + (code - 64);
+  }
+  return col;
+}
+function parseRangeRef(rangeReference) {
+  const parts = rangeReference.split(":");
+  if (parts.length !== 2) {
+    throw new Error(`Invalid range reference: "${rangeReference}" \u2014 expected "A1:B10" format.`);
+  }
+  const start = parseCellRef(parts[0]);
+  const end = parseCellRef(parts[1]);
+  if (start.row > end.row || start.column > end.column) {
+    throw new Error(
+      `Invalid range reference: "${rangeReference}" \u2014 start must be top-left of end.`
+    );
+  }
+  return {
+    startRow: start.row,
+    startColumn: start.column,
+    endRow: end.row,
+    endColumn: end.column
+  };
+}
+
+// src/model/oa-date.ts
+var OA_EPOCH_MS = Date.UTC(1899, 11, 30, 0, 0, 0, 0);
+var MS_PER_DAY = 864e5;
+function toOADate(date) {
+  const utcMs = Date.UTC(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    date.getHours(),
+    date.getMinutes(),
+    date.getSeconds(),
+    date.getMilliseconds()
+  );
+  return (utcMs - OA_EPOCH_MS) / MS_PER_DAY;
+}
+function fromOADate(oaDate) {
+  const ms = OA_EPOCH_MS + oaDate * MS_PER_DAY;
+  const d = new Date(ms);
+  return new Date(
+    d.getUTCFullYear(),
+    d.getUTCMonth(),
+    d.getUTCDate(),
+    d.getUTCHours(),
+    d.getUTCMinutes(),
+    d.getUTCSeconds(),
+    d.getUTCMilliseconds()
+  );
+}
+var DATE_FORMAT_IDS = /* @__PURE__ */ new Set([14, 15, 16, 17, 18, 19, 20, 21, 22, 45, 46, 47]);
+function isDateFormatId(formatId) {
+  return DATE_FORMAT_IDS.has(formatId);
+}
+function isDateFormatCode(formatCode) {
+  const lower = formatCode.toLowerCase();
+  return lower.includes("y") || lower.includes("d") || lower.includes("m") && !lower.includes("mm:") || // m = month unless part of mm:ss
+  lower.includes("h") || lower.includes("am") || lower.includes("pm");
+}
+
+// src/model/cell.ts
+var _data, _sharedStrings, _styles, _Cell_instances, isDateStyle_fn;
+var Cell = class {
+  /** @internal */
+  constructor(data, sharedStrings, styles) {
+    __privateAdd(this, _Cell_instances);
+    __privateAdd(this, _data);
+    __privateAdd(this, _sharedStrings);
+    __privateAdd(this, _styles);
+    __privateSet(this, _data, data);
+    __privateSet(this, _sharedStrings, sharedStrings);
+    __privateSet(this, _styles, styles);
+  }
+  // ── Identity ───────────────────────────────────────────────────────────────
+  /** Cell reference string e.g. "A1". */
+  get reference() {
+    return __privateGet(this, _data).reference;
+  }
+  /** 1-based row index. */
+  get row() {
+    return parseCellRef(__privateGet(this, _data).reference).row;
+  }
+  /** 1-based column index. */
+  get column() {
+    return parseCellRef(__privateGet(this, _data).reference).column;
+  }
+  setValue(value) {
+    __privateGet(this, _data).formula = void 0;
+    if (value === null || value === void 0) {
+      __privateGet(this, _data).dataType = void 0;
+      __privateGet(this, _data).rawValue = void 0;
+      return this;
+    }
+    if (typeof value === "string") {
+      const idx = __privateGet(this, _sharedStrings).addOrGet(value);
+      __privateGet(this, _data).dataType = "s";
+      __privateGet(this, _data).rawValue = String(idx);
+      return this;
+    }
+    if (typeof value === "boolean") {
+      __privateGet(this, _data).dataType = "b";
+      __privateGet(this, _data).rawValue = value ? "1" : "0";
+      return this;
+    }
+    if (value instanceof Date) {
+      __privateGet(this, _data).dataType = "n";
+      __privateGet(this, _data).rawValue = String(toOADate(value));
+      if (__privateGet(this, _data).styleIndex === 0) {
+        const style = new CellStyle();
+        style.setNumberFormat(ExcelNumberFormat.shortDate);
+        __privateGet(this, _data).styleIndex = __privateGet(this, _styles).getOrCreateCellFormatIndex(style);
+      }
+      return this;
+    }
+    __privateGet(this, _data).dataType = "n";
+    __privateGet(this, _data).rawValue = String(value);
+    return this;
+  }
+  /**
+   * Gets the typed cell value.
+   * Returns string | number | boolean | Date | null.
+   * Date detection is based on the cell's number format.
+   */
+  getValue() {
+    if (__privateGet(this, _data).rawValue === void 0 || __privateGet(this, _data).rawValue === "") return null;
+    switch (__privateGet(this, _data).dataType) {
+      case "s": {
+        const idx = parseInt(__privateGet(this, _data).rawValue, 10);
+        return __privateGet(this, _sharedStrings).tryGetString(idx) ?? __privateGet(this, _data).rawValue;
+      }
+      case "b":
+        return __privateGet(this, _data).rawValue === "1";
+      case "str":
+        return __privateGet(this, _data).rawValue;
+      default: {
+        const num = parseFloat(__privateGet(this, _data).rawValue);
+        if (isNaN(num)) return __privateGet(this, _data).rawValue;
+        if (__privateMethod(this, _Cell_instances, isDateStyle_fn).call(this)) {
+          try {
+            return fromOADate(num);
+          } catch {
+            return num;
+          }
+        }
+        return num;
+      }
+    }
+  }
+  /**
+   * Returns the display text of the cell value (always a string).
+   */
+  getText() {
+    const val = this.getValue();
+    if (val === null) return "";
+    if (val instanceof Date) return val.toLocaleDateString();
+    return String(val);
+  }
+  // ── Formula API ────────────────────────────────────────────────────────────
+  /**
+   * Sets a formula. The leading '=' is optional.
+   * Clears any cached value.
+   */
+  setFormula(formula) {
+    if (!formula) throw new Error("Formula cannot be empty.");
+    __privateGet(this, _data).formula = formula.startsWith("=") ? formula.slice(1) : formula;
+    __privateGet(this, _data).rawValue = void 0;
+    __privateGet(this, _data).dataType = void 0;
+    return this;
+  }
+  /** Returns the formula text (without leading '='), or null if no formula. */
+  getFormula() {
+    return __privateGet(this, _data).formula ?? null;
+  }
+  /** True if this cell contains a formula. */
+  get hasFormula() {
+    return __privateGet(this, _data).formula !== void 0 && __privateGet(this, _data).formula !== "";
+  }
+  // ── Style API ──────────────────────────────────────────────────────────────
+  /** Gets the current CellStyle. Returns a new CellStyle if no style is set. */
+  get style() {
+    return __privateGet(this, _styles).getCellStyle(__privateGet(this, _data).styleIndex);
+  }
+  /** Replaces the entire cell style. */
+  set style(value) {
+    __privateGet(this, _data).styleIndex = __privateGet(this, _styles).getOrCreateCellFormatIndex(value);
+  }
+  /**
+   * Applies style changes via a callback on the current style.
+   * Returns this for chaining.
+   *
+   * @example
+   * cell.applyStyle(s => s.setBold(true).setFontColor(ExcelColor.red))
+   */
+  applyStyle(action) {
+    const s = __privateGet(this, _styles).getCellStyle(__privateGet(this, _data).styleIndex).clone();
+    action(s);
+    __privateGet(this, _data).styleIndex = __privateGet(this, _styles).getOrCreateCellFormatIndex(s);
+    return this;
+  }
+  // Convenience style shortcuts (mirror Cell.cs methods)
+  setBold(bold = true) {
+    return this.applyStyle((s) => s.setBold(bold));
+  }
+  setItalic(italic = true) {
+    return this.applyStyle((s) => s.setItalic(italic));
+  }
+  setFontSize(size) {
+    return this.applyStyle((s) => s.setFontSize(size));
+  }
+  setFontColor(color) {
+    return this.applyStyle((s) => s.setFontColor(color));
+  }
+  setFontName(name) {
+    return this.applyStyle((s) => s.setFontName(name));
+  }
+  setBackgroundColor(color) {
+    return this.applyStyle((s) => s.setBackgroundColor(color));
+  }
+  setWrapText(wrap = true) {
+    return this.applyStyle((s) => s.setWrapText(wrap));
+  }
+  setHorizontalAlignment(a) {
+    return this.applyStyle((s) => s.setHorizontalAlignment(a));
+  }
+  setVerticalAlignment(a) {
+    return this.applyStyle((s) => s.setVerticalAlignment(a));
+  }
+  setAllBorders(style, color) {
+    return this.applyStyle((s) => s.setAllBorders(style, color));
+  }
+  setNumberFormat(formatOrCode) {
+    return this.applyStyle((s) => s.setNumberFormat(formatOrCode));
+  }
+  // ── Clear ──────────────────────────────────────────────────────────────────
+  /** Clears the cell value and formula, preserving style. */
+  clear() {
+    __privateGet(this, _data).rawValue = void 0;
+    __privateGet(this, _data).dataType = void 0;
+    __privateGet(this, _data).formula = void 0;
+  }
+  /** Clears the cell value, formula, AND style. */
+  clearAll() {
+    this.clear();
+    __privateGet(this, _data).styleIndex = 0;
+  }
+  // ── XML serialisation ──────────────────────────────────────────────────────
+  /** @internal Builds the <c> XML element string for this cell. */
+  toXml() {
+    const ref = __privateGet(this, _data).reference;
+    const style = __privateGet(this, _data).styleIndex > 0 ? ` s="${__privateGet(this, _data).styleIndex}"` : "";
+    const type = __privateGet(this, _data).dataType ? ` t="${__privateGet(this, _data).dataType}"` : "";
+    const formulaXml = __privateGet(this, _data).formula ? `<f>${escXml(__privateGet(this, _data).formula)}</f>` : "";
+    const valueXml = __privateGet(this, _data).rawValue !== void 0 && __privateGet(this, _data).rawValue !== "" ? `<v>${escXml(__privateGet(this, _data).rawValue)}</v>` : "";
+    if (!formulaXml && !valueXml && __privateGet(this, _data).styleIndex === 0) return "";
+    return `<c r="${ref}"${style}${type}>${formulaXml}${valueXml}</c>`;
+  }
+  /** @internal Parses a <c> XML element into CellData. */
+  static fromXmlElement(el, ref) {
+    const dataType = el.attributes["t"] ?? void 0;
+    const styleIndex = parseInt(el.attributes["s"] ?? "0", 10);
+    let rawValue;
+    let formula;
+    for (const child of el.children) {
+      const tag = child.tagName.replace(/^.*:/, "");
+      if (tag === "v") rawValue = child.textContent;
+      if (tag === "f") formula = child.textContent;
+    }
+    return { reference: ref, dataType, rawValue, formula, styleIndex };
+  }
+};
+_data = new WeakMap();
+_sharedStrings = new WeakMap();
+_styles = new WeakMap();
+_Cell_instances = new WeakSet();
+// ── Private helpers ────────────────────────────────────────────────────────
+isDateStyle_fn = function() {
+  const style = __privateGet(this, _styles).getCellStyle(__privateGet(this, _data).styleIndex);
+  if (!style.numberFormat) return false;
+  if (isDateFormatId(style.numberFormat.formatId)) return true;
+  return isDateFormatCode(style.numberFormat.formatCode);
+};
+function escXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/model/range.ts
+var _sheet, _startRow, _startColumn, _endRow, _endColumn, _address, _Range_instances, forEach_fn;
+var Range = class {
+  constructor(sheet, rangeReference) {
+    __privateAdd(this, _Range_instances);
+    __privateAdd(this, _sheet);
+    __privateAdd(this, _startRow);
+    __privateAdd(this, _startColumn);
+    __privateAdd(this, _endRow);
+    __privateAdd(this, _endColumn);
+    __privateAdd(this, _address);
+    __privateSet(this, _sheet, sheet);
+    __privateSet(this, _address, rangeReference.toUpperCase());
+    const { startRow, startColumn, endRow, endColumn } = parseRangeRef(rangeReference);
+    __privateSet(this, _startRow, startRow);
+    __privateSet(this, _startColumn, startColumn);
+    __privateSet(this, _endRow, endRow);
+    __privateSet(this, _endColumn, endColumn);
+  }
+  /** The range address e.g. "A1:B10". */
+  get address() {
+    return __privateGet(this, _address);
+  }
+  /** Number of rows in the range. */
+  get rowCount() {
+    return __privateGet(this, _endRow) - __privateGet(this, _startRow) + 1;
+  }
+  /** Number of columns in the range. */
+  get columnCount() {
+    return __privateGet(this, _endColumn) - __privateGet(this, _startColumn) + 1;
+  }
+  // ── Value bulk operations ──────────────────────────────────────────────────
+  /**
+   * Sets values from a 2D array.
+   * Values that exceed the range boundary are silently ignored.
+   */
+  setValues(values) {
+    for (let r = 0; r < values.length && __privateGet(this, _startRow) + r <= __privateGet(this, _endRow); r++) {
+      const rowValues = values[r];
+      for (let c = 0; c < rowValues.length && __privateGet(this, _startColumn) + c <= __privateGet(this, _endColumn); c++) {
+        const cell = __privateGet(this, _sheet).getCell(__privateGet(this, _startRow) + r, __privateGet(this, _startColumn) + c);
+        const val = rowValues[c];
+        cell.setValue(val);
+      }
+    }
+  }
+  /**
+   * Gets all cell values as a 2D array (row-major order).
+   */
+  getValues() {
+    const result = [];
+    for (let r = 0; r < this.rowCount; r++) {
+      const row = [];
+      for (let c = 0; c < this.columnCount; c++) {
+        const cell = __privateGet(this, _sheet).tryGetCell(__privateGet(this, _startRow) + r, __privateGet(this, _startColumn) + c);
+        row.push(cell ? cell.getValue() : null);
+      }
+      result.push(row);
+    }
+    return result;
+  }
+  /** Clears all cells in the range (values only, preserves style). */
+  clear() {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.clear());
+  }
+  /** Auto-fits all columns in the range. */
+  autoFit() {
+    for (let col = __privateGet(this, _startColumn); col <= __privateGet(this, _endColumn); col++) {
+      __privateGet(this, _sheet).autoFitColumn(col);
+    }
+  }
+  // ── Style bulk operations ──────────────────────────────────────────────────
+  /** Applies a CellStyle to all cells in the range. Returns this for chaining. */
+  setStyle(style) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => {
+      cell.style = style;
+    });
+    return this;
+  }
+  /**
+   * Applies style changes to all cells in the range.
+   * @example range.applyStyle(s => s.setBold(true).setBackgroundColor(ExcelColor.lightGray))
+   */
+  applyStyle(action) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.applyStyle(action));
+    return this;
+  }
+  setBold(bold = true) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.setBold(bold));
+    return this;
+  }
+  setFontSize(size) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.setFontSize(size));
+    return this;
+  }
+  setFontColor(color) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.setFontColor(color));
+    return this;
+  }
+  setFontName(name) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.setFontName(name));
+    return this;
+  }
+  setBackgroundColor(color) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.setBackgroundColor(color));
+    return this;
+  }
+  setAllBorders(style, color) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.setAllBorders(style, color));
+    return this;
+  }
+  setHorizontalAlignment(alignment) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.setHorizontalAlignment(alignment));
+    return this;
+  }
+  setVerticalAlignment(alignment) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.setVerticalAlignment(alignment));
+    return this;
+  }
+  setWrapText(wrap = true) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.setWrapText(wrap));
+    return this;
+  }
+  setNumberFormat(formatOrCode) {
+    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.setNumberFormat(formatOrCode));
+    return this;
+  }
+};
+_sheet = new WeakMap();
+_startRow = new WeakMap();
+_startColumn = new WeakMap();
+_endRow = new WeakMap();
+_endColumn = new WeakMap();
+_address = new WeakMap();
+_Range_instances = new WeakSet();
+// ── Private helper ─────────────────────────────────────────────────────────
+forEach_fn = function(action) {
+  for (let r = __privateGet(this, _startRow); r <= __privateGet(this, _endRow); r++) {
+    for (let c = __privateGet(this, _startColumn); c <= __privateGet(this, _endColumn); c++) {
+      action(__privateGet(this, _sheet).getCell(r, c));
+    }
+  }
+};
+
+// src/model/worksheet.ts
+var _sharedStrings2, _styles2, _name, _rows, _cols, _mergeCells, _pane, _autoFilter, _dataValidations, _visibility, _drawings, _Worksheet_instances, buildColsXml_fn, buildSheetDataXml_fn, buildMergeCellsXml_fn, buildDataValidationsXml_fn, buildSheetViewXml_fn, getOrCreateRow_fn;
+var Worksheet = class {
+  /** @internal */
+  constructor(name, sharedStrings, styles) {
+    __privateAdd(this, _Worksheet_instances);
+    __privateAdd(this, _sharedStrings2);
+    __privateAdd(this, _styles2);
+    __privateAdd(this, _name);
+    __privateAdd(this, _rows, /* @__PURE__ */ new Map());
+    __privateAdd(this, _cols, []);
+    __privateAdd(this, _mergeCells, []);
+    __privateAdd(this, _pane);
+    __privateAdd(this, _autoFilter);
+    __privateAdd(this, _dataValidations, []);
+    __privateAdd(this, _visibility, "visible");
+    __privateAdd(this, _drawings, []);
+    __privateSet(this, _name, name);
+    __privateSet(this, _sharedStrings2, sharedStrings);
+    __privateSet(this, _styles2, styles);
+  }
+  // ── Identity ───────────────────────────────────────────────────────────────
+  get name() {
+    return __privateGet(this, _name);
+  }
+  set name(value) {
+    if (!value) throw new Error("Worksheet name cannot be empty.");
+    __privateSet(this, _name, value);
+  }
+  getCell(refOrRow, column) {
+    const ref = typeof refOrRow === "string" ? refOrRow.replace(/\$/g, "").toUpperCase() : cellRefFromRowCol(refOrRow, column);
+    const { row } = parseCellRef(ref);
+    const rowData = __privateMethod(this, _Worksheet_instances, getOrCreateRow_fn).call(this, row);
+    let cellData = rowData.cells.get(ref);
+    if (!cellData) {
+      cellData = { reference: ref, styleIndex: 0 };
+      rowData.cells.set(ref, cellData);
+    }
+    return new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2));
+  }
+  tryGetCell(refOrRow, column) {
+    const ref = typeof refOrRow === "string" ? refOrRow.replace(/\$/g, "").toUpperCase() : cellRefFromRowCol(refOrRow, column);
+    const { row } = parseCellRef(ref);
+    const rowData = __privateGet(this, _rows).get(row);
+    if (!rowData) return null;
+    const cellData = rowData.cells.get(ref);
+    if (!cellData) return null;
+    return new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2));
+  }
+  cell(refOrRow, column) {
+    return typeof refOrRow === "string" ? this.getCell(refOrRow) : this.getCell(refOrRow, column);
+  }
+  /** Gets a Range object for bulk operations. */
+  getRange(rangeReference) {
+    if (!rangeReference) throw new Error("Range reference cannot be empty.");
+    return new Range(this, rangeReference);
+  }
+  /** Gets the raw value of a cell (for formula evaluation). */
+  getCellValue(reference) {
+    return this.tryGetCell(reference)?.getValue() ?? null;
+  }
+  /**
+   * Returns the 1-based extent of populated cells (largest row and column that
+   * contain data). Returns zeros for an empty sheet. Useful for snapshotting a
+   * sheet into a dense 2D array.
+   */
+  get usedBounds() {
+    let rowCount = 0;
+    let columnCount = 0;
+    for (const row of __privateGet(this, _rows).values()) {
+      if (row.cells.size === 0) continue;
+      if (row.rowIndex > rowCount) rowCount = row.rowIndex;
+      for (const ref of row.cells.keys()) {
+        const col = parseCellRef(ref).column;
+        if (col > columnCount) columnCount = col;
+      }
+    }
+    return { rowCount, columnCount };
+  }
+  // ── Layout ─────────────────────────────────────────────────────────────────
+  /** Sets the width of a column (1-based index). */
+  setColumnWidth(columnIndex, width) {
+    if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
+    if (width <= 0) throw new RangeError("Width must be > 0.");
+    __privateSet(this, _cols, __privateGet(this, _cols).filter((c) => !(c.min <= columnIndex && c.max >= columnIndex)));
+    __privateGet(this, _cols).push({ min: columnIndex, max: columnIndex, width, customWidth: true });
+    __privateGet(this, _cols).sort((a, b) => a.min - b.min);
+  }
+  /** Auto-fits column width based on content (approximate). */
+  autoFitColumn(columnIndex) {
+    if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
+    let maxLen = 8;
+    for (const row of __privateGet(this, _rows).values()) {
+      const ref = cellRefFromRowCol(row.rowIndex, columnIndex);
+      const cellData = row.cells.get(ref);
+      if (cellData) {
+        const cell = new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2));
+        const textLen = cell.getText().length;
+        if (textLen > maxLen) maxLen = textLen;
+      }
+    }
+    this.setColumnWidth(columnIndex, Math.min(maxLen * 1.2 + 2, 255));
+  }
+  /** Sets the height of a row (1-based index). */
+  setRowHeight(rowIndex, height) {
+    if (rowIndex < 1) throw new RangeError("Row index must be >= 1.");
+    if (height <= 0) throw new RangeError("Height must be > 0.");
+    const row = __privateMethod(this, _Worksheet_instances, getOrCreateRow_fn).call(this, rowIndex);
+    row.height = height;
+    row.customHeight = true;
+  }
+  /** Merges cells in the given range (e.g. "A1:B2"). */
+  mergeCells(rangeReference) {
+    if (!rangeReference) throw new Error("Range reference cannot be empty.");
+    __privateGet(this, _mergeCells).push({ ref: rangeReference });
+  }
+  /** Removes a merge for the given range reference. */
+  unmergeCells(rangeReference) {
+    __privateSet(this, _mergeCells, __privateGet(this, _mergeCells).filter((m) => m.ref !== rangeReference));
+  }
+  /**
+   * Freezes rows and/or columns.
+   * @param row    Number of rows to freeze (0 = none)
+   * @param column Number of columns to freeze (0 = none)
+   */
+  freezePanes(row, column) {
+    if (row < 0) throw new RangeError("Row must be >= 0.");
+    if (column < 0) throw new RangeError("Column must be >= 0.");
+    __privateSet(this, _pane, row === 0 && column === 0 ? void 0 : { row, column });
+  }
+  /** Sets auto-filter on the given range. */
+  setAutoFilter(rangeReference) {
+    __privateSet(this, _autoFilter, { ref: rangeReference });
+  }
+  /**
+   * Adds a dropdown data validation to a cell range.
+   * @param cellRange   Range to apply (e.g. "F2:F1000")
+   * @param listFormula Formula for the dropdown list (e.g. "'Sheet2'!$A$1:$A$10")
+   */
+  addDropdownValidation(cellRange, listFormula) {
+    __privateGet(this, _dataValidations).push({ sqref: cellRange, formula: listFormula });
+  }
+  /** Sets the visibility state of this worksheet. */
+  setVisibility(state) {
+    __privateSet(this, _visibility, state);
+  }
+  get visibility() {
+    return __privateGet(this, _visibility);
+  }
+  // ── Drawings (charts, images …) ──────────────────────────────────────────────
+  /**
+   * Attaches a drawing provider (e.g. a chart) to this worksheet.
+   * Satellite packages such as `@devmm/puredocs-excel-charts` call this; the core
+   * save pipeline turns registered providers into valid OOXML drawing/chart parts.
+   */
+  addDrawingProvider(provider) {
+    __privateGet(this, _drawings).push(provider);
+  }
+  /** True when this worksheet has at least one drawing to serialise. */
+  get hasDrawings() {
+    return __privateGet(this, _drawings).length > 0;
+  }
+  /** @internal — drawing providers, consumed by the save pipeline. */
+  get drawingProviders() {
+    return __privateGet(this, _drawings);
+  }
+  // ── XML serialisation ──────────────────────────────────────────────────────
+  /** Builds the xl/worksheets/sheetN.xml string. */
+  buildXml() {
+    const colsXml = __privateMethod(this, _Worksheet_instances, buildColsXml_fn).call(this);
+    const sheetDataXml = __privateMethod(this, _Worksheet_instances, buildSheetDataXml_fn).call(this);
+    const mergeXml = __privateMethod(this, _Worksheet_instances, buildMergeCellsXml_fn).call(this);
+    const filterXml = __privateGet(this, _autoFilter) ? `<autoFilter ref="${__privateGet(this, _autoFilter).ref}"/>` : "";
+    const validXml = __privateMethod(this, _Worksheet_instances, buildDataValidationsXml_fn).call(this);
+    const sheetViewXml = __privateMethod(this, _Worksheet_instances, buildSheetViewXml_fn).call(this);
+    const drawingXml = this.hasDrawings ? `<drawing r:id="${WORKSHEET_DRAWING_REL_ID}"/>` : "";
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+           xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <sheetViews>${sheetViewXml}</sheetViews>
+${colsXml}${sheetDataXml}${filterXml}${mergeXml}${validXml}${drawingXml}
+</worksheet>`;
+  }
+  /** Parses xl/worksheets/sheetN.xml and loads cells into memory. */
+  loadFromXml(xml2) {
+    __privateGet(this, _rows).clear();
+    __privateSet(this, _cols, []);
+    __privateSet(this, _mergeCells, []);
+    __privateSet(this, _pane, void 0);
+    __privateSet(this, _autoFilter, void 0);
+    __privateSet(this, _dataValidations, []);
+    const root = parseXml(xml2);
+    for (const colEl of getElementsByTagName(root, "col")) {
+      __privateGet(this, _cols).push({
+        min: parseInt(getAttr(colEl, "min") ?? "1", 10),
+        max: parseInt(getAttr(colEl, "max") ?? "1", 10),
+        width: parseFloat(getAttr(colEl, "width") ?? "8"),
+        customWidth: getAttr(colEl, "customWidth") === "1",
+        hidden: getAttr(colEl, "hidden") === "1"
+      });
+    }
+    for (const rowEl of getElementsByTagName(root, "row")) {
+      const rowIndex = parseInt(getAttr(rowEl, "r") ?? "0", 10);
+      if (rowIndex < 1) continue;
+      const rowData = { rowIndex, cells: /* @__PURE__ */ new Map() };
+      const ht = getAttr(rowEl, "ht");
+      if (ht) {
+        rowData.height = parseFloat(ht);
+        rowData.customHeight = true;
+      }
+      for (const cellEl of rowEl.children) {
+        const tag = cellEl.tagName.replace(/^.*:/, "");
+        if (tag !== "c") continue;
+        const ref = getAttr(cellEl, "r");
+        if (!ref) continue;
+        const cellData = Cell.fromXmlElement(
+          { attributes: cellEl.attributes, children: cellEl.children },
+          ref.toUpperCase()
+        );
+        rowData.cells.set(ref.toUpperCase(), cellData);
+      }
+      __privateGet(this, _rows).set(rowIndex, rowData);
+    }
+    for (const mcEl of getElementsByTagName(root, "mergeCell")) {
+      const ref = getAttr(mcEl, "ref");
+      if (ref) __privateGet(this, _mergeCells).push({ ref });
+    }
+    const afEls = getElementsByTagName(root, "autoFilter");
+    if (afEls.length > 0) {
+      const ref = getAttr(afEls[0], "ref");
+      if (ref) __privateSet(this, _autoFilter, { ref });
+    }
+    for (const paneEl of getElementsByTagName(root, "pane")) {
+      const state = getAttr(paneEl, "state");
+      if (state === "frozen" || state === "frozenSplit") {
+        __privateSet(this, _pane, {
+          row: parseInt(getAttr(paneEl, "ySplit") ?? "0", 10),
+          column: parseInt(getAttr(paneEl, "xSplit") ?? "0", 10)
+        });
+      }
+    }
+    for (const dvEl of getElementsByTagName(root, "dataValidation")) {
+      const sqref = getAttr(dvEl, "sqref") ?? "";
+      const f1Els = getElementsByTagName(dvEl, "formula1");
+      const formula = f1Els[0]?.textContent ?? "";
+      if (sqref && formula) __privateGet(this, _dataValidations).push({ sqref, formula });
+    }
+  }
+};
+_sharedStrings2 = new WeakMap();
+_styles2 = new WeakMap();
+_name = new WeakMap();
+_rows = new WeakMap();
+_cols = new WeakMap();
+_mergeCells = new WeakMap();
+_pane = new WeakMap();
+_autoFilter = new WeakMap();
+_dataValidations = new WeakMap();
+_visibility = new WeakMap();
+_drawings = new WeakMap();
+_Worksheet_instances = new WeakSet();
+// ── Private XML builders ───────────────────────────────────────────────────
+buildColsXml_fn = function() {
+  if (__privateGet(this, _cols).length === 0) return "";
+  const inner = __privateGet(this, _cols).map((c) => {
+    const hidden = c.hidden ? ' hidden="1"' : "";
+    return `<col min="${c.min}" max="${c.max}" width="${c.width.toFixed(2)}" customWidth="${c.customWidth ? 1 : 0}"${hidden}/>`;
+  }).join("");
+  return `<cols>${inner}</cols>`;
+};
+buildSheetDataXml_fn = function() {
+  const sortedRows = [...__privateGet(this, _rows).values()].sort((a, b) => a.rowIndex - b.rowIndex);
+  if (sortedRows.length === 0) return "<sheetData/>";
+  const rowsXml = sortedRows.map((row) => {
+    const ht = row.height !== void 0 && row.customHeight ? ` ht="${row.height}" customHeight="1"` : "";
+    const sortedCells = [...row.cells.values()].sort((a, b) => {
+      const ra = parseCellRef(a.reference);
+      const rb = parseCellRef(b.reference);
+      return ra.column - rb.column;
+    });
+    const cellsXml = sortedCells.map((cd) => new Cell(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2)).toXml()).filter(Boolean).join("");
+    if (!cellsXml && !ht) return "";
+    return `<row r="${row.rowIndex}"${ht}>${cellsXml}</row>`;
+  }).filter(Boolean).join("");
+  return `<sheetData>${rowsXml}</sheetData>`;
+};
+buildMergeCellsXml_fn = function() {
+  if (__privateGet(this, _mergeCells).length === 0) return "";
+  const inner = __privateGet(this, _mergeCells).map((m) => `<mergeCell ref="${m.ref}"/>`).join("");
+  return `<mergeCells count="${__privateGet(this, _mergeCells).length}">${inner}</mergeCells>`;
+};
+buildDataValidationsXml_fn = function() {
+  if (__privateGet(this, _dataValidations).length === 0) return "";
+  const inner = __privateGet(this, _dataValidations).map(
+    (dv) => `<dataValidation type="list" allowBlank="1" showInputMessage="1" showErrorMessage="1" sqref="${dv.sqref}"><formula1>${escXml2(dv.formula)}</formula1></dataValidation>`
+  ).join("");
+  return `<dataValidations count="${__privateGet(this, _dataValidations).length}">${inner}</dataValidations>`;
+};
+buildSheetViewXml_fn = function() {
+  if (!__privateGet(this, _pane)) return '<sheetView workbookViewId="0"/>';
+  const { row, column } = __privateGet(this, _pane);
+  const topLeftRow = row > 0 ? row + 1 : 1;
+  const topLeftCol = column > 0 ? column + 1 : 1;
+  const topLeft = cellRefFromRowCol(topLeftRow, topLeftCol);
+  const activePane = row > 0 && column > 0 ? "bottomRight" : row > 0 ? "bottomLeft" : "topRight";
+  const xSplit = column > 0 ? ` xSplit="${column}"` : "";
+  const ySplit = row > 0 ? ` ySplit="${row}"` : "";
+  return `<sheetView workbookViewId="0"><pane${xSplit}${ySplit} topLeftCell="${topLeft}" activePane="${activePane}" state="frozen"/></sheetView>`;
+};
+getOrCreateRow_fn = function(rowIndex) {
+  let row = __privateGet(this, _rows).get(rowIndex);
+  if (!row) {
+    row = { rowIndex, cells: /* @__PURE__ */ new Map() };
+    __privateGet(this, _rows).set(rowIndex, row);
+  }
+  return row;
+};
+function escXml2(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/model/workbook.ts
+var _sharedStrings3, _styles3, _sheets, _closed, _Workbook_instances, assertOpen_fn, buildZipEntries_fn;
+var _Workbook = class _Workbook {
+  constructor(sharedStrings, styles) {
+    __privateAdd(this, _Workbook_instances);
+    __privateAdd(this, _sharedStrings3);
+    __privateAdd(this, _styles3);
+    __privateAdd(this, _sheets, []);
+    __privateAdd(this, _closed, false);
+    __privateSet(this, _sharedStrings3, sharedStrings);
+    __privateSet(this, _styles3, styles);
+  }
+  // ── Factory methods ────────────────────────────────────────────────────────
+  /**
+   * Creates a new empty workbook.
+   * Mirrors Workbook.Create() in C#.
+   */
+  static create() {
+    const ss = new SharedStringManager();
+    const sm = new StyleManager();
+    return new _Workbook(ss, sm);
+  }
+  /**
+   * Opens an existing workbook from a binary buffer (ArrayBuffer or Uint8Array).
+   * Works in both browser and Node.js.
+   * Mirrors Workbook.Open(stream) in C#.
+   */
+  static fromBuffer(buffer) {
+    const entries = unzipXlsx(buffer);
+    const ss = new SharedStringManager();
+    const sm = new StyleManager();
+    const wb = new _Workbook(ss, sm);
+    const ssXml = readXmlEntry(entries, "xl/sharedStrings.xml");
+    if (ssXml) ss.loadFromXml(ssXml);
+    const stylesXml = readXmlEntry(entries, "xl/styles.xml");
+    if (stylesXml) sm.loadFromXml(stylesXml);
+    const wbXml = requireXmlEntry(entries, "xl/workbook.xml");
+    const wbRoot = parseXml(wbXml);
+    for (const sheetEl of getElementsByTagName(wbRoot, "sheet")) {
+      const name = getAttr(sheetEl, "name") ?? "Sheet";
+      const sheetId = parseInt(getAttr(sheetEl, "sheetId") ?? "1", 10);
+      const relId = getAttr(sheetEl, "r:id") ?? getAttr(sheetEl, "id") ?? `rId${sheetId}`;
+      const state = getAttr(sheetEl, "state");
+      const relXml = readXmlEntry(entries, "xl/_rels/workbook.xml.rels") ?? "";
+      const wsPath = resolveWorksheetPath(relXml, relId);
+      const wsXml = wsPath ? readXmlEntry(entries, wsPath) ?? EMPTY_WORKSHEET_XML : EMPTY_WORKSHEET_XML;
+      const ws = new Worksheet(name, ss, sm);
+      if (state) ws.setVisibility(state);
+      ws.loadFromXml(wsXml);
+      __privateGet(wb, _sheets).push({ worksheet: ws, sheetId, relId });
+    }
+    return wb;
+  }
+  /**
+   * Opens an existing workbook from a file path (Node.js only).
+   * Mirrors Workbook.Open(filePath) in C#.
+   */
+  static async fromFile(filePath) {
+    const fs = await import('fs/promises');
+    const buffer = await fs.readFile(filePath);
+    return _Workbook.fromBuffer(buffer);
+  }
+  // ── Worksheet management ───────────────────────────────────────────────────
+  /**
+   * Collection of worksheets (read-only array view).
+   * Access by index: workbook.worksheets[0]
+   * Access by name: workbook.worksheets.find(s => s.name === 'Sheet1')
+   */
+  get worksheets() {
+    return __privateGet(this, _sheets).map((e) => e.worksheet);
+  }
+  /**
+   * Adds a new worksheet with the given name and returns it.
+   * Mirrors workbook.AddWorksheet(name) in C#.
+   */
+  addWorksheet(name) {
+    __privateMethod(this, _Workbook_instances, assertOpen_fn).call(this);
+    if (!name) throw new Error("Worksheet name cannot be empty.");
+    if (__privateGet(this, _sheets).some((e) => e.worksheet.name === name)) {
+      throw new Error(`Worksheet "${name}" already exists.`);
+    }
+    const sheetId = __privateGet(this, _sheets).length + 1;
+    const relId = `rId${sheetId}`;
+    const ws = new Worksheet(name, __privateGet(this, _sharedStrings3), __privateGet(this, _styles3));
+    __privateGet(this, _sheets).push({ worksheet: ws, sheetId, relId });
+    return ws;
+  }
+  /**
+   * Returns a worksheet by name. Throws if not found.
+   */
+  getWorksheet(name) {
+    const entry = __privateGet(this, _sheets).find((e) => e.worksheet.name === name);
+    if (!entry) throw new Error(`Worksheet "${name}" not found.`);
+    return entry.worksheet;
+  }
+  // ── Serialisation ──────────────────────────────────────────────────────────
+  /**
+   * Serialises the workbook to a Uint8Array (xlsx binary).
+   * Mirrors workbook.SaveAs(stream) in C#.
+   * Works in browser and Node.js.
+   */
+  saveAsBuffer() {
+    __privateMethod(this, _Workbook_instances, assertOpen_fn).call(this);
+    const entries = __privateMethod(this, _Workbook_instances, buildZipEntries_fn).call(this);
+    return zipXlsx(entries);
+  }
+  /**
+   * Saves the workbook to a file (Node.js only).
+   * Mirrors workbook.SaveAs(filePath) in C#.
+   */
+  async saveToFile(filePath) {
+    __privateMethod(this, _Workbook_instances, assertOpen_fn).call(this);
+    const buffer = this.saveAsBuffer();
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(filePath, buffer);
+  }
+  // ── Lifecycle ──────────────────────────────────────────────────────────────
+  /** Releases resources. The workbook should not be used after this call. */
+  close() {
+    __privateSet(this, _closed, true);
+  }
+  /** Symbol.dispose support for `using` keyword (TypeScript 5.2+). */
+  [Symbol.dispose]() {
+    this.close();
+  }
+};
+_sharedStrings3 = new WeakMap();
+_styles3 = new WeakMap();
+_sheets = new WeakMap();
+_closed = new WeakMap();
+_Workbook_instances = new WeakSet();
+// ── Private helpers ────────────────────────────────────────────────────────
+assertOpen_fn = function() {
+  if (__privateGet(this, _closed)) throw new Error("Workbook has been closed.");
+};
+buildZipEntries_fn = function() {
+  const entries = /* @__PURE__ */ new Map();
+  const sheetCount = __privateGet(this, _sheets).length;
+  entries.set("_rels/.rels", ROOT_RELS);
+  const sheetMetas = __privateGet(this, _sheets).map((e) => ({
+    name: e.worksheet.name,
+    sheetId: e.sheetId,
+    relationshipId: e.relId,
+    state: e.worksheet.visibility !== "visible" ? e.worksheet.visibility : void 0
+  }));
+  entries.set("xl/workbook.xml", buildWorkbookXml(sheetMetas));
+  entries.set("xl/_rels/workbook.xml.rels", buildWorkbookRels(sheetCount));
+  entries.set("xl/styles.xml", __privateGet(this, _styles3).buildStylesXml());
+  entries.set("xl/sharedStrings.xml", __privateGet(this, _sharedStrings3).buildXml());
+  for (let i = 0; i < __privateGet(this, _sheets).length; i++) {
+    entries.set(`xl/worksheets/sheet${i + 1}.xml`, __privateGet(this, _sheets)[i].worksheet.buildXml());
+  }
+  const extraOverrides = [];
+  let drawingCounter = 0;
+  let partCounter = 0;
+  for (let i = 0; i < __privateGet(this, _sheets).length; i++) {
+    const ws = __privateGet(this, _sheets)[i].worksheet;
+    if (!ws.hasDrawings) continue;
+    drawingCounter++;
+    const drawingPath = `xl/drawings/drawing${drawingCounter}.xml`;
+    const anchors = [];
+    const drawingRels = [];
+    ws.drawingProviders.forEach((provider, idx) => {
+      const relId = `rId${idx + 1}`;
+      anchors.push(provider.buildAnchorXml(relId));
+      partCounter++;
+      const part = provider.buildPart(partCounter);
+      entries.set(part.path, part.content);
+      extraOverrides.push({ partName: `/${part.path}`, contentType: part.contentType });
+      const target = `../${part.path.slice("xl/".length)}`;
+      drawingRels.push(
+        `  <Relationship Id="${relId}" Type="${part.relType}" Target="${target}"/>`
+      );
+    });
+    entries.set(drawingPath, buildDrawingXml(anchors.join("")));
+    entries.set(`xl/drawings/_rels/drawing${drawingCounter}.xml.rels`, buildRelsXml(drawingRels));
+    extraOverrides.push({ partName: `/${drawingPath}`, contentType: CONTENT_TYPES.drawing });
+    entries.set(
+      `xl/worksheets/_rels/sheet${i + 1}.xml.rels`,
+      buildRelsXml([
+        `  <Relationship Id="${WORKSHEET_DRAWING_REL_ID}" Type="${REL_TYPES.drawing}" Target="../drawings/drawing${drawingCounter}.xml"/>`
+      ])
+    );
+  }
+  entries.set("[Content_Types].xml", buildContentTypes(sheetCount, extraOverrides));
+  return entries;
+};
+var Workbook = _Workbook;
+function resolveWorksheetPath(relsXml, relId) {
+  if (!relsXml) return void 0;
+  try {
+    const root = parseXml(relsXml);
+    for (const el of getElementsByTagName(root, "Relationship")) {
+      if (getAttr(el, "Id") === relId) {
+        const target = getAttr(el, "Target") ?? "";
+        return target.startsWith("xl/") ? target : `xl/${target}`;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+
+exports.CONTENT_TYPES = CONTENT_TYPES;
+exports.Cell = Cell;
+exports.CellStyle = CellStyle;
+exports.ExcelAlignment = ExcelAlignment;
+exports.ExcelBorder = ExcelBorder;
+exports.ExcelBorderEdge = ExcelBorderEdge;
+exports.ExcelBorderStyle = ExcelBorderStyle;
+exports.ExcelColor = ExcelColor;
+exports.ExcelFill = ExcelFill;
+exports.ExcelFont = ExcelFont;
+exports.ExcelHorizontalAlignment = ExcelHorizontalAlignment;
+exports.ExcelNumberFormat = ExcelNumberFormat;
+exports.ExcelPatternType = ExcelPatternType;
+exports.ExcelReadingOrder = ExcelReadingOrder;
+exports.ExcelUnderline = ExcelUnderline;
+exports.ExcelVerticalAlignRun = ExcelVerticalAlignRun;
+exports.ExcelVerticalAlignment = ExcelVerticalAlignment;
+exports.NS = NS;
+exports.REL_TYPES = REL_TYPES;
+exports.Range = Range;
+exports.StyleManager = StyleManager;
+exports.WORKSHEET_DRAWING_REL_ID = WORKSHEET_DRAWING_REL_ID;
+exports.Workbook = Workbook;
+exports.Worksheet = Worksheet;
+exports.XmlBuilder = XmlBuilder;
+exports.buildDrawingXml = buildDrawingXml;
+exports.buildRelsXml = buildRelsXml;
+exports.cellRefFromRowCol = cellRefFromRowCol;
+exports.columnLetter = columnLetter;
+exports.columnNumber = columnNumber;
+exports.decodeUtf8 = decodeUtf8;
+exports.encodeUtf8 = encodeUtf8;
+exports.escapeXml = escapeXml;
+exports.fromOADate = fromOADate;
+exports.getAttr = getAttr;
+exports.getElementsByTagName = getElementsByTagName;
+exports.isDateFormatCode = isDateFormatCode;
+exports.isDateFormatId = isDateFormatId;
+exports.listEntries = listEntries;
+exports.parseCellRef = parseCellRef;
+exports.parseRangeRef = parseRangeRef;
+exports.parseXml = parseXml;
+exports.readXmlEntry = readXmlEntry;
+exports.requireXmlEntry = requireXmlEntry;
+exports.setBinaryEntry = setBinaryEntry;
+exports.setXmlEntry = setXmlEntry;
+exports.toOADate = toOADate;
+exports.unzipXlsx = unzipXlsx;
+exports.xml = xml;
+exports.zipXlsx = zipXlsx;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map