amendsheet 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3475 @@
+'use strict';
+
+var fflate = require('fflate');
+
+// src/lib/errors.ts
+var XlsxError = class extends Error {
+  code;
+  /** Where in the document the failure was, as tightly as it was known. */
+  part;
+  sheet;
+  reference;
+  constructor(code, message, context) {
+    super(message, { cause: context.cause });
+    this.name = "XlsxError";
+    this.code = code;
+    this.part = context.part;
+    this.sheet = context.sheet;
+    this.reference = context.reference;
+  }
+};
+var LOCAL_SIG = 67324752;
+var CENTRAL_SIG = 33639248;
+var END_SIG = 101010256;
+var ZIP64_EOCD_SIG = 101075792;
+var ZIP64_LOCATOR_SIG = 117853008;
+var ZIP64_EXTRA_ID = 1;
+var U32_MAX = 4294967295;
+var U16_MAX = 65535;
+var notAZip = (message) => new XlsxError("not-a-zip", message, {});
+function readU64(view, offset) {
+  const value = view.getBigUint64(offset, true);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw notAZip("Archive declares a size beyond 9PB, which cannot be represented");
+  }
+  return Number(value);
+}
+function endOfCentralDirectory(view, length) {
+  for (let offset = length - 22; offset >= 0; offset--) {
+    if (view.getUint32(offset, true) === END_SIG) return offset;
+  }
+  throw notAZip("File has no end-of-central-directory record, so it is not a zip");
+}
+function directoryStart(view, end) {
+  const count = view.getUint16(end + 10, true);
+  const offset = view.getUint32(end + 16, true);
+  if (count !== U16_MAX && offset !== U32_MAX) return { count, offset };
+  const locator = end - 20;
+  if (locator < 0 || view.getUint32(locator, true) !== ZIP64_LOCATOR_SIG) {
+    if (offset !== U32_MAX) return { count, offset };
+    throw notAZip("Archive maxes out a directory field but has no ZIP64 locator");
+  }
+  const record = readU64(view, locator + 8);
+  if (record + 56 > view.byteLength || view.getUint32(record, true) !== ZIP64_EOCD_SIG) {
+    throw notAZip("ZIP64 end-of-central-directory record is missing or malformed");
+  }
+  return { count: readU64(view, record + 32), offset: readU64(view, record + 48) };
+}
+function readZip64Extra(view, start, length, name2) {
+  if (start + length > view.byteLength) {
+    throw notAZip(`Entry ${name2} declares a ZIP64 extra field that runs past the archive`);
+  }
+  let position = start;
+  const end = start + length;
+  while (position + 4 <= end) {
+    const id = view.getUint16(position, true);
+    const size = view.getUint16(position + 2, true);
+    if (id === ZIP64_EXTRA_ID) {
+      const valuesEnd = Math.min(position + 4 + size, end);
+      let cursor = position + 4;
+      return () => {
+        if (cursor + 8 > valuesEnd) {
+          throw notAZip(`Entry ${name2} ZIP64 extra field is too short for its overflowed fields`);
+        }
+        const value = readU64(view, cursor);
+        cursor += 8;
+        return value;
+      };
+    }
+    position += 4 + size;
+  }
+  throw notAZip(`Entry ${name2} needs a ZIP64 extra field but has none`);
+}
+function readZip(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const end = endOfCentralDirectory(view, bytes.length);
+  const { count, offset: centralOffset } = directoryStart(view, end);
+  const entries = [];
+  let offset = centralOffset;
+  for (let index = 0; index < count; index++) {
+    if (offset + 46 > view.byteLength || view.getUint32(offset, true) !== CENTRAL_SIG) {
+      throw notAZip("Central directory is malformed");
+    }
+    const method = view.getUint16(offset + 10, true);
+    const crc = view.getUint32(offset + 16, true);
+    let compressedSize = view.getUint32(offset + 20, true);
+    let uncompressedSize = view.getUint32(offset + 24, true);
+    const nameLength = view.getUint16(offset + 28, true);
+    const extraLength = view.getUint16(offset + 30, true);
+    const commentLength = view.getUint16(offset + 32, true);
+    let localOffset = view.getUint32(offset + 42, true);
+    const name2 = new TextDecoder().decode(bytes.subarray(offset + 46, offset + 46 + nameLength));
+    if (uncompressedSize === U32_MAX || compressedSize === U32_MAX || localOffset === U32_MAX) {
+      const next = readZip64Extra(view, offset + 46 + nameLength, extraLength, name2);
+      if (uncompressedSize === U32_MAX) uncompressedSize = next();
+      if (compressedSize === U32_MAX) compressedSize = next();
+      if (localOffset === U32_MAX) localOffset = next();
+    }
+    if (localOffset + 30 > view.byteLength || view.getUint32(localOffset, true) !== LOCAL_SIG) {
+      throw notAZip(`Local header for ${name2} is malformed`);
+    }
+    const localNameLength = view.getUint16(localOffset + 26, true);
+    const localExtraLength = view.getUint16(localOffset + 28, true);
+    const dataStart = localOffset + 30 + localNameLength + localExtraLength;
+    entries.push({
+      name: name2,
+      method,
+      crc,
+      uncompressedSize,
+      compressed: bytes.subarray(dataStart, dataStart + compressedSize)
+    });
+    offset += 46 + nameLength + extraLength + commentLength;
+  }
+  return entries;
+}
+var STORED = 0;
+var DEFLATED = 8;
+function inflate(entry) {
+  if (entry.method === STORED) return entry.compressed;
+  if (entry.method === DEFLATED) {
+    let out;
+    try {
+      out = new Uint8Array(entry.uncompressedSize);
+    } catch (cause) {
+      throw new XlsxError(
+        "part-too-large",
+        `Part ${entry.name} decompresses to ${entry.uncompressedSize} bytes, too large to hold in memory`,
+        { part: entry.name, cause }
+      );
+    }
+    try {
+      return fflate.inflateSync(entry.compressed, { out });
+    } catch (cause) {
+      throw new XlsxError("unreadable-part", `Part ${entry.name} could not be inflated`, {
+        part: entry.name,
+        cause
+      });
+    }
+  }
+  throw new XlsxError("unreadable-part", `Part ${entry.name} uses compression ${entry.method}`, {
+    part: entry.name
+  });
+}
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit++) crc = crc >>> 1 ^ 3988292384 & -(crc & 1);
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function deflate(name2, bytes) {
+  return {
+    name: name2,
+    method: DEFLATED,
+    crc: crc32(bytes),
+    compressed: fflate.deflateSync(bytes, { level: 6 }),
+    uncompressedSize: bytes.length
+  };
+}
+var DOS_TIME = 0;
+var DOS_DATE = 33;
+var VERSION = 20;
+var VERSION_ZIP64 = 45;
+var setU64 = (view, offset, value) => view.setBigUint64(offset, BigInt(value), true);
+function writeZip(entries) {
+  const encoder2 = new TextEncoder();
+  let localTotal = 0;
+  const placed = [];
+  for (const entry of entries) {
+    const name2 = encoder2.encode(entry.name);
+    const sizeZip64 = entry.compressed.length >= U32_MAX || entry.uncompressedSize >= U32_MAX;
+    const localOffset = localTotal;
+    localTotal += 30 + name2.length + (sizeZip64 ? 20 : 0) + entry.compressed.length;
+    placed.push({ entry, name: name2, sizeZip64, localOffset, offsetZip64: false, centralExtra: 0 });
+  }
+  const centralStart = localTotal;
+  let centralTotal = 0;
+  const resolved = placed.map((item) => {
+    const offsetZip64 = item.localOffset >= U32_MAX;
+    const centralExtra = item.sizeZip64 || offsetZip64 ? 4 + (item.sizeZip64 ? 16 : 0) + (offsetZip64 ? 8 : 0) : 0;
+    centralTotal += 46 + item.name.length + centralExtra;
+    return { ...item, offsetZip64, centralExtra };
+  });
+  const eocdZip64 = entries.length >= U16_MAX || centralStart >= U32_MAX || centralTotal >= U32_MAX;
+  const out = new Uint8Array(localTotal + centralTotal + (eocdZip64 ? 76 : 0) + 22);
+  const view = new DataView(out.buffer);
+  let offset = 0;
+  for (const { entry, name: name2, sizeZip64 } of resolved) {
+    view.setUint32(offset, LOCAL_SIG, true);
+    view.setUint16(offset + 4, sizeZip64 ? VERSION_ZIP64 : VERSION, true);
+    view.setUint16(offset + 8, entry.method, true);
+    view.setUint16(offset + 10, DOS_TIME, true);
+    view.setUint16(offset + 12, DOS_DATE, true);
+    view.setUint32(offset + 14, entry.crc, true);
+    view.setUint32(offset + 18, sizeZip64 ? U32_MAX : entry.compressed.length, true);
+    view.setUint32(offset + 22, sizeZip64 ? U32_MAX : entry.uncompressedSize, true);
+    view.setUint16(offset + 26, name2.length, true);
+    view.setUint16(offset + 28, sizeZip64 ? 20 : 0, true);
+    offset += 30;
+    out.set(name2, offset);
+    offset += name2.length;
+    if (sizeZip64) {
+      view.setUint16(offset, ZIP64_EXTRA_ID, true);
+      view.setUint16(offset + 2, 16, true);
+      setU64(view, offset + 4, entry.uncompressedSize);
+      setU64(view, offset + 12, entry.compressed.length);
+      offset += 20;
+    }
+    out.set(entry.compressed, offset);
+    offset += entry.compressed.length;
+  }
+  for (const { entry, name: name2, sizeZip64, offsetZip64, localOffset, centralExtra } of resolved) {
+    view.setUint32(offset, CENTRAL_SIG, true);
+    view.setUint16(offset + 4, VERSION, true);
+    view.setUint16(offset + 6, sizeZip64 || offsetZip64 ? VERSION_ZIP64 : VERSION, true);
+    view.setUint16(offset + 10, entry.method, true);
+    view.setUint16(offset + 12, DOS_TIME, true);
+    view.setUint16(offset + 14, DOS_DATE, true);
+    view.setUint32(offset + 16, entry.crc, true);
+    view.setUint32(offset + 20, sizeZip64 ? U32_MAX : entry.compressed.length, true);
+    view.setUint32(offset + 24, sizeZip64 ? U32_MAX : entry.uncompressedSize, true);
+    view.setUint16(offset + 28, name2.length, true);
+    view.setUint16(offset + 30, centralExtra, true);
+    view.setUint32(offset + 42, offsetZip64 ? U32_MAX : localOffset, true);
+    offset += 46;
+    out.set(name2, offset);
+    offset += name2.length;
+    if (centralExtra > 0) {
+      view.setUint16(offset, ZIP64_EXTRA_ID, true);
+      view.setUint16(offset + 2, centralExtra - 4, true);
+      offset += 4;
+      if (sizeZip64) {
+        setU64(view, offset, entry.uncompressedSize);
+        setU64(view, offset + 8, entry.compressed.length);
+        offset += 16;
+      }
+      if (offsetZip64) {
+        setU64(view, offset, localOffset);
+        offset += 8;
+      }
+    }
+  }
+  if (eocdZip64) {
+    const record = offset;
+    view.setUint32(offset, ZIP64_EOCD_SIG, true);
+    setU64(view, offset + 4, 44);
+    view.setUint16(offset + 12, VERSION_ZIP64, true);
+    view.setUint16(offset + 14, VERSION_ZIP64, true);
+    setU64(view, offset + 24, entries.length);
+    setU64(view, offset + 32, entries.length);
+    setU64(view, offset + 40, centralTotal);
+    setU64(view, offset + 48, centralStart);
+    offset += 56;
+    view.setUint32(offset, ZIP64_LOCATOR_SIG, true);
+    setU64(view, offset + 8, record);
+    view.setUint32(offset + 16, 1, true);
+    offset += 20;
+  }
+  view.setUint32(offset, END_SIG, true);
+  view.setUint16(offset + 8, Math.min(entries.length, U16_MAX), true);
+  view.setUint16(offset + 10, Math.min(entries.length, U16_MAX), true);
+  view.setUint32(offset + 12, Math.min(centralTotal, U32_MAX), true);
+  view.setUint32(offset + 16, Math.min(centralStart, U32_MAX), true);
+  return out;
+}
+
+// src/lib/container.ts
+var LazyParts = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  raw;
+  cache = /* @__PURE__ */ new Map();
+  everything;
+  read(name2, entry) {
+    const cached = this.cache.get(name2);
+    if (cached !== void 0) return cached;
+    const bytes = inflate(entry);
+    this.cache.set(name2, bytes);
+    return bytes;
+  }
+  get(name2) {
+    const entry = this.raw.get(name2);
+    return entry === void 0 ? void 0 : this.read(name2, entry);
+  }
+  has(name2) {
+    return this.raw.has(name2);
+  }
+  get size() {
+    return this.raw.size;
+  }
+  keys() {
+    return this.raw.keys();
+  }
+  // Iterating values or pairs wants every part, so it inflates them all at once.
+  all() {
+    if (this.everything === void 0) {
+      this.everything = /* @__PURE__ */ new Map();
+      for (const [name2, entry] of this.raw) this.everything.set(name2, this.read(name2, entry));
+    }
+    return this.everything;
+  }
+  values() {
+    return this.all().values();
+  }
+  entries() {
+    return this.all().entries();
+  }
+  [Symbol.iterator]() {
+    return this.all()[Symbol.iterator]();
+  }
+  forEach(callback, thisArg) {
+    for (const [name2, bytes] of this.all()) callback.call(thisArg, bytes, name2, this);
+  }
+};
+var OLE2_MAGIC = [208, 207, 17, 224, 161, 177, 26, 225];
+var startsWith = (bytes, magic) => magic.every((byte, index) => bytes[index] === byte);
+function readContainer(bytes) {
+  if (startsWith(bytes, OLE2_MAGIC)) {
+    throw new XlsxError(
+      "not-a-zip",
+      "File is an OLE2 compound file, not an .xlsx. A password-protected workbook must be decrypted first, and a legacy .xls must be converted to .xlsx.",
+      {}
+    );
+  }
+  const entries = /* @__PURE__ */ new Map();
+  for (const entry of readZip(bytes)) {
+    if (entry.name.endsWith("/")) continue;
+    entries.set(entry.name, entry);
+  }
+  return {
+    parts: new LazyParts(entries),
+    write: (changes) => writeChanges(entries, changes)
+  };
+}
+function writeChanges(entries, changes) {
+  const out = [];
+  for (const [name2, entry] of entries) {
+    const change = changes.get(name2);
+    if (change === void 0) out.push(entry);
+    else if (change !== null) out.push(deflate(name2, change));
+  }
+  return writeZip(out);
+}
+function decodeXmlPart(bytes, path) {
+  const misencoded = bytes[0] === 255 || bytes[0] === 254 || bytes[0] === 0 || bytes[1] === 0;
+  if (misencoded) {
+    throw new XlsxError(
+      "unreadable-part",
+      `Part ${path} is not UTF-8 (it looks like UTF-16); every part must be UTF-8 XML`,
+      { part: path }
+    );
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch (cause) {
+    throw new XlsxError("unreadable-part", `Part ${path} is not valid utf-8`, { part: path, cause });
+  }
+}
+
+// src/lib/date.ts
+var MILLISECONDS_PER_DAY = 864e5;
+var EPOCH_1900 = Date.UTC(1899, 11, 31);
+var EPOCH_1904 = Date.UTC(1904, 0, 1);
+var PHANTOM_LEAP_DAY = 60;
+var LAST_SERIAL = 2958465;
+function serialToDate(serial, date1904, at = {}) {
+  if (!Number.isFinite(serial) || serial < 0 || serial > LAST_SERIAL) {
+    throw new XlsxError("invalid-content", `Serial ${serial} is not a date`, at);
+  }
+  const corrected = !date1904 && serial > PHANTOM_LEAP_DAY ? serial - 1 : serial;
+  const epoch = date1904 ? EPOCH_1904 : EPOCH_1900;
+  const asUtc = new Date(Math.round(epoch + corrected * MILLISECONDS_PER_DAY));
+  return new Date(
+    asUtc.getUTCFullYear(),
+    asUtc.getUTCMonth(),
+    asUtc.getUTCDate(),
+    asUtc.getUTCHours(),
+    asUtc.getUTCMinutes(),
+    asUtc.getUTCSeconds(),
+    asUtc.getUTCMilliseconds()
+  );
+}
+var ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?/;
+function parseIsoDate(text) {
+  const match = ISO_DATE.exec(text);
+  if (match === null) return void 0;
+  const [, year, month, day, hours, minutes, seconds, fraction] = match;
+  const milliseconds = fraction === void 0 ? 0 : Math.round(Number(`0.${fraction}`) * 1e3);
+  const date = new Date(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hours ?? 0),
+    Number(minutes ?? 0),
+    Number(seconds ?? 0),
+    milliseconds
+  );
+  if (date.getFullYear() !== Number(year) || date.getMonth() !== Number(month) - 1 || date.getHours() !== Number(hours ?? 0) || date.getMinutes() !== Number(minutes ?? 0) || date.getSeconds() !== Number(seconds ?? 0)) {
+    return void 0;
+  }
+  return date;
+}
+function dateToSerial(date, date1904, at = {}) {
+  const where = at.reference === void 0 ? "" : ` to cell ${at.reference}`;
+  if (Number.isNaN(date.getTime())) {
+    throw new XlsxError("unwritable-value", `Cannot write an invalid date${where}`, at);
+  }
+  const startOfDay = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  const atStartOfDay = date.getTime() === startOfDay.getTime();
+  const asUtc = Date.UTC(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    atStartOfDay ? 0 : date.getHours(),
+    atStartOfDay ? 0 : date.getMinutes(),
+    atStartOfDay ? 0 : date.getSeconds(),
+    atStartOfDay ? 0 : date.getMilliseconds()
+  );
+  const epoch = date1904 ? EPOCH_1904 : EPOCH_1900;
+  const days = (asUtc - epoch) / MILLISECONDS_PER_DAY;
+  if (days < 0) {
+    throw new XlsxError(
+      "unwritable-value",
+      `Cannot write ${date.toDateString()}${where}: it is before ${date1904 ? 1904 : 1900}, which this workbook cannot hold`,
+      at
+    );
+  }
+  const serial = date1904 ? days : days >= PHANTOM_LEAP_DAY ? days + 1 : days;
+  if (serial > LAST_SERIAL) {
+    throw new XlsxError(
+      "unwritable-value",
+      `Cannot write ${date.toDateString()}${where}: it is after 9999, which this workbook cannot hold`,
+      at
+    );
+  }
+  return serial;
+}
+
+// src/lib/reference.ts
+var LAST_COLUMN = 16384;
+var LAST_ROW = 1048576;
+var LETTER_A = "A".charCodeAt(0);
+var isLetter = (character) => character >= "A" && character <= "Z" || character >= "a" && character <= "z";
+var isDigit = (character) => character >= "0" && character <= "9";
+function columnToIndex(letters) {
+  if (letters === "" || !Array.from(letters).every(isLetter)) {
+    throw new XlsxError("bad-reference", `"${letters}" does not name a column`, {
+      reference: letters
+    });
+  }
+  let index = 0;
+  for (const letter of letters.toUpperCase()) {
+    index = index * 26 + (letter.charCodeAt(0) - LETTER_A + 1);
+  }
+  return index;
+}
+function indexToColumn(index) {
+  if (index < 1 || index > LAST_COLUMN) {
+    throw new XlsxError("bad-reference", `Column ${index} is outside the sheet`, {
+      reference: String(index)
+    });
+  }
+  let letters = "";
+  let remaining = index;
+  while (remaining > 0) {
+    const digit = (remaining - 1) % 26;
+    letters = String.fromCharCode(LETTER_A + digit) + letters;
+    remaining = (remaining - 1 - digit) / 26;
+  }
+  return letters;
+}
+function parseReference(reference) {
+  let index = 0;
+  if (reference.charAt(index) === "$") index++;
+  const lettersStart = index;
+  while (index < reference.length && isLetter(reference.charAt(index))) index++;
+  const letters = reference.slice(lettersStart, index);
+  if (reference.charAt(index) === "$") index++;
+  const digitsStart = index;
+  while (index < reference.length && isDigit(reference.charAt(index))) index++;
+  const digits = reference.slice(digitsStart, index);
+  if (letters === "" || digits === "" || index !== reference.length) {
+    throw new XlsxError("bad-reference", `"${reference}" is not a cell reference`, { reference });
+  }
+  return { row: Number(digits), column: columnToIndex(letters) };
+}
+function parseWritableReference(reference) {
+  const address = parseReference(reference);
+  const { row, column } = address;
+  if (row < 1 || row > LAST_ROW || column < 1 || column > LAST_COLUMN) {
+    throw new XlsxError("bad-reference", `"${reference}" is outside the sheet`, { reference });
+  }
+  return address;
+}
+function formatReference(address) {
+  return `${indexToColumn(address.column)}${address.row}`;
+}
+function parseFileReference(reference, context) {
+  try {
+    return parseReference(reference);
+  } catch {
+    throw new XlsxError(
+      "invalid-content",
+      `Cell reference "${reference}" in the file is not a valid reference`,
+      { ...context, reference }
+    );
+  }
+}
+function canonicalReference(address) {
+  if (address.column < 1 || address.column > LAST_COLUMN) return void 0;
+  return formatReference(address);
+}
+
+// src/lib/xml.ts
+var parseError = (message) => new XlsxError("malformed-xml", message, {});
+var ENTITY = /&(?:#x([0-9a-fA-F]+)|#(\d+)|([a-zA-Z][a-zA-Z0-9]*));/g;
+var NAMED_ENTITIES = /* @__PURE__ */ new Map([
+  ["amp", "&"],
+  ["lt", "<"],
+  ["gt", ">"],
+  ["quot", '"'],
+  ["apos", "'"]
+]);
+var HIGHEST_CODE_POINT = 1114111;
+function fromCodePoint(code, reference) {
+  if (code > HIGHEST_CODE_POINT) {
+    throw parseError(`Character reference ${reference} is above the highest code point`);
+  }
+  return String.fromCodePoint(code);
+}
+function decodeEntities(text) {
+  if (!text.includes("&")) return text;
+  return text.replace(
+    ENTITY,
+    (match, hex, decimal, named) => {
+      if (hex !== void 0) return fromCodePoint(Number.parseInt(hex, 16), match);
+      if (decimal !== void 0) return fromCodePoint(Number(decimal), match);
+      if (named !== void 0) return NAMED_ENTITIES.get(named) ?? match;
+      return match;
+    }
+  );
+}
+var isWhitespace = (character) => character === " " || character === "	" || character === "\n" || character === "\r";
+function findTagEnd(source, start) {
+  let quote = null;
+  for (let index = start; index < source.length; index++) {
+    const character = source.charAt(index);
+    if (quote !== null) {
+      if (character === quote) quote = null;
+    } else if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === ">") {
+      return index;
+    }
+  }
+  return -1;
+}
+function parseAttributes(source, tagStart) {
+  const attributes = /* @__PURE__ */ new Map();
+  let index = 0;
+  while (index < source.length) {
+    while (index < source.length && isWhitespace(source.charAt(index))) index++;
+    if (index >= source.length) break;
+    const nameStart = index;
+    while (index < source.length && !isWhitespace(source.charAt(index)) && source.charAt(index) !== "=") {
+      index++;
+    }
+    const name2 = source.slice(nameStart, index);
+    if (name2.length === 0) break;
+    while (index < source.length && isWhitespace(source.charAt(index))) index++;
+    if (source.charAt(index) !== "=") {
+      throw parseError(`Attribute "${name2}" has no value, at offset ${tagStart}`);
+    }
+    index++;
+    while (index < source.length && isWhitespace(source.charAt(index))) index++;
+    const quote = source.charAt(index);
+    if (quote !== '"' && quote !== "'") {
+      throw parseError(`Attribute "${name2}" is not quoted, at offset ${tagStart}`);
+    }
+    index++;
+    const valueStart = index;
+    while (index < source.length && source.charAt(index) !== quote) index++;
+    attributes.set(name2, decodeEntities(source.slice(valueStart, index)));
+    index++;
+  }
+  return attributes;
+}
+var localNameOf = (name2) => {
+  const colon = name2.indexOf(":");
+  return colon === -1 ? name2 : name2.slice(colon + 1);
+};
+function interpretTag(inner, start, end) {
+  if (inner.startsWith("/")) {
+    const name3 = inner.slice(1).trim();
+    return { kind: "close", name: name3, localName: localNameOf(name3), start, end };
+  }
+  const selfClosing = inner.endsWith("/");
+  const body = selfClosing ? inner.slice(0, -1) : inner;
+  let nameEnd = 0;
+  while (nameEnd < body.length && !isWhitespace(body.charAt(nameEnd))) nameEnd++;
+  const name2 = body.slice(0, nameEnd);
+  return {
+    kind: "open",
+    name: name2,
+    localName: localNameOf(name2),
+    attributes: parseAttributes(body.slice(nameEnd), start),
+    selfClosing,
+    start,
+    end
+  };
+}
+function* readXml(source) {
+  let position = 0;
+  while (position < source.length) {
+    const tagStart = source.indexOf("<", position);
+    if (tagStart === -1) {
+      yield {
+        kind: "text",
+        text: decodeEntities(source.slice(position)),
+        start: position,
+        end: source.length
+      };
+      return;
+    }
+    if (tagStart > position) {
+      yield {
+        kind: "text",
+        text: decodeEntities(source.slice(position, tagStart)),
+        start: position,
+        end: tagStart
+      };
+    }
+    position = tagStart;
+    if (source.startsWith("<![CDATA[", position)) {
+      const end = source.indexOf("]]>", position);
+      if (end === -1) throw parseError(`Unterminated CDATA at offset ${position}`);
+      yield { kind: "text", text: source.slice(position + 9, end), start: position, end: end + 3 };
+      position = end + 3;
+      continue;
+    }
+    if (source.startsWith("<!--", position)) {
+      const end = source.indexOf("-->", position);
+      if (end === -1) throw parseError(`Unterminated comment at offset ${position}`);
+      position = end + 3;
+      continue;
+    }
+    if (source.startsWith("<?", position)) {
+      const end = source.indexOf("?>", position);
+      if (end === -1) throw parseError(`Unterminated processing instruction at offset ${position}`);
+      position = end + 2;
+      continue;
+    }
+    if (source.startsWith("<!", position)) {
+      const end = findTagEnd(source, position);
+      if (end === -1) throw parseError(`Unterminated declaration at offset ${position}`);
+      position = end + 1;
+      continue;
+    }
+    const tagEnd = findTagEnd(source, position);
+    if (tagEnd === -1) throw parseError(`Unclosed tag starting at offset ${position}`);
+    const inner = source.slice(position + 1, tagEnd);
+    position = tagEnd + 1;
+    yield interpretTag(inner, tagStart, position);
+  }
+}
+var LESS_THAN = 60;
+var QUOTE = 34;
+var APOSTROPHE = 39;
+var GREATER_THAN = 62;
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+function decodeSpan(bytes, start, end) {
+  for (let index = start; index < end; index++) {
+    const byte = bytes[index];
+    if (byte !== void 0 && byte >= 128) {
+      try {
+        return utf8.decode(bytes.subarray(start, end));
+      } catch (cause) {
+        throw new XlsxError("unreadable-part", `Not valid utf-8, at offset ${start}`, { cause });
+      }
+    }
+  }
+  let text = "";
+  for (let index = start; index < end; index += 8192) {
+    text += String.fromCharCode(...bytes.subarray(index, Math.min(end, index + 8192)));
+  }
+  return text;
+}
+function indexOfSequence(bytes, ascii, from) {
+  const first = ascii.charCodeAt(0);
+  for (let at = bytes.indexOf(first, from); at !== -1; at = bytes.indexOf(first, at + 1)) {
+    if (startsWithAscii(bytes, ascii, at)) return at;
+  }
+  return -1;
+}
+function startsWithAscii(bytes, ascii, at) {
+  for (let index = 0; index < ascii.length; index++) {
+    if (bytes[at + index] !== ascii.charCodeAt(index)) return false;
+  }
+  return true;
+}
+function findTagEndByte(bytes, start) {
+  let quote = 0;
+  for (let index = start; index < bytes.length; index++) {
+    const byte = bytes[index];
+    if (quote !== 0) {
+      if (byte === quote) quote = 0;
+    } else if (byte === QUOTE || byte === APOSTROPHE) {
+      quote = byte;
+    } else if (byte === GREATER_THAN) {
+      return index;
+    }
+  }
+  return -1;
+}
+function* readXmlBytes(source) {
+  let position = 0;
+  while (position < source.length) {
+    const tagStart = source.indexOf(LESS_THAN, position);
+    if (tagStart === -1) {
+      yield {
+        kind: "text",
+        text: decodeEntities(decodeSpan(source, position, source.length)),
+        start: position,
+        end: source.length
+      };
+      return;
+    }
+    if (tagStart > position) {
+      yield {
+        kind: "text",
+        text: decodeEntities(decodeSpan(source, position, tagStart)),
+        start: position,
+        end: tagStart
+      };
+    }
+    position = tagStart;
+    if (startsWithAscii(source, "<![CDATA[", position)) {
+      const end = indexOfSequence(source, "]]>", position);
+      if (end === -1) throw parseError(`Unterminated CDATA at offset ${position}`);
+      yield {
+        kind: "text",
+        text: decodeSpan(source, position + 9, end),
+        start: position,
+        end: end + 3
+      };
+      position = end + 3;
+      continue;
+    }
+    if (startsWithAscii(source, "<!--", position)) {
+      const end = indexOfSequence(source, "-->", position);
+      if (end === -1) throw parseError(`Unterminated comment at offset ${position}`);
+      position = end + 3;
+      continue;
+    }
+    if (startsWithAscii(source, "<?", position)) {
+      const end = indexOfSequence(source, "?>", position);
+      if (end === -1) throw parseError(`Unterminated processing instruction at offset ${position}`);
+      position = end + 2;
+      continue;
+    }
+    if (startsWithAscii(source, "<!", position)) {
+      const end = findTagEndByte(source, position);
+      if (end === -1) throw parseError(`Unterminated declaration at offset ${position}`);
+      position = end + 1;
+      continue;
+    }
+    const tagEnd = findTagEndByte(source, position);
+    if (tagEnd === -1) throw parseError(`Unclosed tag starting at offset ${position}`);
+    const inner = decodeSpan(source, position + 1, tagEnd);
+    position = tagEnd + 1;
+    yield interpretTag(inner, tagStart, position);
+  }
+}
+var name = (code) => `U+${code.toString(16).toUpperCase().padStart(4, "0")}`;
+function findUnwritableCharacter(text) {
+  for (let index = 0; index < text.length; index++) {
+    const code = text.charCodeAt(index);
+    if (code < 32 && code !== 9 && code !== 10 && code !== 13) return name(code);
+    if (code === 65534 || code === 65535) return name(code);
+    if (code >= 55296 && code <= 56319) {
+      const next = text.charCodeAt(index + 1);
+      if (Number.isNaN(next) || next < 56320 || next > 57343) return name(code);
+      index++;
+      continue;
+    }
+    if (code >= 56320 && code <= 57343) return name(code);
+  }
+  return void 0;
+}
+var attributeIn = (name2) => new RegExp(`(\\s${name2}\\s*=\\s*)("[^"]*"|'[^']*')`);
+function withAttribute(openTag, name2, value) {
+  const pattern = attributeIn(name2);
+  if (pattern.test(openTag)) {
+    return openTag.replace(pattern, (_, head, quoted) => {
+      const quote = quoted.charAt(0);
+      return `${head}${quote}${value}${quote}`;
+    });
+  }
+  return openTag.replace(/^<([^\s/>]+)/, `<$1 ${name2}="${value}"`);
+}
+function bumpAttribute(openTag, name2, by) {
+  return openTag.replace(
+    new RegExp(`(\\s${name2}\\s*=\\s*)(["'])(\\d+)\\2`),
+    (_, head, quote, digits) => `${head}${quote}${Number(digits) + by}${quote}`
+  );
+}
+
+// src/lib/patch.ts
+var PROTECTION_PERMISSIONS = [
+  ["selectLockedCells", "selectLockedCells"],
+  ["selectUnlockedCells", "selectUnlockedCells"],
+  ["formatCells", "formatCells"],
+  ["formatColumns", "formatColumns"],
+  ["formatRows", "formatRows"],
+  ["insertColumns", "insertColumns"],
+  ["insertRows", "insertRows"],
+  ["insertHyperlinks", "insertHyperlinks"],
+  ["deleteColumns", "deleteColumns"],
+  ["deleteRows", "deleteRows"],
+  ["sort", "sort"],
+  ["autoFilter", "autoFilter"],
+  ["pivotTables", "pivotTables"]
+];
+function sheetProtectionElement(protection, prefix) {
+  let attributes = ` sheet="1" objects="${protection.editObjects === true ? "0" : "1"}" scenarios="${protection.editScenarios === true ? "0" : "1"}"`;
+  for (const [key, attribute] of PROTECTION_PERMISSIONS) {
+    const permitted = protection[key];
+    if (permitted !== void 0) attributes += ` ${attribute}="${permitted ? "0" : "1"}"`;
+  }
+  return `<${prefix}sheetProtection${attributes}/>`;
+}
+var isPermitted = (value) => value === "0" || value === "false";
+function readSheetProtection(bytes) {
+  for (const event of readXmlBytes(bytes)) {
+    if (event.kind !== "open" || event.localName !== "sheetProtection") continue;
+    if (!isProtected(event.attributes.get("sheet"))) return void 0;
+    const result = {};
+    for (const [key, attribute] of PROTECTION_PERMISSIONS) {
+      const value = event.attributes.get(attribute);
+      if (value !== void 0) result[key] = isPermitted(value);
+    }
+    const objects = event.attributes.get("objects");
+    if (objects !== void 0) result.editObjects = isPermitted(objects);
+    const scenarios = event.attributes.get("scenarios");
+    if (scenarios !== void 0) result.editScenarios = isPermitted(scenarios);
+    return result;
+  }
+  return void 0;
+}
+var isProtected = (value) => value === "1" || value === "true";
+var escapeXml = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\r/g, "&#13;");
+function formulaOf(value, reference, at) {
+  if ("formula" in value && typeof value.formula === "string") return value.formula;
+  throw new XlsxError(
+    "unwritable-value",
+    `Cell ${reference} was given an object that names no string formula`,
+    { ...at, reference }
+  );
+}
+function checkWritable(reference, value, date1904, at = {}) {
+  if (value === null || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new XlsxError("unwritable-value", `Cell ${reference} cannot hold ${value}`, {
+        ...at,
+        reference
+      });
+    }
+    return;
+  }
+  if (value instanceof Date) {
+    dateToSerial(value, date1904, { ...at, reference });
+    return;
+  }
+  if (typeof value !== "string" && (typeof value !== "object" || value === null)) {
+    throw new XlsxError(
+      "unwritable-value",
+      `Cell ${reference} cannot hold a value of type ${typeof value}`,
+      { ...at, reference }
+    );
+  }
+  const unwritable = findUnwritableCharacter(
+    typeof value === "string" ? value : formulaOf(value, reference, at)
+  );
+  if (unwritable !== void 0) {
+    throw new XlsxError(
+      "unwritable-value",
+      `Cell ${reference} holds ${unwritable}, which cannot be written to xml`,
+      { ...at, reference }
+    );
+  }
+}
+function parseMergeRange(ref) {
+  const colon = ref.indexOf(":");
+  if (colon === -1) return void 0;
+  const start = parseReference(ref.slice(0, colon));
+  const end = parseReference(ref.slice(colon + 1));
+  const minRow = Math.min(start.row, end.row);
+  const minColumn = Math.min(start.column, end.column);
+  return {
+    anchor: formatReference({ row: minRow, column: minColumn }),
+    minRow,
+    maxRow: Math.max(start.row, end.row),
+    minColumn,
+    maxColumn: Math.max(start.column, end.column)
+  };
+}
+var canonicalMerge = (merge) => `${merge.anchor}:${formatReference({ row: merge.maxRow, column: merge.maxColumn })}`;
+function mergeRangeReference(range, at = {}) {
+  const parsed = parseMergeRange(range);
+  if (parsed === void 0) {
+    throw new XlsxError("bad-reference", `"${range}" is not an A1:B2 style range to merge`, {
+      ...at,
+      reference: range
+    });
+  }
+  return canonicalMerge(parsed);
+}
+function indexSheet(bytes) {
+  const styles = /* @__PURE__ */ new Map();
+  const sharedFormulas = /* @__PURE__ */ new Map();
+  const shape = readShape(bytes);
+  for (const row of shape.rows) {
+    for (const cell of row.cells) {
+      if (cell.style === void 0 && cell.spillingFormula === void 0) continue;
+      const reference = canonicalReference({ row: row.row, column: cell.column });
+      if (reference === void 0) continue;
+      if (cell.style !== void 0) styles.set(reference, Number(cell.style));
+      if (cell.spillingFormula !== void 0) {
+        sharedFormulas.set(reference, cell.spillingFormula);
+      }
+    }
+  }
+  return { styles, sharedFormulas, merges: shape.merges };
+}
+function mergeAnchorFor(index, reference) {
+  const { row, column } = parseReference(reference);
+  for (const merge of index.merges) {
+    const inside = row >= merge.minRow && row <= merge.maxRow && column >= merge.minColumn && column <= merge.maxColumn;
+    if (inside && merge.anchor !== reference) return merge.anchor;
+  }
+  return void 0;
+}
+function sharedFormulaRefusal(reference, master, at = {}) {
+  const what = master.kind === "shared" ? `defines shared formula ${master.name}` : `holds the ${master.kind === "array" ? "array formula" : "data table"} covering ${master.name}`;
+  return new XlsxError(
+    "unwritable-value",
+    `Cell ${reference} ${what}; overwriting it would break the cells that depend on it`,
+    { ...at, reference }
+  );
+}
+function mergeRefusal(reference, anchor, at = {}) {
+  return new XlsxError(
+    "unwritable-value",
+    `Cell ${reference} is merged into ${anchor}; a value there would never show, so write ${anchor} instead`,
+    { ...at, reference }
+  );
+}
+function cellElement(reference, value, style, date1904, sharedStrings, prefix, at) {
+  checkWritable(reference, value, date1904, at);
+  const attributes = style === void 0 ? "" : ` s="${style}"`;
+  const c = `${prefix}c`;
+  const v = `${prefix}v`;
+  if (value === null) return `<${c} r="${reference}"${attributes}/>`;
+  if (typeof value === "object" && !(value instanceof Date)) {
+    const f = `${prefix}f`;
+    return `<${c} r="${reference}"${attributes}><${f}>${escapeXml(value.formula)}</${f}></${c}>`;
+  }
+  if (typeof value === "string") {
+    const shared = sharedStrings?.get(value);
+    if (shared !== void 0) {
+      return `<${c} r="${reference}"${attributes} t="s"><${v}>${shared}</${v}></${c}>`;
+    }
+    const space = value === value.trim() ? "" : ' xml:space="preserve"';
+    return `<${c} r="${reference}"${attributes} t="inlineStr"><${prefix}is><${prefix}t${space}>${escapeXml(value)}</${prefix}t></${prefix}is></${c}>`;
+  }
+  if (typeof value === "boolean") {
+    return `<${c} r="${reference}"${attributes} t="b"><${v}>${value ? 1 : 0}</${v}></${c}>`;
+  }
+  if (value instanceof Date) {
+    return `<${c} r="${reference}"${attributes}><${v}>${dateToSerial(value, date1904)}</${v}></${c}>`;
+  }
+  return `<${c} r="${reference}"${attributes}><${v}>${value}</${v}></${c}>`;
+}
+function readShape(bytes, at = {}) {
+  const rows = [];
+  const merges = [];
+  let dimension;
+  let contentEnd = -1;
+  let dataStart = -1;
+  let dataEnd = -1;
+  let selfClosing = false;
+  let protection;
+  let mergeOpenStart = -1;
+  let mergeOpenEnd = -1;
+  let mergeInsertAt = -1;
+  let mergeSelfClosing = false;
+  let mergeCount = 0;
+  let colOpenStart = -1;
+  let colOpenEnd = -1;
+  let colInsertAt = -1;
+  let colSelfClosing = false;
+  const cols = [];
+  let prefix = "";
+  let lastRow = 0;
+  let openDimension = -1;
+  let currentRow;
+  let currentCells = [];
+  let cellStart = -1;
+  let cellColumn = 0;
+  let cellStyle;
+  let master;
+  let openCell = false;
+  for (const event of readXmlBytes(bytes)) {
+    if (event.kind === "open") {
+      if (event.localName === "dimension") {
+        const ref = event.attributes.get("ref");
+        if (ref !== void 0) {
+          dimension = { start: event.start, end: event.end, ref };
+          openDimension = event.selfClosing ? -1 : event.start;
+        }
+        continue;
+      }
+      if (event.localName === "sheetData") {
+        const colon = event.name.indexOf(":");
+        prefix = colon === -1 ? "" : event.name.slice(0, colon + 1);
+        dataStart = event.start;
+        selfClosing = event.selfClosing;
+        if (selfClosing) {
+          dataEnd = event.end;
+          contentEnd = event.end;
+        }
+        continue;
+      }
+      if (event.localName === "row") {
+        const declared = event.attributes.get("r");
+        lastRow = declared === void 0 ? lastRow + 1 : Number(declared);
+        currentRow = { row: lastRow, start: event.start, openEnd: event.end };
+        currentCells = [];
+        cellColumn = 0;
+        if (event.selfClosing) {
+          rows.push({
+            ...currentRow,
+            contentEnd: event.end,
+            end: event.end,
+            selfClosing: true,
+            cells: []
+          });
+          currentRow = void 0;
+        }
+        continue;
+      }
+      if (event.localName === "c") {
+        const reference = event.attributes.get("r");
+        cellColumn = reference === void 0 ? cellColumn + 1 : parseFileReference(reference, at).column;
+        cellStyle = event.attributes.get("s");
+        cellStart = event.start;
+        master = void 0;
+        openCell = !event.selfClosing;
+        if (event.selfClosing) {
+          currentCells.push({
+            column: cellColumn,
+            start: event.start,
+            end: event.end,
+            style: cellStyle,
+            spillingFormula: void 0
+          });
+        }
+      }
+      if (event.localName === "cols") {
+        colOpenStart = event.start;
+        colOpenEnd = event.end;
+        colSelfClosing = event.selfClosing;
+        if (event.selfClosing) colInsertAt = event.end;
+        continue;
+      }
+      if (event.localName === "col") {
+        const min = Number(event.attributes.get("min"));
+        const max = Number(event.attributes.get("max"));
+        if (Number.isInteger(min) && Number.isInteger(max)) {
+          cols.push({ start: event.start, end: event.end, min, max });
+        }
+        continue;
+      }
+      if (event.localName === "mergeCells") {
+        mergeOpenStart = event.start;
+        mergeOpenEnd = event.end;
+        mergeSelfClosing = event.selfClosing;
+        if (event.selfClosing) mergeInsertAt = event.end;
+        continue;
+      }
+      if (event.localName === "mergeCell") {
+        mergeCount++;
+        const ref = event.attributes.get("ref");
+        const merge = ref === void 0 ? void 0 : parseMergeRange(ref);
+        if (merge !== void 0) merges.push(merge);
+        continue;
+      }
+      if (event.localName === "sheetProtection") {
+        protection = { start: event.start, end: event.end };
+        continue;
+      }
+      if (event.localName === "f") {
+        const kind = event.attributes.get("t");
+        const covers = event.attributes.get("ref");
+        if (covers !== void 0) {
+          if (kind === "shared") {
+            const si = event.attributes.get("si");
+            if (si !== void 0) master = { kind: "shared", name: si };
+          } else if (kind === "array" || kind === "dataTable") {
+            master = { kind, name: covers };
+          }
+        }
+      }
+      continue;
+    }
+    if (event.kind !== "close") continue;
+    if (event.localName === "c" && openCell) {
+      currentCells.push({
+        column: cellColumn,
+        start: cellStart,
+        end: event.end,
+        style: cellStyle,
+        spillingFormula: master
+      });
+      openCell = false;
+      continue;
+    }
+    if (event.localName === "row" && currentRow !== void 0) {
+      rows.push({
+        ...currentRow,
+        contentEnd: event.start,
+        end: event.end,
+        selfClosing: false,
+        cells: currentCells
+      });
+      currentRow = void 0;
+      continue;
+    }
+    if (event.localName === "dimension" && openDimension !== -1 && dimension !== void 0) {
+      dimension = { start: openDimension, end: event.end, ref: dimension.ref };
+      openDimension = -1;
+      continue;
+    }
+    if (event.localName === "sheetData") {
+      contentEnd = event.start;
+      dataEnd = event.end;
+    }
+    if (event.localName === "mergeCells") mergeInsertAt = event.start;
+    if (event.localName === "cols") colInsertAt = event.start;
+  }
+  if (dataStart === -1)
+    throw new XlsxError("malformed-xml", "Sheet has no sheetData element to write into", at);
+  return {
+    prefix,
+    dimension,
+    rows,
+    merges,
+    contentEnd,
+    selfClosing,
+    dataStart,
+    dataEnd,
+    protection,
+    mergeContainer: mergeOpenStart === -1 ? void 0 : {
+      openStart: mergeOpenStart,
+      openEnd: mergeOpenEnd,
+      insertAt: mergeInsertAt,
+      selfClosing: mergeSelfClosing,
+      count: mergeCount
+    },
+    colContainer: colOpenStart === -1 ? void 0 : {
+      openStart: colOpenStart,
+      openEnd: colOpenEnd,
+      insertAt: colInsertAt,
+      selfClosing: colSelfClosing
+    },
+    cols
+  };
+}
+function patchSheet(bytes, edits, date1904, sharedStrings, styleOverrides, at = {}, sheet = {}) {
+  const { protection, merges } = sheet;
+  const restyleRefs = styleOverrides === void 0 ? [] : [...styleOverrides.keys()].filter((ref) => !edits.has(ref));
+  const newMerges = merges ?? [];
+  const rowHeights = sheet.rowHeights ?? /* @__PURE__ */ new Map();
+  const columnWidths = sheet.columnWidths ?? /* @__PURE__ */ new Map();
+  if (edits.size === 0 && restyleRefs.length === 0 && protection === void 0 && newMerges.length === 0 && rowHeights.size === 0 && columnWidths.size === 0) {
+    return bytes;
+  }
+  const heightAttributes = (row) => {
+    const height = rowHeights.get(row);
+    return height === void 0 ? "" : ` ht="${height}" customHeight="1"`;
+  };
+  const operations = [
+    ...[...edits].map(([given, value]) => ({ given, value, restyle: false })),
+    ...restyleRefs.map((given) => ({
+      given,
+      value: null,
+      restyle: true
+    }))
+  ];
+  const shape = readShape(bytes, at);
+  const splices = [];
+  const newRows = /* @__PURE__ */ new Map();
+  const filledRows = /* @__PURE__ */ new Map();
+  const styleFor = (reference, current) => {
+    const override = styleOverrides?.get(reference);
+    return override === void 0 ? current : String(override);
+  };
+  const rowsByNumber = /* @__PURE__ */ new Map();
+  for (const candidate of shape.rows) rowsByNumber.set(candidate.row, candidate);
+  const cellIndexes = /* @__PURE__ */ new Map();
+  const cellsOf = (span) => {
+    const known = cellIndexes.get(span);
+    if (known !== void 0) return known;
+    const built = /* @__PURE__ */ new Map();
+    for (const candidate of span.cells) built.set(candidate.column, candidate);
+    cellIndexes.set(span, built);
+    return built;
+  };
+  for (const { given, value, restyle } of operations) {
+    const address = parseReference(given);
+    const { row, column } = address;
+    const reference = formatReference(address);
+    const existingRow = rowsByNumber.get(row);
+    if (existingRow === void 0) {
+      const pending = newRows.get(row) ?? [];
+      pending.push(
+        cellElement(
+          reference,
+          value,
+          styleFor(reference, void 0),
+          date1904,
+          sharedStrings,
+          shape.prefix,
+          at
+        )
+      );
+      newRows.set(row, pending);
+      continue;
+    }
+    const existingCell = cellsOf(existingRow).get(column);
+    if (existingCell !== void 0 && restyle) {
+      const override = styleOverrides?.get(reference);
+      if (override !== void 0) {
+        const element = decoder.decode(bytes.subarray(existingCell.start, existingCell.end));
+        const openEnd = element.indexOf(">") + 1;
+        splices.push({
+          start: existingCell.start,
+          end: existingCell.end,
+          text: withAttribute(element.slice(0, openEnd), "s", override) + element.slice(openEnd),
+          order: column
+        });
+      }
+      continue;
+    }
+    if (existingCell?.spillingFormula !== void 0) {
+      throw sharedFormulaRefusal(reference, existingCell.spillingFormula, at);
+    }
+    if (existingCell !== void 0) {
+      splices.push({
+        start: existingCell.start,
+        end: existingCell.end,
+        text: cellElement(
+          reference,
+          value,
+          styleFor(reference, existingCell.style),
+          date1904,
+          sharedStrings,
+          shape.prefix,
+          at
+        ),
+        order: column
+      });
+      continue;
+    }
+    const cell = cellElement(
+      reference,
+      value,
+      styleFor(reference, void 0),
+      date1904,
+      sharedStrings,
+      shape.prefix,
+      at
+    );
+    if (existingRow.selfClosing) {
+      const pending = filledRows.get(existingRow) ?? [];
+      pending.push({ column, cell });
+      filledRows.set(existingRow, pending);
+      continue;
+    }
+    const next = existingRow.cells.find((candidate) => candidate.column > column);
+    const insertAt = next === void 0 ? existingRow.contentEnd : next.start;
+    splices.push({ start: insertAt, end: insertAt, text: cell, order: column });
+  }
+  for (const [row, cells] of filledRows) {
+    const ordered = [...cells].sort((left, right) => left.column - right.column).map((entry) => entry.cell).join("");
+    const height = rowHeights.get(row.row);
+    const openTag = decoder.decode(bytes.subarray(row.start, row.end));
+    const opened = height === void 0 ? openTag : withAttribute(withAttribute(openTag, "ht", height), "customHeight", 1);
+    splices.push({
+      start: row.start,
+      end: row.end,
+      text: `${opened.slice(0, -2)}>${ordered}</${shape.prefix}row>`,
+      order: row.row
+    });
+  }
+  for (const row of rowHeights.keys()) {
+    if (!rowsByNumber.has(row) && !newRows.has(row)) newRows.set(row, []);
+  }
+  for (const row of rowHeights.keys()) {
+    const span = rowsByNumber.get(row);
+    const height = rowHeights.get(row);
+    if (span === void 0 || height === void 0 || filledRows.has(span)) continue;
+    const openTag = decoder.decode(bytes.subarray(span.start, span.openEnd));
+    splices.push({
+      start: span.start,
+      end: span.openEnd,
+      text: withAttribute(withAttribute(openTag, "ht", height), "customHeight", 1),
+      order: span.row
+    });
+  }
+  const buildRow = (row, cells) => {
+    const ordered = cells.map((text) => ({ text, column: parseReference(cellReferenceOf(text)).column })).sort((a, b) => a.column - b.column).map((entry) => entry.text).join("");
+    return `<${shape.prefix}row r="${row}"${heightAttributes(row)}>${ordered}</${shape.prefix}row>`;
+  };
+  if (shape.selfClosing && newRows.size > 0) {
+    const body = [...newRows].sort(([left], [right]) => left - right).map(([row, cells]) => buildRow(row, cells)).join("");
+    splices.push({
+      start: shape.dataStart,
+      end: shape.dataEnd,
+      text: `<${shape.prefix}sheetData>${body}</${shape.prefix}sheetData>`,
+      order: 0
+    });
+  } else {
+    let cursor = 0;
+    let next = shape.rows[cursor];
+    for (const [row, cells] of [...newRows].sort(([left], [right]) => left - right)) {
+      while (next !== void 0 && next.row <= row) {
+        cursor++;
+        next = shape.rows[cursor];
+      }
+      const offset = next === void 0 ? shape.contentEnd : next.start;
+      splices.push({ start: offset, end: offset, text: buildRow(row, cells), order: row });
+    }
+  }
+  const widened = widenDimension(shape.dimension, [...edits.keys()]);
+  if (widened !== void 0 && shape.dimension !== void 0) {
+    splices.push({
+      start: shape.dimension.start,
+      end: shape.dimension.end,
+      text: `<${shape.prefix}dimension ref="${widened}"/>`,
+      order: -1
+    });
+  }
+  if (protection === "remove") {
+    if (shape.protection !== void 0) {
+      splices.push({
+        start: shape.protection.start,
+        end: shape.protection.end,
+        text: "",
+        order: -1
+      });
+    }
+  } else if (protection !== void 0) {
+    const span = shape.protection ?? { start: shape.dataEnd, end: shape.dataEnd };
+    splices.push({
+      start: span.start,
+      end: span.end,
+      text: sheetProtectionElement(protection, shape.prefix),
+      order: -1
+    });
+  }
+  if (newMerges.length > 0) {
+    const seen = new Set(shape.merges.map(canonicalMerge));
+    const fresh = [];
+    for (const range of newMerges) {
+      if (seen.has(range)) continue;
+      seen.add(range);
+      fresh.push(range);
+    }
+    if (fresh.length > 0) {
+      const children = fresh.map((ref) => `<${shape.prefix}mergeCell ref="${ref}"/>`).join("");
+      const container = shape.mergeContainer;
+      if (container === void 0) {
+        const anchor = shape.protection?.end ?? shape.dataEnd;
+        splices.push({
+          start: anchor,
+          end: anchor,
+          text: `<${shape.prefix}mergeCells count="${fresh.length}">${children}</${shape.prefix}mergeCells>`,
+          order: 0
+        });
+      } else {
+        const openTag = decoder.decode(bytes.subarray(container.openStart, container.openEnd));
+        const counted = withAttribute(openTag, "count", container.count + fresh.length);
+        if (container.selfClosing) {
+          splices.push({
+            start: container.openStart,
+            end: container.openEnd,
+            text: `${counted.slice(0, -2)}>${children}</${shape.prefix}mergeCells>`,
+            order: -1
+          });
+        } else {
+          splices.push({
+            start: container.openStart,
+            end: container.openEnd,
+            text: counted,
+            order: -1
+          });
+          splices.push({
+            start: container.insertAt,
+            end: container.insertAt,
+            text: children,
+            order: 0
+          });
+        }
+      }
+    }
+  }
+  if (columnWidths.size > 0) {
+    const colElement = (min, max, width) => `<${shape.prefix}col min="${min}" max="${max}" width="${width}" customWidth="1"/>`;
+    const colWith = (element, min, max, width) => {
+      const ranged = withAttribute(withAttribute(element, "min", min), "max", max);
+      return width === void 0 ? ranged : withAttribute(withAttribute(ranged, "width", width), "customWidth", 1);
+    };
+    const covering = (column) => shape.cols.find((c) => c.min <= column && column <= c.max);
+    const bySpan = /* @__PURE__ */ new Map();
+    const appends = /* @__PURE__ */ new Map();
+    for (const [column, width] of columnWidths) {
+      const span = covering(column);
+      if (span === void 0) {
+        appends.set(column, width);
+        continue;
+      }
+      const grouped = bySpan.get(span) ?? /* @__PURE__ */ new Map();
+      grouped.set(column, width);
+      bySpan.set(span, grouped);
+    }
+    for (const [span, widths] of bySpan) {
+      const element = decoder.decode(bytes.subarray(span.start, span.end));
+      const segments = [];
+      let cursor = span.min;
+      for (const [column, width] of [...widths].sort(([a], [b]) => a - b)) {
+        if (column > cursor) segments.push(colWith(element, cursor, column - 1));
+        segments.push(colWith(element, column, column, width));
+        cursor = column + 1;
+      }
+      if (cursor <= span.max) segments.push(colWith(element, cursor, span.max));
+      splices.push({ start: span.start, end: span.end, text: segments.join(""), order: span.min });
+    }
+    if (appends.size > 0) {
+      const added = [...appends].sort(([a], [b]) => a - b).map(([column, width]) => colElement(column, column, width)).join("");
+      const container = shape.colContainer;
+      if (container === void 0) {
+        splices.push({
+          start: shape.dataStart,
+          end: shape.dataStart,
+          text: `<${shape.prefix}cols>${added}</${shape.prefix}cols>`,
+          order: -2
+        });
+      } else if (container.selfClosing) {
+        const openTag = decoder.decode(bytes.subarray(container.openStart, container.openEnd));
+        splices.push({
+          start: container.openStart,
+          end: container.openEnd,
+          text: `${openTag.slice(0, -2)}>${added}</${shape.prefix}cols>`,
+          order: -1
+        });
+      } else {
+        splices.push({ start: container.insertAt, end: container.insertAt, text: added, order: 1 });
+      }
+    }
+  }
+  return applySplices(bytes, splices);
+}
+function widenDimension(dimension, references) {
+  if (dimension === void 0) return void 0;
+  const bounds = dimension.ref.split(":");
+  const from = bounds[0] ?? "";
+  if (from === "") return void 0;
+  try {
+    const topLeft = parseReference(from);
+    const bottomRight = parseReference(bounds[1] ?? from);
+    let { row: lastRow, column: lastColumn } = bottomRight;
+    let { row: firstRow, column: firstColumn } = topLeft;
+    for (const reference of references) {
+      const { row, column } = parseReference(reference);
+      firstRow = Math.min(firstRow, row);
+      firstColumn = Math.min(firstColumn, column);
+      lastRow = Math.max(lastRow, row);
+      lastColumn = Math.max(lastColumn, column);
+    }
+    const grown = firstRow !== topLeft.row || firstColumn !== topLeft.column || lastRow !== bottomRight.row || lastColumn !== bottomRight.column;
+    if (!grown) return void 0;
+    const start = formatReference({ row: firstRow, column: firstColumn });
+    const end = formatReference({ row: lastRow, column: lastColumn });
+    return `${start}:${end}`;
+  } catch {
+    return void 0;
+  }
+}
+function cellReferenceOf(element) {
+  const start = element.indexOf('"') + 1;
+  return element.slice(start, element.indexOf('"', start));
+}
+var decoder = new TextDecoder();
+var encoder = new TextEncoder();
+function applySplices(bytes, splices) {
+  const ordered = [...splices].sort((a, b) => a.start - b.start || a.order - b.order);
+  const pieces = [];
+  let cursor = 0;
+  for (const splice of ordered) {
+    pieces.push(bytes.subarray(cursor, splice.start));
+    pieces.push(encoder.encode(splice.text));
+    cursor = splice.end;
+  }
+  pieces.push(bytes.subarray(cursor));
+  let length = 0;
+  for (const piece of pieces) length += piece.length;
+  const out = new Uint8Array(length);
+  let offset = 0;
+  for (const piece of pieces) {
+    out.set(piece, offset);
+    offset += piece.length;
+  }
+  return out;
+}
+
+// src/lib/relationships.ts
+function readRelationships(xml, part) {
+  const relationships = /* @__PURE__ */ new Map();
+  for (const event of readXml(xml)) {
+    if (event.kind !== "open" || event.localName !== "Relationship") continue;
+    const id = event.attributes.get("Id");
+    if (id === void 0)
+      throw new XlsxError("malformed-xml", "Relationship is missing Id", { part });
+    const target = event.attributes.get("Target");
+    if (target === void 0)
+      throw new XlsxError("malformed-xml", `Relationship ${id} is missing Target`, { part });
+    relationships.set(id, {
+      id,
+      type: event.attributes.get("Type") ?? "",
+      target,
+      external: event.attributes.get("TargetMode") === "External"
+    });
+  }
+  return relationships;
+}
+function resolveTarget(ownerPath, target) {
+  if (target.startsWith("/")) return target.slice(1);
+  const ownerFolder = ownerPath.split("/").slice(0, -1);
+  const segments = ownerPath === "" ? [] : ownerFolder;
+  for (const segment of target.split("/")) {
+    if (segment === "." || segment === "") continue;
+    if (segment === "..") segments.pop();
+    else segments.push(segment);
+  }
+  return segments.join("/");
+}
+
+// src/lib/sheet.ts
+function* readSheet(bytes, sharedStrings, at = {}) {
+  let row = 0;
+  let column = 0;
+  let type = "";
+  let styleIndex;
+  let reference;
+  let rawValue = null;
+  let formula = null;
+  let sharedIndex;
+  let ownsSharedRange = false;
+  let inlineText = null;
+  let inValue = false;
+  let inFormula = false;
+  let inInlineText = false;
+  let inPhonetic = false;
+  const finishCell = () => {
+    const address = reference === void 0 ? { row, column } : parseFileReference(reference, at);
+    const written = reference ?? formatReference(address);
+    column = address.column;
+    return {
+      address,
+      reference: written,
+      value: toValue(type, rawValue, inlineText, sharedStrings, written, at),
+      ...formula === null ? {} : { formula: formula.join("") },
+      ...sharedIndex === void 0 ? {} : { sharedIndex, ownsSharedRange },
+      ...styleIndex === void 0 ? {} : { styleIndex }
+    };
+  };
+  for (const event of readXmlBytes(bytes)) {
+    if (event.kind === "open") {
+      switch (event.localName) {
+        case "row": {
+          const declared = event.attributes.get("r");
+          row = declared === void 0 ? row + 1 : Number(declared);
+          column = 0;
+          break;
+        }
+        case "c": {
+          reference = event.attributes.get("r");
+          type = event.attributes.get("t") ?? "n";
+          const style = event.attributes.get("s");
+          styleIndex = style === void 0 ? void 0 : Number(style);
+          rawValue = null;
+          formula = null;
+          sharedIndex = void 0;
+          ownsSharedRange = false;
+          inlineText = null;
+          inPhonetic = false;
+          column++;
+          if (event.selfClosing) yield finishCell();
+          break;
+        }
+        case "v":
+          rawValue = [];
+          inValue = !event.selfClosing;
+          break;
+        case "f":
+          formula = [];
+          inFormula = !event.selfClosing;
+          if (event.attributes.get("t") === "shared") {
+            sharedIndex = event.attributes.get("si");
+            ownsSharedRange = event.attributes.get("ref") !== void 0;
+          }
+          break;
+        case "rPh":
+          inPhonetic = true;
+          break;
+        case "t":
+          inlineText ??= [];
+          inInlineText = !event.selfClosing && !inPhonetic;
+          break;
+      }
+      continue;
+    }
+    if (event.kind === "text") {
+      if (inValue && rawValue !== null) rawValue.push(event.text);
+      else if (inFormula && formula !== null) formula.push(event.text);
+      else if (inInlineText && inlineText !== null) inlineText.push(event.text);
+      continue;
+    }
+    switch (event.localName) {
+      case "v":
+        inValue = false;
+        break;
+      case "f":
+        inFormula = false;
+        break;
+      case "t":
+        inInlineText = false;
+        break;
+      case "rPh":
+        inPhonetic = false;
+        break;
+      case "c":
+        yield finishCell();
+        break;
+    }
+  }
+}
+function toValue(type, rawValue, inlineText, sharedStrings, reference, at) {
+  if (type === "inlineStr") {
+    return { kind: "text", value: inlineText === null ? "" : inlineText.join("") };
+  }
+  if (rawValue === null) return { kind: "empty" };
+  const raw = rawValue.join("");
+  switch (type) {
+    case "s": {
+      const value = sharedStrings[Number(raw)];
+      if (value === void 0) {
+        throw new XlsxError(
+          "invalid-content",
+          `Cell ${reference} references shared string ${raw}, which the table does not hold`,
+          { ...at, reference }
+        );
+      }
+      return { kind: "text", value };
+    }
+    case "str":
+      return { kind: "text", value: raw };
+    case "d":
+      return { kind: "date", value: raw };
+    case "b":
+      return { kind: "boolean", value: raw === "1" };
+    case "e":
+      return { kind: "error", value: raw };
+    default: {
+      if (raw === "") return { kind: "empty" };
+      const value = Number(raw);
+      if (Number.isNaN(value)) {
+        throw new XlsxError(
+          "invalid-content",
+          `Cell ${reference} holds "${raw}", which is not a number`,
+          { ...at, reference }
+        );
+      }
+      return { kind: "number", value };
+    }
+  }
+}
+
+// src/lib/shared-strings.ts
+function readEntries(xml) {
+  const entries = [];
+  let current = null;
+  let plain = true;
+  let inPhonetic = false;
+  let inText = false;
+  for (const event of readXml(xml)) {
+    if (event.kind === "open") {
+      if (event.localName === "si") {
+        current = [];
+        plain = true;
+      } else if (event.localName === "rPh") {
+        inPhonetic = true;
+        plain = false;
+      } else if (event.localName === "r") plain = false;
+      else if (event.localName === "t" && !event.selfClosing) inText = !inPhonetic;
+      continue;
+    }
+    if (event.kind === "text") {
+      if (inText && current !== null) current.push(event.text);
+      continue;
+    }
+    if (event.localName === "t") inText = false;
+    else if (event.localName === "rPh") inPhonetic = false;
+    else if (event.localName === "si" && current !== null) {
+      entries.push({ text: current.join(""), plain });
+      current = null;
+    }
+  }
+  return entries;
+}
+function readSharedStrings(xml) {
+  return readEntries(xml).map((entry) => entry.text);
+}
+var escapeXml2 = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\r/g, "&#13;");
+function entryFor(value, prefix) {
+  const unwritable = findUnwritableCharacter(value);
+  if (unwritable !== void 0) {
+    throw new XlsxError(
+      "unwritable-value",
+      `A string holds ${unwritable}, which cannot be written to xml`,
+      { part: "xl/sharedStrings.xml" }
+    );
+  }
+  const needsPreserve = value !== value.trim();
+  const attributes = needsPreserve ? ' xml:space="preserve"' : "";
+  return `<${prefix}si><${prefix}t${attributes}>${escapeXml2(value)}</${prefix}t></${prefix}si>`;
+}
+function appendSharedStrings(xml, strings) {
+  const existing = readEntries(xml);
+  const indexes = /* @__PURE__ */ new Map();
+  for (const [index, entry] of existing.entries()) {
+    if (entry.plain && !indexes.has(entry.text)) indexes.set(entry.text, index);
+  }
+  let openTag = "";
+  let insertAt = -1;
+  let closeLength = 0;
+  let prefix = "";
+  for (const event of readXml(xml)) {
+    if (event.kind === "open" && event.localName === "sst") {
+      openTag = xml.slice(event.start, event.end);
+      const colon = event.name.indexOf(":");
+      prefix = colon === -1 ? "" : event.name.slice(0, colon + 1);
+      if (event.selfClosing) {
+        insertAt = event.end;
+        closeLength = event.end - event.start;
+      }
+      continue;
+    }
+    if (event.kind === "close" && event.localName === "sst") {
+      insertAt = event.start;
+      closeLength = 0;
+    }
+  }
+  const additions = [];
+  const requested = /* @__PURE__ */ new Map();
+  for (const value of strings) {
+    const known = indexes.get(value);
+    if (known !== void 0) {
+      requested.set(value, known);
+      continue;
+    }
+    const index = existing.length + additions.length;
+    indexes.set(value, index);
+    requested.set(value, index);
+    additions.push(entryFor(value, prefix));
+  }
+  if (additions.length === 0) return { xml, indexes: requested };
+  if (insertAt === -1)
+    throw new XlsxError("malformed-xml", "Shared string table has no sst element", {
+      part: "xl/sharedStrings.xml"
+    });
+  const updatedTag = bumpAttribute(
+    bumpAttribute(openTag, "uniqueCount", additions.length),
+    "count",
+    additions.length
+  );
+  const body = additions.join("");
+  if (closeLength > 0) {
+    const opened = `${updatedTag.slice(0, -2)}>`;
+    return {
+      xml: `${xml.slice(0, insertAt - closeLength)}${opened}${body}</${prefix}sst>${xml.slice(insertAt)}`,
+      indexes: requested
+    };
+  }
+  const head = xml.slice(0, insertAt).replace(openTag, updatedTag);
+  return { xml: `${head}${body}${xml.slice(insertAt)}`, indexes: requested };
+}
+
+// src/lib/tables.ts
+function extendTables(sheetBytes, sheetPath, container, written) {
+  const paths = tablePartPaths(sheetBytes, sheetPath, container);
+  if (paths.length === 0) return [];
+  const cells = new Set(written);
+  const tables = paths.map((path) => decodeTable(container, path)).filter((table) => table !== void 0);
+  const ranges = tables.map((table) => table.range);
+  const extensions = [];
+  for (const table of tables) {
+    const grown = grow(table, cells, ranges);
+    if (grown !== void 0) extensions.push({ path: table.path, xml: grown });
+  }
+  return extensions;
+}
+function tablePartPaths(sheetBytes, sheetPath, container) {
+  const ids = [];
+  for (const event of readXmlBytes(sheetBytes)) {
+    if (event.kind !== "open" || event.localName !== "tablePart") continue;
+    const id = relationshipId(event.attributes);
+    if (id !== void 0) ids.push(id);
+  }
+  if (ids.length === 0) return [];
+  const relsPath = sheetPath.replace(/([^/]+)$/, "_rels/$1.rels");
+  const relsBytes = container.parts.get(relsPath);
+  if (relsBytes === void 0) return [];
+  const relationships = readRelationships(decode(relsBytes), relsPath);
+  const paths = [];
+  for (const id of ids) {
+    const target = relationships.get(id)?.target;
+    if (target !== void 0) paths.push(resolveTarget(sheetPath, target));
+  }
+  return paths;
+}
+var decode = (bytes) => new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+function decodeTable(container, path) {
+  const bytes = container.parts.get(path);
+  if (bytes === void 0) return void 0;
+  let xml;
+  try {
+    xml = decode(bytes);
+  } catch {
+    return void 0;
+  }
+  let range;
+  let hasTotalsRow = false;
+  const columnNames = [];
+  const columnIds = [];
+  for (const event of readXml(xml)) {
+    if (event.kind !== "open") continue;
+    if (event.localName === "table") {
+      const ref = event.attributes.get("ref");
+      range = ref === void 0 ? void 0 : parseRange(ref);
+      if (range === void 0) return void 0;
+      const totals = event.attributes.get("totalsRowCount");
+      hasTotalsRow = totals !== void 0 && totals !== "0";
+    }
+    if (event.localName === "tableColumn") {
+      const name2 = event.attributes.get("name");
+      if (name2 !== void 0) columnNames.push(name2);
+      const id = Number(event.attributes.get("id"));
+      if (Number.isInteger(id)) columnIds.push(id);
+    }
+  }
+  if (range === void 0) return void 0;
+  return { path, xml, range, hasTotalsRow, columnNames, columnIds };
+}
+function parseRange(ref) {
+  const colon = ref.indexOf(":");
+  if (colon === -1) return void 0;
+  try {
+    const start = parseReference(ref.slice(0, colon));
+    const end = parseReference(ref.slice(colon + 1));
+    return {
+      minRow: Math.min(start.row, end.row),
+      maxRow: Math.max(start.row, end.row),
+      minColumn: Math.min(start.column, end.column),
+      maxColumn: Math.max(start.column, end.column)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function grow(table, written, all) {
+  if (table.hasTotalsRow) return void 0;
+  const { range } = table;
+  const others = all.filter((candidate) => candidate !== range);
+  const rowWritten = (row) => spanWritten(written, row, row, range.minColumn, range.maxColumn);
+  const columnHasWrite = (column) => spanWritten(written, range.minRow, range.maxRow, column, column);
+  const overlaps = (r) => others.some(
+    (other) => r.minRow <= other.maxRow && r.maxRow >= other.minRow && r.minColumn <= other.maxColumn && r.maxColumn >= other.minColumn
+  );
+  const downTo = (row) => ({ ...range, maxRow: row });
+  const rightTo = (column) => ({ ...range, maxColumn: column });
+  let maxRow = range.maxRow;
+  while (rowWritten(maxRow + 1) && !overlaps(downTo(maxRow + 1))) maxRow++;
+  let maxColumn = range.maxColumn;
+  while (columnHasWrite(maxColumn + 1) && !overlaps(rightTo(maxColumn + 1))) maxColumn++;
+  if (maxRow === range.maxRow && maxColumn === range.maxColumn) return void 0;
+  const oldRef = refOf(range);
+  const newRef = refOf({ ...range, maxRow, maxColumn });
+  let xml = rewriteRefs(table.xml, oldRef, newRef);
+  if (maxColumn > range.maxColumn) {
+    xml = addColumns(xml, maxColumn - range.maxColumn, table.columnIds, table.columnNames);
+  }
+  return xml;
+}
+var refOf = (range) => `${formatReference({ row: range.minRow, column: range.minColumn })}:${formatReference({ row: range.maxRow, column: range.maxColumn })}`;
+function spanWritten(written, minRow, maxRow, minColumn, maxColumn) {
+  for (let row = minRow; row <= maxRow; row++) {
+    for (let column = minColumn; column <= maxColumn; column++) {
+      if (written.has(formatReference({ row, column }))) return true;
+    }
+  }
+  return false;
+}
+function freshColumnName(taken) {
+  let n = 1;
+  while (taken.has(`column${n}`)) n++;
+  return `Column${n}`;
+}
+function addColumns(xml, count, ids, names) {
+  const taken = new Set(names.map((name2) => name2.toLowerCase()));
+  let nextId = Math.max(0, ...ids) + 1;
+  const added = [];
+  for (let index = 0; index < count; index++) {
+    const name2 = freshColumnName(taken);
+    taken.add(name2.toLowerCase());
+    added.push(`<tableColumn id="${nextId++}" name="${name2}"/>`);
+  }
+  const elements = added.join("");
+  let prefix = "";
+  let insertAt = -1;
+  let countStart = -1;
+  let countEnd = -1;
+  for (const event of readXml(xml)) {
+    if (event.kind === "open" && event.localName === "tableColumns") {
+      const colon = event.name.indexOf(":");
+      prefix = colon === -1 ? "" : event.name.slice(0, colon + 1);
+      countStart = event.start;
+      countEnd = event.end;
+    }
+    if (event.kind === "close" && event.localName === "tableColumns") insertAt = event.start;
+  }
+  if (insertAt === -1 || countStart === -1) return xml;
+  const openTag = withAttribute(xml.slice(countStart, countEnd), "count", names.length + count);
+  const prefixed = elements.replace(/<tableColumn /g, `<${prefix}tableColumn `);
+  return xml.slice(0, countStart) + openTag + xml.slice(countEnd, insertAt) + prefixed + xml.slice(insertAt);
+}
+function rewriteRefs(xml, oldRef, newRef) {
+  let out = "";
+  let position = 0;
+  for (const event of readXml(xml)) {
+    if (event.kind !== "open") continue;
+    if (event.localName !== "table" && event.localName !== "autoFilter") continue;
+    const tag = xml.slice(event.start, event.end);
+    const replaced = tag.replace(
+      /(\sref\s*=\s*)("[^"]*"|'[^']*')/,
+      (whole, head, quoted) => {
+        const value = quoted.slice(1, -1);
+        if (value !== oldRef) return whole;
+        const quote = quoted.charAt(0);
+        return `${head}${quote}${newRef}${quote}`;
+      }
+    );
+    out += xml.slice(position, event.start) + replaced;
+    position = event.end;
+  }
+  return out + xml.slice(position);
+}
+function relationshipId(attributes) {
+  const direct = attributes.get("r:id");
+  if (direct !== void 0) return direct;
+  for (const [name2, value] of attributes) {
+    if (name2 === "id" || name2.endsWith(":id")) return value;
+  }
+  return void 0;
+}
+
+// src/lib/styles.ts
+var BUILT_IN_FORMATS = /* @__PURE__ */ new Map([
+  [0, "General"],
+  [1, "0"],
+  [2, "0.00"],
+  [3, "#,##0"],
+  [4, "#,##0.00"],
+  [9, "0%"],
+  [10, "0.00%"],
+  [11, "0.00E+00"],
+  [12, "# ?/?"],
+  [13, "# ??/??"],
+  [14, "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, "@"]
+]);
+function builtInFormatId(code) {
+  for (const [id, builtIn] of BUILT_IN_FORMATS) {
+    if (builtIn === code) return id;
+  }
+  return void 0;
+}
+function readStyles(xml) {
+  const numberFormats = /* @__PURE__ */ new Map();
+  const cellFormats = [];
+  let inCellFormats = false;
+  let inNumberFormats = false;
+  for (const event of readXml(xml)) {
+    if (event.kind === "close") {
+      if (event.localName === "cellXfs") inCellFormats = false;
+      if (event.localName === "numFmts") inNumberFormats = false;
+      continue;
+    }
+    if (event.kind !== "open") continue;
+    if (event.localName === "numFmts") {
+      inNumberFormats = !event.selfClosing;
+      continue;
+    }
+    if (event.localName === "numFmt" && inNumberFormats) {
+      const id = Number(event.attributes.get("numFmtId"));
+      const code = event.attributes.get("formatCode");
+      if (!Number.isNaN(id) && code !== void 0) numberFormats.set(id, code);
+      continue;
+    }
+    if (event.localName === "cellXfs") {
+      inCellFormats = !event.selfClosing;
+      continue;
+    }
+    if (event.localName === "xf" && inCellFormats) {
+      cellFormats.push(Number(event.attributes.get("numFmtId") ?? 0));
+    }
+  }
+  return { numberFormats, cellFormats };
+}
+function numberFormatOf(styles, styleIndex) {
+  if (styleIndex === void 0) return void 0;
+  const formatId = styles.cellFormats[styleIndex];
+  if (formatId === void 0) return void 0;
+  return styles.numberFormats.get(formatId) ?? BUILT_IN_FORMATS.get(formatId);
+}
+function numericSections(code) {
+  let stripped = "";
+  let index = 0;
+  let section = 1;
+  while (index < code.length) {
+    const character = code.charAt(index);
+    if (character === ";") {
+      section++;
+      if (section > 3) break;
+      stripped += ";";
+      index++;
+      continue;
+    }
+    if (character === '"') {
+      index++;
+      while (index < code.length && code.charAt(index) !== '"') index++;
+      index++;
+      continue;
+    }
+    if (character === "\\" || character === "*" || character === "_") {
+      index += 2;
+      continue;
+    }
+    if (character === "[") {
+      const end = code.indexOf("]", index);
+      const inside = end === -1 ? "" : code.slice(index + 1, end);
+      if (/^[hms]+$/i.test(inside)) stripped += inside;
+      index = end === -1 ? code.length : end + 1;
+      continue;
+    }
+    stripped += character;
+    index++;
+  }
+  return stripped;
+}
+var DATE_TOKEN = /[ymdhs]/i;
+var ELAPSED_TIME = /\[[hms]+\]/i;
+function isDateFormatCode(code) {
+  if (code === void 0 || code === "General") return false;
+  if (ELAPSED_TIME.test(code)) return false;
+  return DATE_TOKEN.test(numericSections(code));
+}
+function isDateFormat(styles, styleIndex) {
+  return isDateFormatCode(numberFormatOf(styles, styleIndex));
+}
+
+// src/lib/styles-writer.ts
+var SHORT_DATE_FORMAT_ID = 14;
+var FIRST_CUSTOM_FORMAT_ID = 164;
+var escapeXml3 = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var prefixOf = (name2) => {
+  const colon = name2.indexOf(":");
+  return colon === -1 ? "" : name2.slice(0, colon + 1);
+};
+var withNamespacePrefix = (fragment, prefix) => prefix === "" ? fragment : fragment.replace(/<(\/?)([A-Za-z])/g, `<$1${prefix}$2`);
+function readTable(xml, container, child) {
+  let openTag = "";
+  let openStart = -1;
+  let openEnd = -1;
+  let insertAt = -1;
+  let selfClosing = false;
+  let inside = false;
+  let prefix = "";
+  let openElement = -1;
+  const elements = [];
+  for (const event of readXml(xml)) {
+    if (event.kind === "open" && event.localName === container) {
+      prefix = prefixOf(event.name);
+      openTag = xml.slice(event.start, event.end);
+      openStart = event.start;
+      openEnd = event.end;
+      selfClosing = event.selfClosing;
+      inside = !event.selfClosing;
+      if (selfClosing) insertAt = event.end;
+      continue;
+    }
+    if (event.kind === "close" && event.localName === container) {
+      insertAt = event.start;
+      inside = false;
+      continue;
+    }
+    if (inside && event.kind === "open" && event.localName === child) {
+      if (event.selfClosing) elements.push(xml.slice(event.start, event.end));
+      else openElement = event.start;
+      continue;
+    }
+    if (inside && event.kind === "close" && event.localName === child && openElement !== -1) {
+      elements.push(xml.slice(openElement, event.end));
+      openElement = -1;
+    }
+  }
+  if (openStart === -1) return void 0;
+  return { elements, prefix, openTag, openStart, openEnd, insertAt, selfClosing };
+}
+function tableInsertPoint(xml) {
+  let cellXfsStart = -1;
+  let closeStart = -1;
+  let prefix = "";
+  for (const event of readXml(xml)) {
+    if (event.kind === "open" && event.localName === "cellXfs" && cellXfsStart === -1) {
+      cellXfsStart = event.start;
+    }
+    if (event.kind === "close" && event.localName === "styleSheet") {
+      closeStart = event.start;
+      prefix = prefixOf(event.name);
+    }
+  }
+  if (closeStart === -1) {
+    throw new XlsxError("malformed-xml", "Style table has no styleSheet element", {
+      part: "xl/styles.xml"
+    });
+  }
+  return { position: cellXfsStart === -1 ? closeStart : cellXfsStart, prefix };
+}
+function ensureInTable(xml, container, child, element) {
+  const table = readTable(xml, container, child);
+  if (table === void 0) {
+    const { position, prefix } = tableInsertPoint(xml);
+    const prefixed2 = element.replace(/^<[^\s/>]+/, `<${prefix}${child}`);
+    const created = `<${prefix}${container} count="1">${prefixed2}</${prefix}${container}>`;
+    return { xml: xml.slice(0, position) + created + xml.slice(position), id: 0 };
+  }
+  const prefixed = element.replace(/^<[^\s/>]+/, `<${table.prefix}${child}`);
+  const existing = table.elements.indexOf(prefixed);
+  if (existing !== -1) return { xml, id: existing };
+  const id = table.elements.length;
+  const openTag = withAttribute(table.openTag, "count", id + 1);
+  if (table.selfClosing) {
+    const opened = `${openTag.slice(0, -2)}>`;
+    return {
+      xml: xml.slice(0, table.openStart) + `${opened}${prefixed}</${table.prefix}${container}>` + xml.slice(table.openEnd),
+      id
+    };
+  }
+  const head = xml.slice(0, table.openStart) + openTag;
+  const body = xml.slice(table.openEnd, table.insertAt);
+  return { xml: `${head}${body}${prefixed}${xml.slice(table.insertAt)}`, id };
+}
+var DEFAULT_XF = '<xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>';
+var OVERRIDE_FLAGS = [
+  ["numFmtId", "applyNumberFormat"],
+  ["fontId", "applyFont"],
+  ["fillId", "applyFill"],
+  ["borderId", "applyBorder"]
+];
+function withApplyFlag(openTag, flag) {
+  const pattern = new RegExp(`${flag}=("|')(?:\\d+|true|false)\\1`);
+  if (pattern.test(openTag)) return openTag.replace(pattern, `${flag}="1"`);
+  return openTag.replace(/\/?>$/, (tag) => tag === "/>" ? ` ${flag}="1"/>` : ` ${flag}="1">`);
+}
+function withOverrides(element, overrides) {
+  const openTagEnd = element.indexOf(">") + 1;
+  let openTag = element.slice(0, openTagEnd);
+  const rest = element.slice(openTagEnd);
+  for (const [attribute, flag] of OVERRIDE_FLAGS) {
+    const value = overrides[attribute];
+    if (value !== void 0) openTag = withApplyFlag(withAttribute(openTag, attribute, value), flag);
+  }
+  return `${openTag}${rest}`;
+}
+function ensureDateStyle(stylesXml, basedOn) {
+  const parsed = readStyles(stylesXml);
+  if (basedOn !== void 0 && isDateFormat(parsed, basedOn)) {
+    return { xml: stylesXml, index: basedOn };
+  }
+  if (basedOn === void 0) {
+    for (let index = 0; index < parsed.cellFormats.length; index++) {
+      if (isDateFormat(parsed, index) && isPlainFormat(stylesXml, index)) {
+        return { xml: stylesXml, index };
+      }
+    }
+  }
+  return applyCellFormat(stylesXml, basedOn, { numFmtId: SHORT_DATE_FORMAT_ID });
+}
+function applyCellFormat(stylesXml, basedOn, overrides) {
+  const formats = readTable(stylesXml, "cellXfs", "xf");
+  const base = basedOn === void 0 ? DEFAULT_XF : formats?.elements[basedOn] ?? DEFAULT_XF;
+  const wanted = withOverrides(base, overrides);
+  const { xml, id } = ensureInTable(stylesXml, "cellXfs", "xf", wanted);
+  return { xml, index: id };
+}
+var REPORTED_UNDERLINES = /* @__PURE__ */ new Set([
+  "double",
+  "singleAccounting",
+  "doubleAccounting"
+]);
+var toUnderline = (value) => {
+  for (const known of REPORTED_UNDERLINES) if (known === value) return known;
+  return void 0;
+};
+var VERTICAL_ALIGNS = /* @__PURE__ */ new Set([
+  "baseline",
+  "superscript",
+  "subscript"
+]);
+var toVertAlign = (value) => {
+  for (const known of VERTICAL_ALIGNS) if (known === value) return known;
+  return void 0;
+};
+var HEX_COLOR = /^[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/;
+function normalizeColor(color) {
+  const hex = color.startsWith("#") ? color.slice(1) : color;
+  if (!HEX_COLOR.test(hex)) {
+    throw new XlsxError("unwritable-value", `Colour "${color}" is not a 6 or 8 digit hex value`, {});
+  }
+  return (hex.length === 6 ? `FF${hex}` : hex).toUpperCase();
+}
+function parseColor(attributes) {
+  const rgb = attributes.get("rgb");
+  if (rgb !== void 0 && HEX_COLOR.test(rgb)) return rgb;
+  const themeText = attributes.get("theme");
+  if (themeText !== void 0) {
+    const theme = Number(themeText);
+    if (Number.isInteger(theme) && theme >= 0) {
+      const tint = Number(attributes.get("tint"));
+      return Number.isNaN(tint) ? { theme } : { theme, tint };
+    }
+  }
+  const indexedText = attributes.get("indexed");
+  if (indexedText !== void 0) {
+    const indexed = Number(indexedText);
+    if (Number.isInteger(indexed) && indexed >= 0) return { indexed };
+  }
+  return void 0;
+}
+function colorAttributes(color) {
+  if (typeof color === "string") return ` rgb="${normalizeColor(color)}"`;
+  if ("theme" in color) {
+    if (!Number.isInteger(color.theme) || color.theme < 0) {
+      throw new XlsxError(
+        "unwritable-value",
+        `Colour theme "${color.theme}" is not a non-negative integer`,
+        {}
+      );
+    }
+    if (color.tint === void 0) return ` theme="${color.theme}"`;
+    if (!Number.isFinite(color.tint) || color.tint < -1 || color.tint > 1) {
+      throw new XlsxError(
+        "unwritable-value",
+        `Colour tint "${color.tint}" is not between -1 and 1`,
+        {}
+      );
+    }
+    return ` theme="${color.theme}" tint="${color.tint}"`;
+  }
+  if (!Number.isInteger(color.indexed) || color.indexed < 0) {
+    throw new XlsxError(
+      "unwritable-value",
+      `Colour index "${color.indexed}" is not a non-negative integer`,
+      {}
+    );
+  }
+  return ` indexed="${color.indexed}"`;
+}
+var flagOn = (value) => value !== "0" && value !== "false";
+function parseFont(element) {
+  const font = {};
+  for (const event of readXml(element)) {
+    if (event.kind !== "open") continue;
+    switch (event.localName) {
+      case "b":
+        font.bold = flagOn(event.attributes.get("val"));
+        break;
+      case "i":
+        font.italic = flagOn(event.attributes.get("val"));
+        break;
+      case "strike":
+        font.strike = flagOn(event.attributes.get("val"));
+        break;
+      case "u": {
+        const val = event.attributes.get("val");
+        if (val === "none") break;
+        font.underline = toUnderline(val) ?? true;
+        break;
+      }
+      case "vertAlign": {
+        const verticalAlign = toVertAlign(event.attributes.get("val"));
+        if (verticalAlign !== void 0) font.verticalAlign = verticalAlign;
+        break;
+      }
+      case "sz": {
+        const size = Number(event.attributes.get("val"));
+        if (!Number.isNaN(size)) font.size = size;
+        break;
+      }
+      case "color": {
+        const color = parseColor(event.attributes);
+        if (color !== void 0) font.color = color;
+        break;
+      }
+      case "name": {
+        const name2 = event.attributes.get("val");
+        if (name2 !== void 0) font.name = name2;
+        break;
+      }
+    }
+  }
+  return font;
+}
+function buildFontElement(font) {
+  let inner = "";
+  if (font.bold === true) inner += "<b/>";
+  if (font.italic === true) inner += "<i/>";
+  if (font.strike === true) inner += "<strike/>";
+  if (font.underline === true || font.underline === "single") inner += "<u/>";
+  else if (typeof font.underline === "string") inner += `<u val="${font.underline}"/>`;
+  if (font.verticalAlign !== void 0) inner += `<vertAlign val="${font.verticalAlign}"/>`;
+  if (font.size !== void 0) {
+    if (!Number.isFinite(font.size) || font.size <= 0) {
+      throw new XlsxError("unwritable-value", `Font size ${font.size} is not a positive number`, {
+        part: "xl/styles.xml"
+      });
+    }
+    inner += `<sz val="${font.size}"/>`;
+  }
+  if (font.color !== void 0) inner += `<color${colorAttributes(font.color)}/>`;
+  if (font.name !== void 0) inner += `<name val="${escapeXml3(font.name)}"/>`;
+  return `<font>${inner}</font>`;
+}
+var numericAttributePatterns = /* @__PURE__ */ new Map();
+var numericAttributePattern = (attribute) => {
+  const cached = numericAttributePatterns.get(attribute);
+  if (cached !== void 0) return cached;
+  const pattern = new RegExp(`\\b${attribute}\\s*=\\s*["'](\\d+)["']`);
+  numericAttributePatterns.set(attribute, pattern);
+  return pattern;
+};
+var attrId = (element, attribute) => {
+  const match = element.match(numericAttributePattern(attribute));
+  return match?.[1] === void 0 ? 0 : Number(match[1]);
+};
+function idOf(stylesXml, basedOn, attribute) {
+  if (basedOn === void 0) return 0;
+  const element = readTable(stylesXml, "cellXfs", "xf")?.elements[basedOn];
+  return element === void 0 ? 0 : attrId(element, attribute);
+}
+function isPlainFormat(stylesXml, index) {
+  const element = readTable(stylesXml, "cellXfs", "xf")?.elements[index];
+  if (element === void 0) return true;
+  const idIsZero = (attribute) => attrId(element, attribute) === 0;
+  return idIsZero("fontId") && idIsZero("fillId") && idIsZero("borderId") && !/<[a-z0-9]*:?alignment[\s/>]/i.test(element) && !/<[a-z0-9]*:?protection[\s/>]/i.test(element);
+}
+function withReservedTable(stylesXml, container, child, reservedInner, reservedCount) {
+  const table = readTable(stylesXml, container, child);
+  if (table !== void 0 && table.elements.length > 0) return stylesXml;
+  if (table === void 0) {
+    const { position, prefix: prefix2 } = tableInsertPoint(stylesXml);
+    const block2 = `<${prefix2}${container} count="${reservedCount}">${reservedInner(prefix2)}</${prefix2}${container}>`;
+    return stylesXml.slice(0, position) + block2 + stylesXml.slice(position);
+  }
+  const { prefix } = table;
+  const block = `<${prefix}${container} count="${reservedCount}">${reservedInner(prefix)}</${prefix}${container}>`;
+  const end = table.selfClosing ? table.openEnd : table.insertAt + `</${prefix}${container}>`.length;
+  return stylesXml.slice(0, table.openStart) + block + stylesXml.slice(end);
+}
+function withReservedFont(stylesXml) {
+  return withReservedTable(stylesXml, "fonts", "font", (prefix) => `<${prefix}font/>`, 1);
+}
+function ensureFontStyle(stylesXml, basedOn, font) {
+  const seeded = withReservedFont(stylesXml);
+  const fonts = readTable(seeded, "fonts", "font");
+  const current = parseFont(fonts?.elements[idOf(seeded, basedOn, "fontId")] ?? "");
+  const merged = {
+    bold: font.bold ?? current.bold,
+    italic: font.italic ?? current.italic,
+    strike: font.strike ?? current.strike,
+    underline: font.underline ?? current.underline,
+    verticalAlign: font.verticalAlign ?? current.verticalAlign,
+    size: font.size ?? current.size,
+    color: font.color ?? current.color,
+    name: font.name ?? current.name
+  };
+  const element = withNamespacePrefix(buildFontElement(merged), tablePrefix(seeded));
+  const { xml, id } = ensureInTable(seeded, "fonts", "font", element);
+  return applyCellFormat(xml, basedOn, { fontId: id });
+}
+var RESERVED_FILLS = '<fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill>';
+function withReservedFills(stylesXml) {
+  return withReservedTable(
+    stylesXml,
+    "fills",
+    "fill",
+    (prefix) => RESERVED_FILLS.replace(/<(\/?)(fill|patternFill)/g, `<$1${prefix}$2`),
+    2
+  );
+}
+function buildFillElement(fill) {
+  const fg = `<fgColor${colorAttributes(fill.color)}/>`;
+  if (fill.type === "solid") {
+    return `<fill><patternFill patternType="solid">${fg}<bgColor indexed="64"/></patternFill></fill>`;
+  }
+  const bg = fill.background === void 0 ? '<bgColor indexed="64"/>' : `<bgColor${colorAttributes(fill.background)}/>`;
+  return `<fill><patternFill patternType="${fill.pattern}">${fg}${bg}</patternFill></fill>`;
+}
+function ensureFillStyle(stylesXml, basedOn, fill) {
+  const seeded = withReservedFills(stylesXml);
+  const element = withNamespacePrefix(buildFillElement(fill), tablePrefix(seeded));
+  const { xml, id } = ensureInTable(seeded, "fills", "fill", element);
+  return applyCellFormat(xml, basedOn, { fillId: id });
+}
+var SIDE_NAMES = ["left", "right", "top", "bottom"];
+var RESERVED_BORDER = "<border><left/><right/><top/><bottom/><diagonal/></border>";
+function withReservedBorder(stylesXml) {
+  return withReservedTable(
+    stylesXml,
+    "borders",
+    "border",
+    (prefix) => RESERVED_BORDER.replace(/<(\/?)(border|left|right|top|bottom|diagonal)/g, `<$1${prefix}$2`),
+    1
+  );
+}
+function parseBorder(element) {
+  const sides = {};
+  let inSide;
+  for (const event of readXml(element)) {
+    if (event.kind === "close") {
+      if (inSide !== void 0 && event.localName === inSide) inSide = void 0;
+      continue;
+    }
+    if (event.kind !== "open") continue;
+    if (event.localName === "left" || event.localName === "right") inSide = event.localName;
+    else if (event.localName === "top" || event.localName === "bottom") inSide = event.localName;
+    else {
+      if (event.localName === "color" && inSide !== void 0) {
+        const color = parseColor(event.attributes);
+        const style2 = sides[inSide]?.style;
+        if (color !== void 0 && style2 !== void 0) sides[inSide] = { style: style2, color };
+      }
+      continue;
+    }
+    const style = event.attributes.get("style");
+    if (style !== void 0) sides[inSide] = { style };
+    if (event.selfClosing) inSide = void 0;
+  }
+  return sides;
+}
+var borderSidesAt = (stylesXml, id) => {
+  const element = readTable(stylesXml, "borders", "border")?.elements[id];
+  return element === void 0 ? {} : parseBorder(element);
+};
+var buildSide = (name2, side) => {
+  if (side === void 0) return `<${name2}/>`;
+  if (side.color === void 0) return `<${name2} style="${side.style}"/>`;
+  return `<${name2} style="${side.style}"><color${colorAttributes(side.color)}/></${name2}>`;
+};
+var buildBorderElement = (sides) => `<border>${buildSide("left", sides.left)}${buildSide("right", sides.right)}${buildSide("top", sides.top)}${buildSide("bottom", sides.bottom)}<diagonal/></border>`;
+function ensureBorderStyle(stylesXml, basedOn, border) {
+  const seeded = withReservedBorder(stylesXml);
+  const current = borderSidesAt(seeded, idOf(seeded, basedOn, "borderId"));
+  const merged = {};
+  for (const name2 of SIDE_NAMES) {
+    const side = border[name2] ?? border.all ?? current[name2];
+    if (side !== void 0) merged[name2] = side;
+  }
+  const element = withNamespacePrefix(buildBorderElement(merged), tablePrefix(seeded));
+  const { xml, id } = ensureInTable(seeded, "borders", "border", element);
+  return applyCellFormat(xml, basedOn, { borderId: id });
+}
+var numberAttribute = (value) => {
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+};
+function parseAlignment(xf) {
+  const out = {};
+  for (const event of readXml(xf)) {
+    if (event.kind !== "open" || event.localName !== "alignment") continue;
+    const horizontal = event.attributes.get("horizontal");
+    if (horizontal !== void 0) out.horizontal = horizontal;
+    const vertical = event.attributes.get("vertical");
+    if (vertical !== void 0) out.vertical = vertical;
+    const wrapText = event.attributes.get("wrapText");
+    if (wrapText !== void 0) out.wrapText = flagOn(wrapText);
+    const rotation = numberAttribute(event.attributes.get("textRotation"));
+    if (rotation !== void 0) out.textRotation = rotation;
+    const indent = numberAttribute(event.attributes.get("indent"));
+    if (indent !== void 0) out.indent = indent;
+  }
+  return out;
+}
+function buildAlignmentElement(alignment, prefix) {
+  let attributes = "";
+  if (alignment.horizontal !== void 0) attributes += ` horizontal="${alignment.horizontal}"`;
+  if (alignment.vertical !== void 0) attributes += ` vertical="${alignment.vertical}"`;
+  if (alignment.wrapText === true) attributes += ' wrapText="1"';
+  if (alignment.textRotation !== void 0)
+    attributes += ` textRotation="${alignment.textRotation}"`;
+  if (alignment.indent !== void 0) attributes += ` indent="${alignment.indent}"`;
+  return `<${prefix}alignment${attributes}/>`;
+}
+var ALIGNMENT_CHILD = /<(?:[A-Za-z0-9]+:)?alignment\b(?:[^>]*\/>|[\s\S]*?<\/(?:[A-Za-z0-9]+:)?alignment>)/;
+function withAlignmentChild(xf, alignment, prefix) {
+  const close = xf.indexOf(">");
+  const selfClosing = xf.charAt(close - 1) === "/";
+  const openTag = withApplyFlag(
+    `${xf.slice(0, selfClosing ? close - 1 : close)}>`,
+    "applyAlignment"
+  );
+  const body = selfClosing ? "" : xf.slice(close + 1, xf.lastIndexOf("</"));
+  return `${openTag}${alignment}${body.replace(ALIGNMENT_CHILD, "")}</${prefix}xf>`;
+}
+function validateAlignment(alignment) {
+  const { textRotation, indent } = alignment;
+  if (textRotation !== void 0 && (!Number.isInteger(textRotation) || textRotation < 0 || textRotation > 180 && textRotation !== 255)) {
+    throw new XlsxError("unwritable-value", `Text rotation ${textRotation} is not 0\u2013180 or 255`, {
+      part: "xl/styles.xml"
+    });
+  }
+  if (indent !== void 0 && (!Number.isInteger(indent) || indent < 0)) {
+    throw new XlsxError("unwritable-value", `Indent ${indent} is not a whole number of steps`, {
+      part: "xl/styles.xml"
+    });
+  }
+}
+function ensureAlignmentStyle(stylesXml, basedOn, alignment) {
+  validateAlignment(alignment);
+  const prefix = tablePrefix(stylesXml);
+  const base = basedOn === void 0 ? DEFAULT_XF : readTable(stylesXml, "cellXfs", "xf")?.elements[basedOn] ?? DEFAULT_XF;
+  const current = parseAlignment(base);
+  const merged = {
+    horizontal: alignment.horizontal ?? current.horizontal,
+    vertical: alignment.vertical ?? current.vertical,
+    wrapText: alignment.wrapText ?? current.wrapText,
+    textRotation: alignment.textRotation ?? current.textRotation,
+    indent: alignment.indent ?? current.indent
+  };
+  const wanted = withAlignmentChild(base, buildAlignmentElement(merged, prefix), prefix);
+  const { xml, id } = ensureInTable(stylesXml, "cellXfs", "xf", wanted);
+  return { xml, index: id };
+}
+function parseProtection(xf) {
+  const out = {};
+  for (const event of readXml(xf)) {
+    if (event.kind !== "open" || event.localName !== "protection") continue;
+    const locked = event.attributes.get("locked");
+    if (locked !== void 0) out.locked = flagOn(locked);
+    const hidden = event.attributes.get("hidden");
+    if (hidden !== void 0) out.hidden = flagOn(hidden);
+  }
+  return out;
+}
+function buildProtectionElement(protection, prefix) {
+  let attributes = "";
+  if (protection.locked !== void 0) attributes += ` locked="${protection.locked ? "1" : "0"}"`;
+  if (protection.hidden !== void 0) attributes += ` hidden="${protection.hidden ? "1" : "0"}"`;
+  return `<${prefix}protection${attributes}/>`;
+}
+var PROTECTION_CHILD = /<(?:[A-Za-z0-9]+:)?protection\b[^>]*\/>/;
+function withProtectionChild(xf, protection, prefix) {
+  const close = xf.indexOf(">");
+  const selfClosing = xf.charAt(close - 1) === "/";
+  const openTag = withApplyFlag(
+    `${xf.slice(0, selfClosing ? close - 1 : close)}>`,
+    "applyProtection"
+  );
+  const body = (selfClosing ? "" : xf.slice(close + 1, xf.lastIndexOf("</"))).replace(
+    PROTECTION_CHILD,
+    ""
+  );
+  const extLst = body.match(/<(?:[A-Za-z0-9]+:)?extLst\b/);
+  const at = extLst?.index ?? body.length;
+  return `${openTag}${body.slice(0, at)}${protection}${body.slice(at)}</${prefix}xf>`;
+}
+function ensureProtectionStyle(stylesXml, basedOn, protection) {
+  const prefix = tablePrefix(stylesXml);
+  const base = basedOn === void 0 ? DEFAULT_XF : readTable(stylesXml, "cellXfs", "xf")?.elements[basedOn] ?? DEFAULT_XF;
+  const current = parseProtection(base);
+  const merged = {
+    locked: protection.locked ?? current.locked,
+    hidden: protection.hidden ?? current.hidden
+  };
+  const wanted = withProtectionChild(base, buildProtectionElement(merged, prefix), prefix);
+  const { xml, id } = ensureInTable(stylesXml, "cellXfs", "xf", wanted);
+  return { xml, index: id };
+}
+function tablePrefix(xml) {
+  for (const event of readXml(xml)) {
+    if (event.kind !== "open") continue;
+    if (event.localName !== "numFmts" && event.localName !== "styleSheet") continue;
+    const colon = event.name.indexOf(":");
+    return colon === -1 ? "" : event.name.slice(0, colon + 1);
+  }
+  return "";
+}
+function usedFormatIds(xml) {
+  const used = /* @__PURE__ */ new Set();
+  for (const event of readXml(xml)) {
+    if (event.kind !== "open") continue;
+    const declared = event.attributes.get("numFmtId");
+    if (declared === void 0) continue;
+    const id = Number(declared);
+    if (!Number.isNaN(id)) used.add(id);
+  }
+  return used;
+}
+function withNumberFormat(xml, id, code, prefix) {
+  const element = `<${prefix}numFmt numFmtId="${id}" formatCode="${escapeXml3(code)}"/>`;
+  let openStart = -1;
+  let openEnd = -1;
+  let children = 0;
+  for (const event of readXml(xml)) {
+    if (event.kind === "open" && event.localName === "numFmts" && event.selfClosing) {
+      const opened = `${withAttribute(xml.slice(event.start, event.end - 2), "count", 1)}>`;
+      return `${xml.slice(0, event.start)}${opened}${element}</${prefix}numFmts>${xml.slice(event.end)}`;
+    }
+    if (event.kind === "open" && event.localName === "numFmts") {
+      openStart = event.start;
+      openEnd = event.end;
+      continue;
+    }
+    if (openStart !== -1 && event.kind === "open" && event.localName === "numFmt") {
+      children++;
+      continue;
+    }
+    if (event.kind === "close" && event.localName === "numFmts" && openStart !== -1) {
+      const head = xml.slice(0, openStart) + withAttribute(xml.slice(openStart, openEnd), "count", children + 1) + xml.slice(openEnd, event.start);
+      return head + element + xml.slice(event.start);
+    }
+  }
+  for (const event of readXml(xml)) {
+    if (event.kind !== "open" || event.localName !== "styleSheet") continue;
+    const table = `<${prefix}numFmts count="1">${element}</${prefix}numFmts>`;
+    return xml.slice(0, event.end) + table + xml.slice(event.end);
+  }
+  throw new XlsxError("malformed-xml", "Style table has no styleSheet element", {
+    part: "xl/styles.xml"
+  });
+}
+function ensureNumberFormat(stylesXml, basedOn, formatCode) {
+  const unwritable = findUnwritableCharacter(formatCode);
+  if (unwritable !== void 0) {
+    throw new XlsxError(
+      "unwritable-value",
+      `Number format holds ${unwritable}, which cannot be written to xml`,
+      { part: "xl/styles.xml" }
+    );
+  }
+  const parsed = readStyles(stylesXml);
+  if (basedOn !== void 0 && numberFormatOf(parsed, basedOn) === formatCode) {
+    return { xml: stylesXml, index: basedOn };
+  }
+  if (basedOn === void 0) {
+    for (let index = 0; index < parsed.cellFormats.length; index++) {
+      if (numberFormatOf(parsed, index) === formatCode && isPlainFormat(stylesXml, index)) {
+        return { xml: stylesXml, index };
+      }
+    }
+  }
+  let formatId = builtInFormatId(formatCode);
+  let withFormat = stylesXml;
+  const prefix = tablePrefix(stylesXml);
+  if (formatId === void 0) {
+    for (const [id, code] of parsed.numberFormats) {
+      if (code === formatCode) formatId = id;
+    }
+  }
+  if (formatId === void 0) {
+    const used = usedFormatIds(stylesXml);
+    formatId = FIRST_CUSTOM_FORMAT_ID;
+    while (used.has(formatId)) formatId++;
+    withFormat = withNumberFormat(stylesXml, formatId, formatCode, prefix);
+  }
+  return applyCellFormat(withFormat, basedOn, { numFmtId: formatId });
+}
+var PATTERN_STYLES = /* @__PURE__ */ new Set([
+  "gray125",
+  "gray0625",
+  "mediumGray",
+  "darkGray",
+  "lightGray",
+  "darkHorizontal",
+  "darkVertical",
+  "darkDown",
+  "darkUp",
+  "darkGrid",
+  "darkTrellis",
+  "lightHorizontal",
+  "lightVertical",
+  "lightDown",
+  "lightUp",
+  "lightGrid",
+  "lightTrellis"
+]);
+var toPatternStyle = (value) => {
+  for (const known of PATTERN_STYLES) if (known === value) return known;
+  return void 0;
+};
+function parseFill(element) {
+  let patternType;
+  let foreground;
+  let background;
+  for (const event of readXml(element)) {
+    if (event.kind !== "open") continue;
+    if (event.localName === "patternFill") patternType = event.attributes.get("patternType");
+    if (event.localName === "fgColor") foreground = parseColor(event.attributes) ?? foreground;
+    if (event.localName === "bgColor") {
+      const color = parseColor(event.attributes);
+      if (color !== void 0 && !(typeof color === "object" && "indexed" in color))
+        background = color;
+    }
+  }
+  if (foreground === void 0) return void 0;
+  if (patternType === "solid") return { type: "solid", color: foreground };
+  const pattern = toPatternStyle(patternType);
+  if (pattern === void 0) return void 0;
+  return background === void 0 ? { type: "pattern", pattern, color: foreground } : { type: "pattern", pattern, color: foreground, background };
+}
+var BORDER_STYLES = /* @__PURE__ */ new Set([
+  "thin",
+  "medium",
+  "thick",
+  "dashed",
+  "dotted",
+  "double",
+  "hair",
+  "mediumDashed",
+  "dashDot",
+  "mediumDashDot",
+  "dashDotDot",
+  "mediumDashDotDot",
+  "slantDashDot"
+]);
+function toBorderStyle(value) {
+  for (const known of BORDER_STYLES) if (known === value) return known;
+  return void 0;
+}
+function fontFrom(xf, fonts) {
+  const id = attrId(xf, "fontId");
+  const element = fonts[id];
+  if (id === 0 || element === void 0) return void 0;
+  const font = parseFont(element);
+  return Object.keys(font).length === 0 ? void 0 : font;
+}
+var fillFrom = (xf, fills) => {
+  const element = fills[attrId(xf, "fillId")];
+  return element === void 0 ? void 0 : parseFill(element);
+};
+function borderFrom(xf, borders) {
+  const element = borders[attrId(xf, "borderId")];
+  if (element === void 0) return void 0;
+  const sides = parseBorder(element);
+  const border = {};
+  for (const name2 of SIDE_NAMES) {
+    const side = sides[name2];
+    const style = side === void 0 ? void 0 : toBorderStyle(side.style);
+    if (side === void 0 || style === void 0) continue;
+    border[name2] = side.color === void 0 ? { style } : { style, color: side.color };
+  }
+  return Object.keys(border).length === 0 ? void 0 : border;
+}
+var HORIZONTAL_ALIGNMENTS = /* @__PURE__ */ new Set([
+  "general",
+  "left",
+  "center",
+  "right",
+  "fill",
+  "justify",
+  "centerContinuous",
+  "distributed"
+]);
+var VERTICAL_ALIGNMENTS = /* @__PURE__ */ new Set([
+  "top",
+  "center",
+  "bottom",
+  "justify",
+  "distributed"
+]);
+var toHorizontal = (value) => {
+  for (const known of HORIZONTAL_ALIGNMENTS) if (known === value) return known;
+  return void 0;
+};
+var toVertical = (value) => {
+  for (const known of VERTICAL_ALIGNMENTS) if (known === value) return known;
+  return void 0;
+};
+function alignmentFrom(xf) {
+  const parsed = parseAlignment(xf);
+  const horizontal = toHorizontal(parsed.horizontal);
+  const vertical = toVertical(parsed.vertical);
+  const alignment = {};
+  if (horizontal !== void 0) alignment.horizontal = horizontal;
+  if (vertical !== void 0) alignment.vertical = vertical;
+  if (parsed.wrapText !== void 0) alignment.wrapText = parsed.wrapText;
+  if (parsed.textRotation !== void 0) alignment.textRotation = parsed.textRotation;
+  if (parsed.indent !== void 0) alignment.indent = parsed.indent;
+  return Object.keys(alignment).length === 0 ? void 0 : alignment;
+}
+function protectionFrom(xf) {
+  const parsed = parseProtection(xf);
+  return Object.keys(parsed).length === 0 ? void 0 : parsed;
+}
+function readFormatting(stylesXml) {
+  const xfs = readTable(stylesXml, "cellXfs", "xf")?.elements ?? [];
+  const fonts = readTable(stylesXml, "fonts", "font")?.elements ?? [];
+  const fills = readTable(stylesXml, "fills", "fill")?.elements ?? [];
+  const borders = readTable(stylesXml, "borders", "border")?.elements ?? [];
+  return xfs.map((xf) => {
+    const font = fontFrom(xf, fonts);
+    const fill = fillFrom(xf, fills);
+    const border = borderFrom(xf, borders);
+    const alignment = alignmentFrom(xf);
+    const protection = protectionFrom(xf);
+    return {
+      ...font === void 0 ? {} : { font },
+      ...fill === void 0 ? {} : { fill },
+      ...border === void 0 ? {} : { border },
+      ...alignment === void 0 ? {} : { alignment },
+      ...protection === void 0 ? {} : { protection }
+    };
+  });
+}
+
+// src/lib/workbook.ts
+var OFFICE_DOCUMENT = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+var WORKSHEET = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet";
+var ROOT_RELATIONSHIPS = "_rels/.rels";
+function partText(container, path) {
+  const bytes = container.parts.get(path);
+  if (bytes === void 0)
+    throw new XlsxError("missing-part", `Missing part ${path}`, { part: path });
+  return decodeXmlPart(bytes, path);
+}
+function findWorkbookPath(container) {
+  if (!container.parts.has(ROOT_RELATIONSHIPS)) {
+    throw new XlsxError("missing-part", `Missing part ${ROOT_RELATIONSHIPS}`, {
+      part: ROOT_RELATIONSHIPS
+    });
+  }
+  for (const relationship of readRelationships(
+    partText(container, ROOT_RELATIONSHIPS),
+    ROOT_RELATIONSHIPS
+  ).values()) {
+    if (relationship.type === OFFICE_DOCUMENT) return resolveTarget("", relationship.target);
+  }
+  throw new XlsxError("missing-part", "Package declares no workbook part", {
+    part: ROOT_RELATIONSHIPS
+  });
+}
+function toSheetState(value) {
+  if (value === "hidden") return "hidden";
+  if (value === "veryHidden") return "veryHidden";
+  return "visible";
+}
+var isTrue = (value) => value === "1" || value === "true";
+function relationshipId2(attributes) {
+  const direct = attributes.get("r:id");
+  if (direct !== void 0) return direct;
+  for (const [name2, value] of attributes) {
+    if (name2 === "id" || name2.endsWith(":id")) return value;
+  }
+  return void 0;
+}
+function readWorkbookPart(bytes) {
+  const container = readContainer(bytes);
+  const workbookPath = findWorkbookPath(container);
+  const workbookXml = partText(container, workbookPath);
+  const relationshipsPath = workbookPath.replace(/([^/]+)$/, "_rels/$1.rels");
+  const relationships = container.parts.has(relationshipsPath) ? readRelationships(partText(container, relationshipsPath), relationshipsPath) : /* @__PURE__ */ new Map();
+  const sheets = [];
+  let date1904 = false;
+  for (const event of readXml(workbookXml)) {
+    if (event.kind !== "open") continue;
+    if (event.localName === "workbookPr") {
+      date1904 = isTrue(event.attributes.get("date1904"));
+      continue;
+    }
+    if (event.localName !== "sheet") continue;
+    const id = relationshipId2(event.attributes);
+    const relationship = id === void 0 ? void 0 : relationships.get(id);
+    if (relationship === void 0 || relationship.external) continue;
+    if (relationship.type !== WORKSHEET) continue;
+    sheets.push({
+      name: event.attributes.get("name") ?? "",
+      sheetId: event.attributes.get("sheetId") ?? "",
+      path: resolveTarget(workbookPath, relationship.target),
+      state: toSheetState(event.attributes.get("state"))
+    });
+  }
+  return { path: workbookPath, relationshipsPath, sheets, date1904, container };
+}
+
+// src/lib/document.ts
+var EMPTY_STYLES = { numberFormats: /* @__PURE__ */ new Map(), cellFormats: [] };
+var EMPTY_EDITS = /* @__PURE__ */ new Map();
+var CALCULATION_CHAIN = "xl/calcChain.xml";
+var CONTENT_TYPES = "[Content_Types].xml";
+var AFTER_CALC_PR = /* @__PURE__ */ new Set([
+  "oleSize",
+  "customWorkbookViews",
+  "pivotCaches",
+  "smartTagPr",
+  "smartTagTypes",
+  "webPublishing",
+  "fileRecoveryPr",
+  "webPublishObjects",
+  "extLst"
+]);
+function withRecalculation(xml) {
+  for (const event of readXml(xml)) {
+    if (event.kind !== "open" || event.localName !== "calcPr") continue;
+    const tag = xml.slice(event.start, event.end);
+    if (tag.includes("fullCalcOnLoad=")) {
+      return xml.slice(0, event.start) + // Either quote character is legal, and matching only double quotes
+      // left the check passing while the rewrite did nothing.
+      tag.replace(/fullCalcOnLoad=("|')[^"']*\1/, 'fullCalcOnLoad="1"') + xml.slice(event.end);
+    }
+    const opened = tag.replace(
+      /\/?>$/,
+      (end) => end === "/>" ? ' fullCalcOnLoad="1"/>' : ' fullCalcOnLoad="1">'
+    );
+    return xml.slice(0, event.start) + opened + xml.slice(event.end);
+  }
+  let depth = 0;
+  let insertAt = -1;
+  for (const event of readXml(xml)) {
+    if (event.kind === "open") {
+      if (depth === 1 && insertAt === -1 && AFTER_CALC_PR.has(event.localName)) {
+        insertAt = event.start;
+      }
+      if (!event.selfClosing) depth++;
+      continue;
+    }
+    if (event.kind !== "close") continue;
+    depth--;
+    if (event.localName !== "workbook" || depth !== 0) continue;
+    const colon = event.name.indexOf(":");
+    const prefix = colon === -1 ? "" : event.name.slice(0, colon + 1);
+    const element = `<${prefix}calcPr fullCalcOnLoad="1"/>`;
+    const at = insertAt === -1 ? event.start : insertAt;
+    return xml.slice(0, at) + element + xml.slice(at);
+  }
+  return xml;
+}
+function withoutRelationship(xml, ownerPath, part) {
+  for (const event of readXml(xml)) {
+    if (event.kind !== "open" || event.localName !== "Relationship") continue;
+    if (event.attributes.get("TargetMode") === "External") continue;
+    const target = event.attributes.get("Target");
+    if (target === void 0 || resolveTarget(ownerPath, target) !== part) continue;
+    return xml.slice(0, event.start) + xml.slice(event.end);
+  }
+  return xml;
+}
+function withoutOverride(xml, part) {
+  for (const event of readXml(xml)) {
+    if (event.kind !== "open" || event.localName !== "Override") continue;
+    if (event.attributes.get("PartName") !== `/${part}`) continue;
+    return xml.slice(0, event.start) + xml.slice(event.end);
+  }
+  return xml;
+}
+function partText2(container, path) {
+  const bytes = container.parts.get(path);
+  if (bytes === void 0) return void 0;
+  return decodeXmlPart(bytes, path);
+}
+function toCellValue(raw, styles, date1904) {
+  const value = raw.value;
+  if (value.kind === "date") {
+    const parsed = parseIsoDate(value.value);
+    if (parsed === void 0) return { kind: "text", value: value.value };
+    return { kind: "date", value: parsed, serial: dateToSerial(parsed, date1904) };
+  }
+  if (value.kind === "number" && isDateFormat(styles, raw.styleIndex)) {
+    const serial = value.value;
+    if (serial >= 0 && serial <= LAST_SERIAL) {
+      return { kind: "date", value: serialToDate(serial, date1904), serial };
+    }
+  }
+  return value;
+}
+function toFormula(raw, masters) {
+  if (raw.formula === void 0) return void 0;
+  if (raw.sharedIndex === void 0 || raw.ownsSharedRange === true) {
+    return { kind: "expression", expression: raw.formula };
+  }
+  const master = masters?.get(raw.sharedIndex);
+  return master === void 0 ? { kind: "shared" } : { kind: "shared", master };
+}
+function toCell(raw, styles, formatting, date1904, masters) {
+  const numberFormat = numberFormatOf(styles, raw.styleIndex);
+  const value = toCellValue(raw, styles, date1904);
+  const formula = toFormula(raw, masters);
+  return {
+    address: raw.address,
+    // Not the file's spelling: $A$1 and a1 are the same cell, and a caller that
+    // cross-references this against set() or formatReference needs one answer.
+    reference: canonicalReference(raw.address) ?? raw.reference,
+    value,
+    ...formula === void 0 ? {} : { formula },
+    ...numberFormat === void 0 ? {} : { numberFormat },
+    ...formatting
+  };
+}
+function readWorkbook(bytes) {
+  const part = readWorkbookPart(bytes);
+  const { container, date1904 } = part;
+  const stylesXml = partText2(container, "xl/styles.xml");
+  const styles = stylesXml === void 0 ? EMPTY_STYLES : readStyles(stylesXml);
+  const stringsXml = partText2(container, "xl/sharedStrings.xml");
+  const sharedStrings = stringsXml === void 0 ? [] : readSharedStrings(stringsXml);
+  const edits = /* @__PURE__ */ new Map();
+  const styleOverrides = /* @__PURE__ */ new Map();
+  const sheetProtections = /* @__PURE__ */ new Map();
+  const sheetMerges = /* @__PURE__ */ new Map();
+  const sheetRowHeights = /* @__PURE__ */ new Map();
+  const sheetColumnWidths = /* @__PURE__ */ new Map();
+  let workingStyles = stylesXml;
+  let parsedStyles = styles;
+  let parsedFrom = stylesXml;
+  const stylesNow = () => {
+    if (workingStyles !== void 0 && workingStyles !== parsedFrom) {
+      parsedStyles = readStyles(workingStyles);
+      parsedFrom = workingStyles;
+    }
+    return parsedStyles;
+  };
+  let parsedFormatting;
+  let formattingFrom;
+  const formattingFor = (styleIndex) => {
+    if (styleIndex === void 0 || workingStyles === void 0) return {};
+    if (parsedFormatting === void 0 || workingStyles !== formattingFrom) {
+      parsedFormatting = readFormatting(workingStyles);
+      formattingFrom = workingStyles;
+    }
+    return parsedFormatting[styleIndex] ?? {};
+  };
+  const sheets = part.sheets.map((reference) => {
+    const sheetBytes = container.parts.get(reference.path);
+    const at = { sheet: reference.name, part: reference.path };
+    const patched = () => {
+      if (sheetBytes === void 0) return void 0;
+      const pending = edits.get(reference.path);
+      const overrides = styleOverrides.get(reference.path);
+      const protection = sheetProtections.get(reference.path);
+      const merges = sheetMerges.get(reference.path);
+      const rowHeights = sheetRowHeights.get(reference.path);
+      const columnWidths = sheetColumnWidths.get(reference.path);
+      if (pending === void 0 && overrides === void 0 && protection === void 0 && merges === void 0 && rowHeights === void 0 && columnWidths === void 0) {
+        return sheetBytes;
+      }
+      return patchSheet(sheetBytes, pending ?? EMPTY_EDITS, date1904, void 0, overrides, at, {
+        protection,
+        merges,
+        rowHeights,
+        columnWidths
+      });
+    };
+    function* readCells(source) {
+      const bytes2 = source ?? patched();
+      if (bytes2 === void 0) return;
+      const masters = /* @__PURE__ */ new Map();
+      for (const raw of readSheet(bytes2, sharedStrings, at)) {
+        if (raw.ownsSharedRange === true && raw.sharedIndex !== void 0) {
+          masters.set(raw.sharedIndex, canonicalReference(raw.address) ?? raw.reference);
+        }
+        yield toCell(raw, stylesNow(), formattingFor(raw.styleIndex), date1904, masters);
+      }
+    }
+    let index;
+    const indexed = () => {
+      if (sheetBytes === void 0) return void 0;
+      index ??= indexSheet(sheetBytes);
+      return index;
+    };
+    const styleAt = (canonical) => styleOverrides.get(reference.path)?.get(canonical) ?? indexed()?.styles.get(canonical);
+    const predict = (canonical, value, styleIndex) => {
+      const address = parseReference(canonical);
+      const style = styleIndex === void 0 ? {} : { styleIndex };
+      const raw = { address, reference: canonical, ...style };
+      const formatting = formattingFor(styleIndex);
+      if (value === null) {
+        return toCell({ ...raw, value: { kind: "empty" } }, stylesNow(), formatting, date1904);
+      }
+      if (typeof value === "number") {
+        return toCell(
+          { ...raw, value: { kind: "number", value } },
+          stylesNow(),
+          formatting,
+          date1904
+        );
+      }
+      if (typeof value === "boolean") {
+        return toCell(
+          { ...raw, value: { kind: "boolean", value } },
+          stylesNow(),
+          formatting,
+          date1904
+        );
+      }
+      if (typeof value === "string") {
+        return toCell({ ...raw, value: { kind: "text", value } }, stylesNow(), formatting, date1904);
+      }
+      if (value instanceof Date) {
+        const serial = dateToSerial(value, date1904);
+        return toCell(
+          { ...raw, value: { kind: "number", value: serial } },
+          stylesNow(),
+          formatting,
+          date1904
+        );
+      }
+      const formula = value.formula;
+      return toCell(
+        { ...raw, value: { kind: "empty" }, formula },
+        stylesNow(),
+        formatting,
+        date1904
+      );
+    };
+    let byReference;
+    const overlay = /* @__PURE__ */ new Map();
+    const findCell = (canonical) => {
+      const edited = overlay.get(canonical);
+      if (edited !== void 0) return edited;
+      if (byReference === void 0) {
+        byReference = /* @__PURE__ */ new Map();
+        for (const found of readCells(sheetBytes)) {
+          const where = canonicalReference(found.address);
+          if (where !== void 0) byReference.set(where, found);
+        }
+      }
+      return byReference.get(canonical);
+    };
+    const restyled = (base, styleIndex) => {
+      const styles2 = stylesNow();
+      const numberFormat = numberFormatOf(styles2, styleIndex);
+      const dateFormat = isDateFormat(styles2, styleIndex);
+      let value = base.value;
+      if (value.kind === "number" && dateFormat && value.value >= 0 && value.value <= LAST_SERIAL) {
+        value = { kind: "date", value: serialToDate(value.value, date1904), serial: value.value };
+      } else if (value.kind === "date" && !dateFormat) {
+        value = { kind: "number", value: value.serial };
+      }
+      return {
+        address: base.address,
+        reference: base.reference,
+        value,
+        ...base.formula === void 0 ? {} : { formula: base.formula },
+        ...numberFormat === void 0 ? {} : { numberFormat },
+        ...formattingFor(styleIndex)
+      };
+    };
+    const resolveStyle = (current, value, options, canonical) => {
+      if (workingStyles === void 0) {
+        if (Object.values(options ?? {}).some((asked) => asked !== void 0)) {
+          throw new XlsxError(
+            "missing-part",
+            `Cannot format ${canonical}: the package has no style table`,
+            { part: "xl/styles.xml", reference: canonical }
+          );
+        }
+        return void 0;
+      }
+      let xml = workingStyles;
+      let base = current;
+      let applied;
+      const step = (next) => {
+        xml = next.xml;
+        base = next.index;
+        applied = next;
+      };
+      if (options?.numberFormat !== void 0)
+        step(ensureNumberFormat(xml, base, options.numberFormat));
+      else if (value instanceof Date) step(ensureDateStyle(xml, base));
+      if (options?.font !== void 0) step(ensureFontStyle(xml, base, options.font));
+      if (options?.fill !== void 0) step(ensureFillStyle(xml, base, options.fill));
+      if (options?.border !== void 0) step(ensureBorderStyle(xml, base, options.border));
+      if (options?.alignment !== void 0) step(ensureAlignmentStyle(xml, base, options.alignment));
+      if (options?.protection !== void 0)
+        step(ensureProtectionStyle(xml, base, options.protection));
+      return applied;
+    };
+    const commitStyle = (canonical, current, applied) => {
+      if (applied === void 0) return current;
+      workingStyles = applied.xml;
+      if (applied.index !== current) {
+        const overrides = styleOverrides.get(reference.path) ?? /* @__PURE__ */ new Map();
+        overrides.set(canonical, applied.index);
+        styleOverrides.set(reference.path, overrides);
+      }
+      return applied.index;
+    };
+    const absent = (canonical, verb) => new XlsxError(
+      "missing-part",
+      `Sheet ${reference.name} is not in the package, so ${canonical} cannot be ${verb}`,
+      { ...at, reference: canonical }
+    );
+    return {
+      name: reference.name,
+      state: reference.state,
+      sheetId: reference.sheetId,
+      get protection() {
+        const pending = sheetProtections.get(reference.path);
+        if (pending === "remove") return void 0;
+        if (pending !== void 0) return pending;
+        return sheetBytes === void 0 ? void 0 : readSheetProtection(sheetBytes);
+      },
+      cells: () => readCells(),
+      cell(cellReference) {
+        const wanted = canonicalReference(parseReference(cellReference));
+        if (wanted === void 0) return void 0;
+        return findCell(wanted);
+      },
+      set(cellReference, value, options) {
+        const canonical = formatReference(parseWritableReference(cellReference));
+        if (sheetBytes === void 0) throw absent(canonical, "written");
+        checkWritable(canonical, value, date1904, at);
+        const index2 = indexed();
+        if (index2 !== void 0) {
+          const si = index2.sharedFormulas.get(canonical);
+          if (si !== void 0) throw sharedFormulaRefusal(canonical, si, at);
+          const anchor = mergeAnchorFor(index2, canonical);
+          if (anchor !== void 0) throw mergeRefusal(canonical, anchor, at);
+        }
+        const current = styleAt(canonical);
+        const applied = resolveStyle(current, value, options, canonical);
+        const pending = edits.get(reference.path) ?? /* @__PURE__ */ new Map();
+        pending.set(canonical, value);
+        edits.set(reference.path, pending);
+        overlay.set(canonical, predict(canonical, value, commitStyle(canonical, current, applied)));
+      },
+      format(cellReference, options) {
+        const canonical = formatReference(parseWritableReference(cellReference));
+        if (sheetBytes === void 0) throw absent(canonical, "formatted");
+        const current = styleAt(canonical);
+        const applied = resolveStyle(current, void 0, options, canonical);
+        if (applied === void 0) return;
+        const existing = findCell(canonical);
+        const resolved = commitStyle(canonical, current, applied);
+        overlay.set(
+          canonical,
+          existing === void 0 ? predict(canonical, null, resolved) : restyled(existing, resolved)
+        );
+      },
+      protect(options = {}) {
+        if (sheetBytes === void 0) {
+          throw new XlsxError(
+            "missing-part",
+            `Sheet ${reference.name} is not in the package, so it cannot be protected`,
+            at
+          );
+        }
+        sheetProtections.set(reference.path, options);
+      },
+      unprotect() {
+        sheetProtections.set(reference.path, "remove");
+      },
+      merge(range) {
+        if (sheetBytes === void 0) {
+          throw new XlsxError(
+            "missing-part",
+            `Sheet ${reference.name} is not in the package, so ${range} cannot be merged`,
+            { ...at, reference: range }
+          );
+        }
+        const canonical = mergeRangeReference(range, at);
+        const pending = sheetMerges.get(reference.path) ?? [];
+        pending.push(canonical);
+        sheetMerges.set(reference.path, pending);
+      },
+      setRowHeight(row, height) {
+        if (sheetBytes === void 0) {
+          throw new XlsxError(
+            "missing-part",
+            `Sheet ${reference.name} is not in the package, so row ${row} cannot be sized`,
+            at
+          );
+        }
+        if (!Number.isInteger(row) || row < 1) {
+          throw new XlsxError("bad-reference", `Row ${row} is not a row number`, { ...at });
+        }
+        if (row > LAST_ROW) {
+          throw new XlsxError("bad-reference", `Row ${row} is outside the sheet`, { ...at });
+        }
+        if (!Number.isFinite(height) || height < 0) {
+          throw new XlsxError("unwritable-value", `Row height ${height} is not zero or more`, {
+            ...at
+          });
+        }
+        const heights = sheetRowHeights.get(reference.path) ?? /* @__PURE__ */ new Map();
+        heights.set(row, height);
+        sheetRowHeights.set(reference.path, heights);
+      },
+      setColumnWidth(column, width) {
+        if (sheetBytes === void 0) {
+          throw new XlsxError(
+            "missing-part",
+            `Sheet ${reference.name} is not in the package, so column ${column} cannot be sized`,
+            { ...at, reference: column }
+          );
+        }
+        const index2 = columnToIndex(column);
+        if (index2 > LAST_COLUMN) {
+          throw new XlsxError("bad-reference", `Column ${column} is outside the sheet`, {
+            ...at,
+            reference: column
+          });
+        }
+        if (!Number.isFinite(width) || width < 0) {
+          throw new XlsxError("unwritable-value", `Column width ${width} is not zero or more`, {
+            ...at,
+            reference: column
+          });
+        }
+        const widths = sheetColumnWidths.get(reference.path) ?? /* @__PURE__ */ new Map();
+        widths.set(index2, width);
+        sheetColumnWidths.set(reference.path, widths);
+      }
+    };
+  });
+  const toBytes = () => {
+    const changes = /* @__PURE__ */ new Map();
+    if (edits.size === 0 && styleOverrides.size === 0 && sheetProtections.size === 0 && sheetMerges.size === 0 && sheetRowHeights.size === 0 && sheetColumnWidths.size === 0) {
+      return container.write(changes);
+    }
+    const encoder2 = new TextEncoder();
+    if (container.parts.has(CALCULATION_CHAIN)) {
+      changes.set(CALCULATION_CHAIN, null);
+      const types = partText2(container, CONTENT_TYPES);
+      if (types !== void 0) {
+        changes.set(CONTENT_TYPES, encoder2.encode(withoutOverride(types, CALCULATION_CHAIN)));
+      }
+      const rels = partText2(container, part.relationshipsPath);
+      if (rels !== void 0) {
+        changes.set(
+          part.relationshipsPath,
+          encoder2.encode(withoutRelationship(rels, part.path, CALCULATION_CHAIN))
+        );
+      }
+    }
+    if (workingStyles !== void 0 && workingStyles !== stylesXml) {
+      changes.set("xl/styles.xml", encoder2.encode(workingStyles));
+    }
+    let indexes;
+    if (stringsXml !== void 0) {
+      const written = [];
+      for (const pending of edits.values()) {
+        for (const value of pending.values()) {
+          if (typeof value === "string") written.push(value);
+        }
+      }
+      if (written.length > 0) {
+        const appended = appendSharedStrings(stringsXml, written);
+        changes.set("xl/sharedStrings.xml", encoder2.encode(appended.xml));
+        indexes = appended.indexes;
+      }
+    }
+    for (const path of /* @__PURE__ */ new Set([
+      ...edits.keys(),
+      ...styleOverrides.keys(),
+      ...sheetProtections.keys(),
+      ...sheetMerges.keys(),
+      ...sheetRowHeights.keys(),
+      ...sheetColumnWidths.keys()
+    ])) {
+      const bytes2 = container.parts.get(path);
+      if (bytes2 === void 0) continue;
+      const pending = edits.get(path) ?? EMPTY_EDITS;
+      const at = {
+        sheet: part.sheets.find((s) => s.path === path)?.name,
+        part: path
+      };
+      changes.set(
+        path,
+        patchSheet(bytes2, pending, date1904, indexes, styleOverrides.get(path), at, {
+          protection: sheetProtections.get(path),
+          merges: sheetMerges.get(path),
+          rowHeights: sheetRowHeights.get(path),
+          columnWidths: sheetColumnWidths.get(path)
+        })
+      );
+      for (const extension of extendTables(bytes2, path, container, pending.keys())) {
+        changes.set(extension.path, encoder2.encode(extension.xml));
+      }
+    }
+    const wroteFormula = [...edits.values()].some(
+      (pending) => [...pending.values()].some(
+        (value) => typeof value === "object" && value !== null && !(value instanceof Date)
+      )
+    );
+    if (wroteFormula) {
+      const book = partText2(container, part.path);
+      if (book !== void 0) changes.set(part.path, encoder2.encode(withRecalculation(book)));
+    }
+    return container.write(changes);
+  };
+  return {
+    sheets,
+    sheet: (name2) => sheets.find((candidate) => candidate.name === name2),
+    epoch: date1904 ? 1904 : 1900,
+    toBytes
+  };
+}
+
+exports.XlsxError = XlsxError;
+exports.columnToIndex = columnToIndex;
+exports.formatReference = formatReference;
+exports.indexToColumn = indexToColumn;
+exports.parseReference = parseReference;
+exports.readWorkbook = readWorkbook;