@particle-academy/holy-sheet 2.10.1 → 2.11.0

package/dist/index.cjs

@@ -242,12 +242,12 @@ function parseRows(csv, delimiter, quote2) {
 // src/workbook/cell-address.ts
 var CellAddress = {
   /** 0-based column index → Excel-style letters. */
-  letter(index) {
-    if (index < 0) {
-      throw new Error(`[holy-sheet] column index must be \u2265 0, got ${index}`);
+  letter(index2) {
+    if (index2 < 0) {
+      throw new Error(`[holy-sheet] column index must be \u2265 0, got ${index2}`);
     }
     let letters = "";
-    let n = index;
+    let n = index2;
     do {
       letters = String.fromCharCode(65 + n % 26) + letters;
       n = Math.floor(n / 26) - 1;
@@ -300,8 +300,8 @@ var ColumnWidths = {
       return Number.isInteger(key) && key >= 0 && key <= ColumnWidths.MAX_INDEX ? key : null;
     }
     if (typeof key === "string" && /^[0-9]{1,5}$/.test(key)) {
-      const index = parseInt(key, 10);
-      return index <= ColumnWidths.MAX_INDEX ? index : null;
+      const index2 = parseInt(key, 10);
+      return index2 <= ColumnWidths.MAX_INDEX ? index2 : null;
     }
     return null;
   },
@@ -521,9 +521,10 @@ var ChartRange = class _ChartRange {
 
 // src/workbook/workbook.ts
 var Workbook = class {
-  constructor(sheets, meta = {}) {
+  constructor(sheets, meta = {}, sourceKind2 = "document") {
     this.sheets = sheets;
     this.meta = meta;
+    this.sourceKind = sourceKind2;
   }
 };
 
@@ -560,6 +561,31 @@ var DateConverter = {
 };
 
 // src/exceptions.ts
+var ArchiveRefused = class _ArchiveRefused extends Error {
+  constructor(reason) {
+    super(`Source archive refused: ${reason}`);
+    this.reason = reason;
+    this.name = "ArchiveRefused";
+    Object.setPrototypeOf(this, _ArchiveRefused.prototype);
+  }
+};
+var TEMPLATE_MESSAGES = {
+  macro_enabled: "Macro-enabled templates (.xltm) are refused: re-save it as an .xltx in Excel.",
+  family_mismatch: "This package declares a template of a different kind than its contents.",
+  already_template: "This package is already a template.",
+  already_document: "This package is already a document.",
+  not_convertible: "This package has no single content-type declaration that can be rewritten.",
+  odf_mimetype: "An OpenDocument package must store its mimetype entry first and uncompressed.",
+  bad_target: 'The conversion target must be "document" or "template".'
+};
+var OfficeTemplateRefused = class _OfficeTemplateRefused extends Error {
+  constructor(reason) {
+    super(`Template refused (${reason}): ${TEMPLATE_MESSAGES[reason] ?? reason}`);
+    this.reason = reason;
+    this.name = "OfficeTemplateRefused";
+    Object.setPrototypeOf(this, _OfficeTemplateRefused.prototype);
+  }
+};
 var SchemaException = class _SchemaException extends Error {
   constructor(errors, message) {
     super(message ?? summarize(errors));
@@ -800,23 +826,23 @@ var Normalizer = class {
     for (const [colIdx, columnDef] of (sheet.columns ?? []).entries()) {
       if (columnDef === null || typeof columnDef !== "object") continue;
       if (columnDef.width === void 0) continue;
-      const index = ColumnWidths.index(colIdx);
+      const index2 = ColumnWidths.index(colIdx);
       const width = ColumnWidths.width(columnDef.width);
-      if (index === null || width === null) continue;
-      out.set(index, width);
+      if (index2 === null || width === null) continue;
+      out.set(index2, width);
     }
-    for (const [index, width] of this.normalizeColumnWidths(sheet.columnWidths ?? {})) {
-      out.set(index, width);
+    for (const [index2, width] of this.normalizeColumnWidths(sheet.columnWidths ?? {})) {
+      out.set(index2, width);
     }
     return new Map([...out.entries()].sort((a, b) => a[0] - b[0]));
   }
   normalizeColumnWidths(widths) {
     const out = /* @__PURE__ */ new Map();
     for (const [key, px] of Object.entries(widths)) {
-      const index = ColumnWidths.index(key);
+      const index2 = ColumnWidths.index(key);
       const width = ColumnWidths.width(px);
-      if (index === null || width === null) continue;
-      out.set(index, width);
+      if (index2 === null || width === null) continue;
+      out.set(index2, width);
     }
     return out;
   }
@@ -928,14 +954,14 @@ function normalizePoints(points2, count) {
   const byIndex = /* @__PURE__ */ new Map();
   for (const p of Object.values(points2)) {
     const rec = isPlainObject(p) || Array.isArray(p) ? p : null;
-    const index = rec ? rec.index : void 0;
+    const index2 = rec ? rec.index : void 0;
     const color2 = rec ? rec.color : void 0;
     const m = typeof color2 === "string" ? /^#([0-9A-Fa-f]{6})$/.exec(color2) : null;
-    if (typeof index === "number" && Number.isInteger(index) && index >= 0 && index < count && m) {
-      byIndex.set(index, m[1].toUpperCase());
+    if (typeof index2 === "number" && Number.isInteger(index2) && index2 >= 0 && index2 < count && m) {
+      byIndex.set(index2, m[1].toUpperCase());
     }
   }
-  return [...byIndex.entries()].sort((a, b) => a[0] - b[0]).map(([index, color2]) => ({ index, color: color2 }));
+  return [...byIndex.entries()].sort((a, b) => a[0] - b[0]).map(([index2, color2]) => ({ index: index2, color: color2 }));
 }
 var CHART_TYPES = ["column", "bar", "line", "pie"];
 function normalizeCharts(charts, sheetName2, cells) {
@@ -1069,13 +1095,13 @@ var FormulaLinter = class {
     return issues;
   }
   buildIndex(wb) {
-    const index = /* @__PURE__ */ new Map();
+    const index2 = /* @__PURE__ */ new Map();
     for (const sheet of wb.sheets) {
       for (const [address, cell] of sheet.cells) {
-        index.set(sheet.name + "!" + address, cell);
+        index2.set(sheet.name + "!" + address, cell);
       }
     }
-    return index;
+    return index2;
   }
   isError(v) {
     return typeof v === "string" && v.length > 0 && v[0] === "#";
@@ -1589,21 +1615,21 @@ var Repairer = class {
       const widths = {};
       let changed = false;
       for (const [key, px] of Object.entries(sheet.columnWidths)) {
-        let index = ColumnWidths.index(key);
-        if (index === null) {
+        let index2 = ColumnWidths.index(key);
+        if (index2 === null) {
           const letters = ColumnWidths.fromLetters(key);
           if (letters !== null) {
-            index = letters;
-            this.repairs.push(`converted '${path}.columnWidths.${key}' to column index ${index}`);
+            index2 = letters;
+            this.repairs.push(`converted '${path}.columnWidths.${key}' to column index ${index2}`);
             changed = true;
           }
         }
-        if (index === null || ColumnWidths.width(px) === null) {
+        if (index2 === null || ColumnWidths.width(px) === null) {
           this.repairs.push(`dropped '${path}.columnWidths.${key}' (not a column index and a width)`);
           changed = true;
           continue;
         }
-        widths[String(index)] = px;
+        widths[String(index2)] = px;
       }
       if (changed) {
         sheet.columnWidths = widths;
@@ -2027,14 +2053,14 @@ function validatePoints(points2, at2, values2) {
   const errors = [];
   points2.forEach((p, k) => {
     const rec = isPlainObject(p) || Array.isArray(p) ? p : null;
-    const index = rec ? rec.index ?? null : null;
+    const index2 = rec ? rec.index ?? null : null;
     const color2 = rec ? rec.color ?? null : null;
-    if (typeof index !== "number" || !Number.isInteger(index) || index < 0 || index >= count) {
+    if (typeof index2 !== "number" || !Number.isInteger(index2) || index2 < 0 || index2 >= count) {
       errors.push(error(
         `${at2}[${k}].index`,
         "an index within values (0 to " + Math.max(0, count - 1) + ")",
-        typeOf(index),
-        index,
+        typeOf(index2),
+        index2,
         'The 0-based position of the point in its values range: "B5:B7" has points 0, 1 and 2.'
       ));
     }
@@ -2429,8 +2455,17 @@ function buildTree(t, lengths, off, num) {
   let i;
   let sum = 0;
   for (i = 0; i < 16; i++) t.table[i] = 0;
-  for (i = 0; i < num; i++) t.table[lengths[off + i]]++;
+  for (i = 0; i < num; i++) {
+    const length = lengths[off + i];
+    if (length === void 0 || length > 15) throw new Error("holy-sheet: invalid DEFLATE tree");
+    t.table[length]++;
+  }
   t.table[0] = 0;
+  let slots = 1;
+  for (i = 1; i <= 15; i++) {
+    slots = slots * 2 - t.table[i];
+    if (slots < 0) throw new Error("holy-sheet: oversubscribed DEFLATE tree");
+  }
   for (i = 0; i < 16; i++) {
     OFFS[i] = sum;
     sum += t.table[i];
@@ -2450,6 +2485,7 @@ var Reader = class {
 };
 function getBit(d) {
   if (d.bitcount-- === 0) {
+    if (d.index >= d.source.length) throw new Error("holy-sheet: truncated DEFLATE input");
     d.tag = d.source[d.index++];
     d.bitcount = 7;
   }
@@ -2470,6 +2506,7 @@ function decodeSymbol(d, t) {
   do {
     cur = 2 * cur + getBit(d);
     len++;
+    if (len > 15) throw new Error("holy-sheet: invalid DEFLATE code");
     sum += t.table[len];
     cur -= t.table[len];
   } while (cur >= 0);
@@ -2480,6 +2517,7 @@ function decodeTrees(d, lt, dt) {
   const hlit = readBits(d, 5, 257);
   const hdist = readBits(d, 5, 1);
   const hclen = readBits(d, 4, 4);
+  if (hlit > 286) throw new Error("holy-sheet: invalid DEFLATE literal count");
   let i;
   for (i = 0; i < 19; i++) lengths[i] = 0;
   for (i = 0; i < hclen; i++) {
@@ -2492,32 +2530,44 @@ function decodeTrees(d, lt, dt) {
     const sym = decodeSymbol(d, codeTree);
     switch (sym) {
       case 16: {
+        if (num === 0) throw new Error("holy-sheet: invalid DEFLATE repeat");
         const prev = lengths[num - 1];
-        for (let length = readBits(d, 2, 3); length; length--) lengths[num++] = prev;
+        const repeat = readBits(d, 2, 3);
+        if (num + repeat > hlit + hdist) throw new Error("holy-sheet: invalid DEFLATE repeat");
+        for (let length = repeat; length; length--) lengths[num++] = prev;
         break;
       }
-      case 17:
-        for (let length = readBits(d, 3, 3); length; length--) lengths[num++] = 0;
+      case 17: {
+        const repeat = readBits(d, 3, 3);
+        if (num + repeat > hlit + hdist) throw new Error("holy-sheet: invalid DEFLATE repeat");
+        for (let length = repeat; length; length--) lengths[num++] = 0;
         break;
-      case 18:
-        for (let length = readBits(d, 7, 11); length; length--) lengths[num++] = 0;
+      }
+      case 18: {
+        const repeat = readBits(d, 7, 11);
+        if (num + repeat > hlit + hdist) throw new Error("holy-sheet: invalid DEFLATE repeat");
+        for (let length = repeat; length; length--) lengths[num++] = 0;
         break;
+      }
       default:
         lengths[num++] = sym;
         break;
     }
   }
+  if (lengths[256] === 0) throw new Error("holy-sheet: missing DEFLATE end code");
   buildTree(lt, lengths, 0, hlit);
   buildTree(dt, lengths, hlit, hdist);
 }
 var Out = class {
-  constructor() {
-    this.buf = new Uint8Array(1024);
+  constructor(limit) {
+    this.limit = limit;
     this.len = 0;
+    this.buf = new Uint8Array(Math.min(1024, limit));
   }
   push(b) {
+    if (this.len >= this.limit) throw new Error("holy-sheet: DEFLATE output limit exceeded");
     if (this.len >= this.buf.length) {
-      const next = new Uint8Array(this.buf.length * 2);
+      const next = new Uint8Array(Math.min(this.limit, Math.max(1, this.buf.length * 2)));
       next.set(this.buf);
       this.buf = next;
     }
@@ -2532,9 +2582,12 @@ function inflateBlockData(d, out, lt, dt) {
       out.push(sym);
     } else {
       const lengthSym = sym - 257;
+      if (lengthSym < 0 || lengthSym >= LENGTH_BITS.length) throw new Error("holy-sheet: invalid DEFLATE length");
       const length = readBits(d, LENGTH_BITS[lengthSym], LENGTH_BASE[lengthSym]);
       const distSym = decodeSymbol(d, dt);
+      if (distSym < 0 || distSym >= DIST_BITS.length) throw new Error("holy-sheet: invalid DEFLATE distance");
       const dist = readBits(d, DIST_BITS[distSym], DIST_BASE[distSym]);
+      if (dist > out.len) throw new Error("holy-sheet: DEFLATE distance before output");
       const offs = out.len - dist;
       for (let i = 0; i < length; i++) out.push(out.buf[offs + i]);
     }
@@ -2542,13 +2595,20 @@ function inflateBlockData(d, out, lt, dt) {
 }
 function inflateUncompressedBlock(d, out) {
   d.bitcount = 0;
+  if (d.index + 4 > d.source.length) throw new Error("holy-sheet: truncated DEFLATE input");
   let length = d.source[d.index + 1] * 256 + d.source[d.index];
+  const complement = d.source[d.index + 3] * 256 + d.source[d.index + 2];
+  if ((length ^ complement) !== 65535) throw new Error("holy-sheet: invalid DEFLATE stored length");
   d.index += 4;
+  if (d.index + length > d.source.length) throw new Error("holy-sheet: truncated DEFLATE input");
   for (; length; length--) out.push(d.source[d.index++]);
 }
-function inflateRaw(source) {
+function inflateRaw(source, maxOutputBytes = Number.POSITIVE_INFINITY) {
+  if (maxOutputBytes !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(maxOutputBytes) || maxOutputBytes < 0)) {
+    throw new Error("holy-sheet: invalid DEFLATE output limit");
+  }
   const d = new Reader(source);
-  const out = new Out();
+  const out = new Out(maxOutputBytes);
   const lt = new Tree();
   const dt = new Tree();
   let bfinal;
@@ -2570,41 +2630,190 @@ function inflateRaw(source) {
   return out.buf.subarray(0, out.len);
 }
 
-// src/zip/zip-reader.ts
-var decoder = new TextDecoder();
-function unzipSync(data) {
-  const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
-  let eocd = -1;
-  for (let i = data.length - 22; i >= 0; i--) {
-    if (dv.getUint32(i, true) === 101010256) {
-      eocd = i;
-      break;
+// src/zip/source-archive.ts
+var DEFAULT_ARCHIVE_LIMITS = Object.freeze({
+  maxArchiveBytes: 67108864,
+  maxEntries: 16384,
+  maxPartBytes: 67108864,
+  maxExpandedBytes: 268435456,
+  maxCompressionRatio: 1e3
+});
+var corrupt = () => {
+  throw new ArchiveRefused("archive_corrupt");
+};
+var SourceArchive = class _SourceArchive {
+  constructor(original, parts, records = [], archiveComment = new Uint8Array()) {
+    this.original = original;
+    this.parts = parts;
+    this.records = records;
+    this.archiveComment = archiveComment;
+  }
+  static open(input, options = {}) {
+    for (const [key, value] of Object.entries(options)) {
+      if (!Object.prototype.hasOwnProperty.call(DEFAULT_ARCHIVE_LIMITS, key) || !Number.isSafeInteger(value) || value < 1) throw new ArchiveRefused("archive_limits");
+    }
+    const limits = { ...DEFAULT_ARCHIVE_LIMITS, ...options };
+    if (input.length > limits.maxArchiveBytes) throw new ArchiveRefused("archive_limit");
+    const bytes = input.slice();
+    const [records, comment] = index(bytes, limits);
+    const parts = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const compressed = bytes.subarray(record.start, record.start + record.compressed);
+      let payload;
+      try {
+        payload = record.method === 0 ? compressed.slice() : inflateRaw(compressed, record.size + 1);
+      } catch {
+        throw new ArchiveRefused("archive_corrupt");
+      }
+      if (payload.length !== record.size || crc32(payload) !== record.crc) corrupt();
+      parts.set(record.name, payload);
     }
+    const entries = records.map(({ name, size, crc, local, finish, central, centralLength, flags, method, localExtra }) => ({ name, size, crc, local, finish, central, centralLength, flags, method, localExtra }));
+    return new _SourceArchive(bytes, parts, entries, comment);
+  }
+  names() {
+    return [...this.parts.keys()];
+  }
+  read(name) {
+    return this.parts.get(name)?.slice() ?? null;
+  }
+  toBytes() {
+    return this.original.slice();
+  }
+  /** Verified member records in central-directory order. */
+  entries() {
+    return this.records.map((entry) => ({ ...entry }));
   }
-  if (eocd < 0) throw new Error("holy-sheet: not a zip archive (no EOCD record)");
-  const count = dv.getUint16(eocd + 10, true);
-  let cd = dv.getUint32(eocd + 16, true);
-  const result = {};
-  for (let n = 0; n < count; n++) {
-    if (dv.getUint32(cd, true) !== 33639248) break;
-    const method = dv.getUint16(cd + 10, true);
-    const compSize = dv.getUint32(cd + 20, true);
-    const nameLen = dv.getUint16(cd + 28, true);
-    const extraLen = dv.getUint16(cd + 30, true);
-    const commentLen = dv.getUint16(cd + 32, true);
-    const localOffset = dv.getUint32(cd + 42, true);
-    const name = decoder.decode(data.subarray(cd + 46, cd + 46 + nameLen));
-    const lhNameLen = dv.getUint16(localOffset + 26, true);
-    const lhExtraLen = dv.getUint16(localOffset + 28, true);
-    const dataStart = localOffset + 30 + lhNameLen + lhExtraLen;
-    const raw = data.subarray(dataStart, dataStart + compSize);
-    let content;
-    if (method === 0) content = raw.slice();
-    else if (method === 8) content = inflateRaw(raw);
-    else throw new Error(`holy-sheet: unsupported zip method ${method} for "${name}"`);
-    result[name] = content;
-    cd += 46 + nameLen + extraLen + commentLen;
+  /** The archive comment, verbatim. */
+  comment() {
+    return this.archiveComment.slice();
+  }
+};
+function index(bytes, limits) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const bounds = (at3, size, end2 = bytes.length) => {
+    if (at3 < 0 || size < 0 || at3 + size > end2 || at3 + size > bytes.length) corrupt();
+  };
+  const u16 = (at3) => {
+    bounds(at3, 2);
+    return view.getUint16(at3, true);
+  };
+  const u32 = (at3) => {
+    bounds(at3, 4);
+    return view.getUint32(at3, true);
+  };
+  let end = -1;
+  for (let at3 = bytes.length - 22; at3 >= Math.max(0, bytes.length - 65557); at3--) {
+    if (u32(at3) === 101010256 && at3 + 22 + u16(at3 + 20) === bytes.length && u32(at3 + 16) + u32(at3 + 12) === at3) {
+      end = at3;
+      break;
+    }
   }
+  if (end === -1) corrupt();
+  const count = u16(end + 10), directory = u32(end + 16);
+  if (u16(end + 4) !== 0 || u16(end + 6) !== 0 || u16(end + 8) !== count || count === 65535) throw new ArchiveRefused("archive_unsupported");
+  if (count > limits.maxEntries) throw new ArchiveRefused("archive_limit");
+  if (end - directory < count * 46) corrupt();
+  const records = [], seen = /* @__PURE__ */ new Set(), regions = [];
+  let at2 = directory, expanded = 0;
+  const extra = (start, length) => {
+    const finish = start + length;
+    while (start < finish) {
+      bounds(start, 4, finish);
+      const id = u16(start), size = u16(start + 2);
+      bounds(start + 4, size, finish);
+      if (id === 1 || id === 39169) throw new ArchiveRefused("archive_unsupported");
+      start += 4 + size;
+    }
+  };
+  for (let i = 0; i < count; i++) {
+    bounds(at2, 46, end);
+    if (u32(at2) !== 33639248) corrupt();
+    const flags = u16(at2 + 8), method = u16(at2 + 10), crc = u32(at2 + 16);
+    const compressed = u32(at2 + 20), size = u32(at2 + 24), local = u32(at2 + 42);
+    const nameLength = u16(at2 + 28), extraLength = u16(at2 + 30), commentLength = u16(at2 + 32);
+    if ((flags & -2063) !== 0 || ![0, 8].includes(method) || method === 0 && (flags & 6) !== 0 || u16(at2 + 34) !== 0 || [compressed, size, local].includes(4294967295) || u16(at2 + 6) > 20) throw new ArchiveRefused("archive_unsupported");
+    bounds(at2 + 46, nameLength + extraLength + commentLength, end);
+    const name = partName(bytes.subarray(at2 + 46, at2 + 46 + nameLength), flags);
+    if (seen.has(name)) throw new ArchiveRefused("archive_duplicate");
+    seen.add(name);
+    expanded += size;
+    if (size > limits.maxPartBytes || expanded > limits.maxExpandedBytes || size > Math.max(1, compressed) * limits.maxCompressionRatio) throw new ArchiveRefused("archive_limit");
+    if (method === 0 && compressed !== size) corrupt();
+    extra(at2 + 46 + nameLength, extraLength);
+    bounds(local, 30, directory);
+    if (u32(local) !== 67324752 || u16(local + 4) !== u16(at2 + 6) || u16(local + 6) !== flags || u16(local + 8) !== method) corrupt();
+    const localName2 = u16(local + 26), localExtra = u16(local + 28);
+    const start = local + 30 + localName2 + localExtra;
+    bounds(local + 30, localName2 + localExtra + compressed, directory);
+    const rawName = bytes.subarray(local + 30, local + 30 + localName2);
+    const centralName = bytes.subarray(at2 + 46, at2 + 46 + nameLength);
+    if (rawName.length !== centralName.length || !rawName.every((byte, pos) => byte === centralName[pos])) corrupt();
+    extra(local + 30 + localName2, localExtra);
+    for (const [offset, expected] of [[14, crc], [18, compressed], [22, size]]) {
+      const value = u32(local + offset);
+      if (value !== expected && !((flags & 8) !== 0 && value === 0)) corrupt();
+    }
+    let finish = start + compressed;
+    if ((flags & 8) !== 0) {
+      let found = false;
+      for (const prefix of [0, 4]) {
+        if (finish + prefix + 12 <= directory && (prefix === 0 || u32(finish) === 134695760) && u32(finish + prefix) === crc && u32(finish + prefix + 4) === compressed && u32(finish + prefix + 8) === size) {
+          finish += prefix + 12;
+          found = true;
+          break;
+        }
+      }
+      if (!found) corrupt();
+    }
+    records.push({
+      name,
+      method,
+      crc,
+      size,
+      compressed,
+      start,
+      local,
+      finish,
+      central: at2,
+      centralLength: 46 + nameLength + extraLength + commentLength,
+      flags,
+      localExtra
+    });
+    regions.push([local, finish]);
+    at2 += 46 + nameLength + extraLength + commentLength;
+  }
+  if (at2 !== end) corrupt();
+  regions.sort((a, b) => a[0] - b[0]);
+  let previous = 0;
+  for (const [start, finish] of regions) {
+    if (start < previous) corrupt();
+    previous = finish;
+  }
+  return [records, bytes.slice(end + 22, end + 22 + u16(end + 20))];
+}
+function partName(bytes, flags) {
+  let name;
+  try {
+    name = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+  } catch {
+    throw new ArchiveRefused("archive_path");
+  }
+  if (name === "" || name.startsWith("/") || name.includes(String.fromCharCode(92)) || name.includes(":")) throw new ArchiveRefused("archive_path");
+  for (const byte of bytes) {
+    if (byte < 32 || byte === 127) throw new ArchiveRefused("archive_path");
+    if (byte > 127 && (flags & 2048) === 0) throw new ArchiveRefused("archive_unsupported");
+  }
+  const parts = (name.endsWith("/") ? name.slice(0, -1) : name).split("/");
+  if (parts.some((part2) => part2 === "" || part2 === "." || part2 === "..")) throw new ArchiveRefused("archive_path");
+  return name;
+}
+
+// src/zip/zip-reader.ts
+function unzipSync(data, limits = {}) {
+  const source = SourceArchive.open(data, limits);
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const name of source.names()) result[name] = source.read(name);
   return result;
 }
 
@@ -2652,23 +2861,522 @@ var ODS_MIMETYPES = /* @__PURE__ */ new Set([
   "application/vnd.oasis.opendocument.spreadsheet",
   "application/vnd.oasis.opendocument.spreadsheet-template"
 ]);
-var decoder2 = new TextDecoder();
+var decoder = new TextDecoder();
 var FormatSniffer = {
   sniff(bytes, path = null) {
     let files;
     try {
       files = unzipSync(bytes);
     } catch (e) {
+      if (e instanceof ArchiveRefused && (e.reason !== "archive_corrupt" || bytes[0] === 80 && bytes[1] === 75)) throw e;
       if (e instanceof Error && e.message.includes("unsupported zip method")) throw e;
       throw UnsupportedFormatException.notAZip(path);
     }
-    const mimetype = files["mimetype"] ? phpTrim(decoder2.decode(files["mimetype"])) : null;
+    const mimetype = files["mimetype"] ? phpTrim(decoder.decode(files["mimetype"])) : null;
     if (mimetype !== null && ODS_MIMETYPES.has(mimetype)) return { format: "ods", files };
     if (files["xl/workbook.xml"]) return { format: "xlsx", files };
     throw UnsupportedFormatException.unknownPackage(path, mimetype);
   }
 };
 
+// src/reader/xml.ts
+var XML_NS = "http://www.w3.org/XML/1998/namespace";
+function localName(name) {
+  const idx = name.indexOf(":");
+  return idx >= 0 ? name.slice(idx + 1) : name;
+}
+function unescapeXml(s) {
+  if (s.indexOf("&") < 0) return s;
+  return s.replace(/&(#x?[0-9a-fA-F]+|\w+);/g, (m, ent) => {
+    switch (ent) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      case "apos":
+        return "'";
+      default:
+        if (ent[0] === "#") {
+          const code = ent[1] === "x" || ent[1] === "X" ? parseInt(ent.slice(2), 16) : parseInt(ent.slice(1), 10);
+          return Number.isFinite(code) ? String.fromCodePoint(code) : m;
+        }
+        return m;
+    }
+  });
+}
+function findTagEnd(src, from) {
+  let quote2 = "";
+  for (let i = from; i < src.length; i++) {
+    const ch = src[i];
+    if (quote2) {
+      if (ch === quote2) quote2 = "";
+    } else if (ch === '"' || ch === "'") {
+      quote2 = ch;
+    } else if (ch === ">") {
+      return i;
+    }
+  }
+  return src.length;
+}
+var ATTR_RE = /([^\s=/]+)\s*=\s*("([^"]*)"|'([^']*)')/g;
+function parseTag(inner) {
+  const trimmed = inner.trim();
+  let i = 0;
+  while (i < trimmed.length && !/\s/.test(trimmed[i])) i++;
+  const name = trimmed.slice(0, i);
+  const attrs = {};
+  const raw = [];
+  const rest = trimmed.slice(i);
+  for (const m of rest.matchAll(ATTR_RE)) {
+    const rawValue = m[3] ?? m[4] ?? "";
+    attrs[localName(m[1])] = unescapeXml(rawValue);
+    raw.push([m[1], rawValue]);
+  }
+  return { name, attrs, raw };
+}
+function parseXml(src, options = {}) {
+  const namespaces = options.namespaces === true;
+  let i = 0;
+  const n = src.length;
+  const root = { name: "#root", attrs: {}, children: [], text: "" };
+  if (namespaces) root.content = [];
+  const stack = [root];
+  const scopes = [{ xml: XML_NS }];
+  const appendText = (text2) => {
+    const top = stack[stack.length - 1];
+    top.text += text2;
+    if (namespaces && text2 !== "") top.content.push(text2);
+  };
+  while (i < n) {
+    if (src[i] === "<") {
+      if (src.startsWith("<!--", i)) {
+        const end2 = src.indexOf("-->", i);
+        i = end2 < 0 ? n : end2 + 3;
+        continue;
+      }
+      if (src.startsWith("<![CDATA[", i)) {
+        const end2 = src.indexOf("]]>", i);
+        appendText(src.slice(i + 9, end2 < 0 ? n : end2));
+        i = end2 < 0 ? n : end2 + 3;
+        continue;
+      }
+      if (src.startsWith("<?", i)) {
+        const end2 = src.indexOf("?>", i);
+        i = end2 < 0 ? n : end2 + 2;
+        continue;
+      }
+      if (src.startsWith("<!", i)) {
+        const end2 = src.indexOf(">", i);
+        i = end2 < 0 ? n : end2 + 1;
+        continue;
+      }
+      if (src[i + 1] === "/") {
+        const end2 = src.indexOf(">", i);
+        if (stack.length > 1) {
+          stack.pop();
+          if (namespaces) scopes.pop();
+        }
+        i = end2 < 0 ? n : end2 + 1;
+        continue;
+      }
+      const end = findTagEnd(src, i + 1);
+      const tagContent = src.slice(i + 1, end);
+      const selfClosing = tagContent.endsWith("/");
+      const { name, attrs, raw } = parseTag(selfClosing ? tagContent.slice(0, -1) : tagContent);
+      const node = { name: localName(name), attrs, children: [], text: "" };
+      const parent = stack[stack.length - 1];
+      parent.children.push(node);
+      let scope;
+      if (namespaces) {
+        scope = resolveNamespaces(node, name, raw, scopes[scopes.length - 1]);
+        parent.content.push(node);
+      }
+      if (!selfClosing) {
+        stack.push(node);
+        if (scope) scopes.push(scope);
+      }
+      i = end + 1;
+    } else {
+      const next = src.indexOf("<", i);
+      const stop = next < 0 ? n : next;
+      appendText(unescapeXml(src.slice(i, stop)));
+      i = stop;
+    }
+  }
+  return root.children[0] ?? null;
+}
+function resolveNamespaces(node, qname, raw, parentScope) {
+  let scope = parentScope;
+  for (const [key, value] of raw) {
+    if (key === "xmlns" || key.startsWith("xmlns:")) {
+      if (scope === parentScope) scope = { ...parentScope };
+      scope[key === "xmlns" ? "" : key.slice(6)] = unescapeXml(value);
+    }
+  }
+  const colon = qname.indexOf(":");
+  node.ns = scope[colon >= 0 ? qname.slice(0, colon) : ""] ?? "";
+  node.content = [];
+  const nsAttrs = {};
+  for (const [key, value] of raw) {
+    if (key === "xmlns" || key.startsWith("xmlns:")) continue;
+    const idx = key.indexOf(":");
+    const normalised = unescapeXml(value.replace(/[\t\n\r]/g, " "));
+    if (idx < 0) {
+      nsAttrs[key] = normalised;
+    } else {
+      nsAttrs[`{${scope[key.slice(0, idx)] ?? ""}}${key.slice(idx + 1)}`] = normalised;
+    }
+  }
+  node.nsAttrs = nsAttrs;
+  return scope;
+}
+function el(node, name) {
+  return node?.children.find((c) => c.name === name);
+}
+function els(node, name) {
+  return node ? node.children.filter((c) => c.name === name) : [];
+}
+function at(node, name) {
+  return node?.attrs[name];
+}
+
+// src/zip/office-template.ts
+var DOCUMENT = "document";
+var TEMPLATE = "template";
+var FAMILY = "spreadsheet";
+var VBA = "application/vnd.ms-office.vbaProject";
+var FAMILIES = {
+  word: {
+    part: "/word/document.xml",
+    document: "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml",
+    template: "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml",
+    macroDocument: "application/vnd.ms-word.document.macroEnabled.main+xml",
+    macroTemplate: "application/vnd.ms-word.template.macroEnabledTemplate.main+xml",
+    odfDocument: "application/vnd.oasis.opendocument.text",
+    odfTemplate: "application/vnd.oasis.opendocument.text-template",
+    odfBody: "text"
+  },
+  presentation: {
+    part: "/ppt/presentation.xml",
+    document: "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml",
+    template: "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml",
+    macroDocument: "application/vnd.ms-powerpoint.presentation.macroEnabled.main+xml",
+    macroTemplate: "application/vnd.ms-powerpoint.template.macroEnabled.main+xml",
+    odfDocument: "application/vnd.oasis.opendocument.presentation",
+    odfTemplate: "application/vnd.oasis.opendocument.presentation-template",
+    odfBody: "presentation"
+  },
+  spreadsheet: {
+    part: "/xl/workbook.xml",
+    document: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
+    template: "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml",
+    macroDocument: "application/vnd.ms-excel.sheet.macroEnabled.main+xml",
+    macroTemplate: "application/vnd.ms-excel.template.macroEnabled.main+xml",
+    odfDocument: "application/vnd.oasis.opendocument.spreadsheet",
+    odfTemplate: "application/vnd.oasis.opendocument.spreadsheet-template",
+    odfBody: "spreadsheet"
+  }
+};
+var OWN = FAMILIES[FAMILY];
+var UTF8 = new TextDecoder("utf-8");
+function filesView(files) {
+  return {
+    read: (name) => Object.prototype.hasOwnProperty.call(files, name) ? files[name] : null,
+    names: () => Object.keys(files)
+  };
+}
+function sourceKind(zip) {
+  const types = zip.read("[Content_Types].xml");
+  if (types !== null) return ooxmlKind(zip, types);
+  const mimetype = zip.read("mimetype");
+  if (mimetype !== null) return odfKind(zip, latin1(mimetype));
+  return DOCUMENT;
+}
+function convert(bytes, to = null) {
+  if (to !== null && to !== DOCUMENT && to !== TEMPLATE) throw new OfficeTemplateRefused("bad_target");
+  const zip = SourceArchive.open(new Uint8Array(bytes));
+  const kind = sourceKind(zip);
+  const target = to ?? (kind === TEMPLATE ? DOCUMENT : TEMPLATE);
+  if (target === kind) throw new OfficeTemplateRefused(`already_${kind}`);
+  const replacements = /* @__PURE__ */ new Map();
+  const types = zip.read("[Content_Types].xml");
+  const mimetypeBytes = zip.read("mimetype");
+  if (types !== null) {
+    const declared = declarations(types);
+    if (declared === null) throw new OfficeTemplateRefused("not_convertible");
+    if (hasVba(zip, declared) || typesOf(declared, OWN.part).includes(OWN.macroDocument)) {
+      throw new OfficeTemplateRefused("macro_enabled");
+    }
+    const [from, value] = target === TEMPLATE ? [OWN.document, OWN.template] : [OWN.template, OWN.document];
+    replacements.set("[Content_Types].xml", fromLatin1(rewriteOverride(latin1(types), OWN.part, from, value)));
+  } else if (mimetypeBytes !== null) {
+    const entries = zip.entries();
+    const first2 = entries[0];
+    const byLocal = [...entries].sort((a, b) => a.local - b.local);
+    if (first2 === void 0 || first2.name !== "mimetype" || byLocal[0].name !== "mimetype" || first2.method !== 0 || first2.localExtra !== 0) {
+      throw new OfficeTemplateRefused("odf_mimetype");
+    }
+    const [from, value] = target === TEMPLATE ? [OWN.odfDocument, OWN.odfTemplate] : [OWN.odfTemplate, OWN.odfDocument];
+    if (latin1(mimetypeBytes) !== from) throw new OfficeTemplateRefused("not_convertible");
+    replacements.set("mimetype", fromLatin1(value));
+    const manifest = zip.read("META-INF/manifest.xml");
+    if (manifest !== null) {
+      const rewritten = rewriteManifestRoot(latin1(manifest), from, value);
+      if (rewritten !== null) replacements.set("META-INF/manifest.xml", fromLatin1(rewritten));
+    }
+  } else {
+    throw new OfficeTemplateRefused("not_convertible");
+  }
+  const out = rebuild(zip, replacements);
+  if (sourceKind(SourceArchive.open(out)) !== target) {
+    throw new Error("Template conversion did not produce the requested kind.");
+  }
+  return out;
+}
+function ooxmlKind(zip, types) {
+  const declared = declarations(types);
+  if (declared === null) return DOCUMENT;
+  let kind = DOCUMENT;
+  for (const [part2, type] of declared) {
+    for (const [name, family] of Object.entries(FAMILIES)) {
+      if (type !== family.template && type !== family.macroTemplate) continue;
+      if (name !== FAMILY || part2 !== asciiLower2(OWN.part)) throw new OfficeTemplateRefused("family_mismatch");
+      if (type === family.macroTemplate) throw new OfficeTemplateRefused("macro_enabled");
+      kind = TEMPLATE;
+    }
+  }
+  if (kind === TEMPLATE && hasVba(zip, declared)) throw new OfficeTemplateRefused("macro_enabled");
+  return kind;
+}
+function odfKind(zip, mimetype) {
+  if (mimetype !== OWN.odfTemplate) {
+    if (mimetype.startsWith("application/vnd.oasis.opendocument.") && mimetype.endsWith("-template")) {
+      throw new OfficeTemplateRefused("family_mismatch");
+    }
+    return DOCUMENT;
+  }
+  const content = dom(zip.read("content.xml"));
+  const body = content !== null ? firstByLocalName(content, "body") : null;
+  const first2 = body?.children[0] ?? null;
+  if (first2 === null || first2.name !== OWN.odfBody) throw new OfficeTemplateRefused("family_mismatch");
+  const root = manifestRootType(dom(zip.read("META-INF/manifest.xml")));
+  if (root !== null && root !== OWN.odfTemplate && root !== OWN.odfDocument) {
+    throw new OfficeTemplateRefused("family_mismatch");
+  }
+  return TEMPLATE;
+}
+function declarations(types) {
+  const root = dom(types);
+  if (root === null) return null;
+  const out = [];
+  for (const el2 of elements(root)) {
+    if (el2.name === "Override") out.push([asciiLower2(el2.attrs["PartName"] ?? ""), el2.attrs["ContentType"] ?? ""]);
+    else if (el2.name === "Default") out.push([`*.${asciiLower2(el2.attrs["Extension"] ?? "")}`, el2.attrs["ContentType"] ?? ""]);
+  }
+  return out;
+}
+function typesOf(declared, part2) {
+  return declared.filter(([name]) => name === asciiLower2(part2)).map(([, type]) => type);
+}
+function hasVba(zip, declared) {
+  if (declared.some(([, type]) => asciiLower2(type) === asciiLower2(VBA))) return true;
+  return zip.names().some((name) => /(^|\/)vbaProject\.bin$/i.test(name));
+}
+function manifestRootType(root) {
+  if (root === null) return null;
+  for (const el2 of elements(root)) {
+    if (el2.name === "file-entry" && el2.attrs["full-path"] === "/") return el2.attrs["media-type"] ?? null;
+  }
+  return null;
+}
+function rewriteOverride(xml, part2, from, to) {
+  const hits = [];
+  for (const tag of xml.matchAll(/<(?:[A-Za-z_][\w.\-]*:)?Override\b[^>]*>/g)) {
+    const name = /\sPartName\s*=\s*(["'])(.*?)\1/s.exec(tag[0]);
+    if (name === null || asciiLower2(name[2]) !== asciiLower2(part2)) continue;
+    const type = /\sContentType\s*=\s*(["'])(.*?)\1/s.exec(tag[0]);
+    if (type !== null && type[2] === from) hits.push(tag.index + type.index + type[0].indexOf(type[1]) + 1);
+  }
+  if (hits.length !== 1) throw new OfficeTemplateRefused("not_convertible");
+  const out = xml.slice(0, hits[0]) + to + xml.slice(hits[0] + from.length);
+  const declared = declarations(out);
+  const after = declared === null ? [] : typesOf(declared, part2);
+  if (after.length !== 1 || after[0] !== to) throw new OfficeTemplateRefused("not_convertible");
+  return out;
+}
+function rewriteManifestRoot(xml, from, to) {
+  const current = manifestRootType(dom(xml));
+  if (current === null) return null;
+  if (current !== from) throw new OfficeTemplateRefused("not_convertible");
+  const hits = [];
+  for (const tag of xml.matchAll(/<(?:[A-Za-z_][\w.\-]*:)?file-entry\b[^>]*>/g)) {
+    if (!/\s(?:[A-Za-z_][\w.\-]*:)?full-path\s*=\s*(["'])\/\1/.test(tag[0])) continue;
+    const type = /\s(?:[A-Za-z_][\w.\-]*:)?media-type\s*=\s*(["'])(.*?)\1/s.exec(tag[0]);
+    if (type !== null && type[2] === from) hits.push(tag.index + type.index + type[0].indexOf(type[1]) + 1);
+  }
+  if (hits.length !== 1) throw new OfficeTemplateRefused("not_convertible");
+  const out = xml.slice(0, hits[0]) + to + xml.slice(hits[0] + from.length);
+  if (manifestRootType(dom(out)) !== to) throw new OfficeTemplateRefused("not_convertible");
+  return out;
+}
+function rebuild(zip, replacements) {
+  const original = zip.toBytes();
+  const view = new DataView(original.buffer, original.byteOffset, original.byteLength);
+  const u16 = (at2) => view.getUint16(at2, true);
+  const u32 = (at2) => view.getUint32(at2, true);
+  const entries = zip.entries();
+  const byLocal = [...entries].sort((a, b) => a.local - b.local);
+  const nameBytes = (entry) => original.subarray(entry.central + 46, entry.central + 46 + u16(entry.central + 28));
+  const chunks = [];
+  const offsets = /* @__PURE__ */ new Map();
+  let length = 0;
+  const push = (chunk) => {
+    chunks.push(chunk);
+    length += chunk.length;
+  };
+  for (const entry of byLocal) {
+    offsets.set(entry.name, length);
+    const data = replacements.get(entry.name);
+    if (data === void 0) {
+      push(original.subarray(entry.local, entry.finish));
+      continue;
+    }
+    const name = nameBytes(entry);
+    const header = new Uint8Array(30 + name.length + data.length);
+    const hv = new DataView(header.buffer);
+    hv.setUint32(0, 67324752, true);
+    hv.setUint16(4, 10, true);
+    hv.setUint16(6, entry.flags & 2048, true);
+    hv.setUint16(8, 0, true);
+    hv.setUint16(10, u16(entry.local + 10), true);
+    hv.setUint16(12, u16(entry.local + 12), true);
+    hv.setUint32(14, crc32(data) >>> 0, true);
+    hv.setUint32(18, data.length, true);
+    hv.setUint32(22, data.length, true);
+    hv.setUint16(26, name.length, true);
+    hv.setUint16(28, 0, true);
+    header.set(name, 30);
+    header.set(data, 30 + name.length);
+    push(header);
+  }
+  const localsLength = length;
+  for (const entry of entries) {
+    const data = replacements.get(entry.name);
+    if (data === void 0) {
+      const record2 = new Uint8Array(entry.centralLength);
+      record2.set(original.subarray(entry.central, entry.central + entry.centralLength));
+      new DataView(record2.buffer, record2.byteOffset, record2.byteLength).setUint32(42, offsets.get(entry.name), true);
+      push(record2);
+      continue;
+    }
+    const name = nameBytes(entry);
+    const at2 = entry.central;
+    const record = new Uint8Array(46 + name.length);
+    const rv = new DataView(record.buffer);
+    rv.setUint32(0, 33639248, true);
+    rv.setUint16(4, u16(at2 + 4), true);
+    rv.setUint16(6, 10, true);
+    rv.setUint16(8, entry.flags & 2048, true);
+    rv.setUint16(10, 0, true);
+    rv.setUint16(12, u16(at2 + 12), true);
+    rv.setUint16(14, u16(at2 + 14), true);
+    rv.setUint32(16, crc32(data) >>> 0, true);
+    rv.setUint32(20, data.length, true);
+    rv.setUint32(24, data.length, true);
+    rv.setUint16(28, name.length, true);
+    rv.setUint16(36, u16(at2 + 36), true);
+    rv.setUint32(38, u32(at2 + 38), true);
+    rv.setUint32(42, offsets.get(entry.name), true);
+    record.set(name, 46);
+    push(record);
+  }
+  const comment = zip.comment();
+  const end = new Uint8Array(22 + comment.length);
+  const ev = new DataView(end.buffer);
+  ev.setUint32(0, 101010256, true);
+  ev.setUint16(8, entries.length, true);
+  ev.setUint16(10, entries.length, true);
+  ev.setUint32(12, length - localsLength, true);
+  ev.setUint32(16, localsLength, true);
+  ev.setUint16(20, comment.length, true);
+  end.set(comment, 22);
+  push(end);
+  const out = new Uint8Array(length);
+  let pos = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, pos);
+    pos += chunk.length;
+  }
+  return out;
+}
+function dom(xml) {
+  if (xml === null) return null;
+  const text2 = typeof xml === "string" ? UTF8.decode(fromLatin1(xml)) : UTF8.decode(xml);
+  if (text2 === "" || /<!DOCTYPE/i.test(text2)) return null;
+  return parseXml(text2);
+}
+function* elements(root) {
+  const stack = [root];
+  while (stack.length > 0) {
+    const el2 = stack.pop();
+    yield el2;
+    for (let i = el2.children.length - 1; i >= 0; i--) stack.push(el2.children[i]);
+  }
+}
+function firstByLocalName(root, local) {
+  for (const el2 of elements(root)) if (el2.name === local) return el2;
+  return null;
+}
+function asciiLower2(s) {
+  return s.replace(/[A-Z]/g, (c) => String.fromCharCode(c.charCodeAt(0) + 32));
+}
+function latin1(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 32768) out += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return out;
+}
+function fromLatin1(s) {
+  const out = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i) & 255;
+  return out;
+}
+
+// src/reader/file-input.ts
+async function readFileBounded(path) {
+  const fs = await import('fs');
+  if (!fs.statSync(path).isFile()) throw new ArchiveRefused("archive_path");
+  const fd = fs.openSync(path, "r");
+  const limit = DEFAULT_ARCHIVE_LIMITS.maxArchiveBytes;
+  try {
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile()) throw new ArchiveRefused("archive_path");
+    if (stat.size > limit) throw new ArchiveRefused("archive_limit");
+    const chunks = [];
+    let total = 0;
+    for (; ; ) {
+      const chunk = new Uint8Array(Math.min(65536, limit + 1 - total));
+      const count = fs.readSync(fd, chunk, 0, chunk.length, null);
+      if (count === 0) break;
+      if (total + count > limit) throw new ArchiveRefused("archive_limit");
+      chunks.push(chunk.subarray(0, count));
+      total += count;
+    }
+    const bytes = new Uint8Array(total);
+    let at2 = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, at2);
+      at2 += chunk.length;
+    }
+    return bytes;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
 // src/reader/ods/ods-formula.ts
 function odsFormulaToA1(formula2) {
   let grammar = "of";
@@ -3177,6 +3885,7 @@ var WorkbookSchema = {
   fromWorkbook(workbook) {
     const schema = { sheets: workbook.sheets.map(sheetToSchema) };
     if (Object.keys(workbook.meta).length > 0) schema["meta"] = workbook.meta;
+    if (workbook.sourceKind === "template") schema["sourceKind"] = "template";
     return schema;
   }
 };
@@ -3279,176 +3988,11 @@ function commentToObject(c) {
   return out;
 }
 
-// src/reader/xml.ts
-var XML_NS = "http://www.w3.org/XML/1998/namespace";
-function localName(name) {
-  const idx = name.indexOf(":");
-  return idx >= 0 ? name.slice(idx + 1) : name;
-}
-function unescapeXml(s) {
-  if (s.indexOf("&") < 0) return s;
-  return s.replace(/&(#x?[0-9a-fA-F]+|\w+);/g, (m, ent) => {
-    switch (ent) {
-      case "amp":
-        return "&";
-      case "lt":
-        return "<";
-      case "gt":
-        return ">";
-      case "quot":
-        return '"';
-      case "apos":
-        return "'";
-      default:
-        if (ent[0] === "#") {
-          const code = ent[1] === "x" || ent[1] === "X" ? parseInt(ent.slice(2), 16) : parseInt(ent.slice(1), 10);
-          return Number.isFinite(code) ? String.fromCodePoint(code) : m;
-        }
-        return m;
-    }
-  });
-}
-function findTagEnd(src, from) {
-  let quote2 = "";
-  for (let i = from; i < src.length; i++) {
-    const ch = src[i];
-    if (quote2) {
-      if (ch === quote2) quote2 = "";
-    } else if (ch === '"' || ch === "'") {
-      quote2 = ch;
-    } else if (ch === ">") {
-      return i;
-    }
-  }
-  return src.length;
-}
-var ATTR_RE = /([^\s=/]+)\s*=\s*("([^"]*)"|'([^']*)')/g;
-function parseTag(inner) {
-  const trimmed = inner.trim();
-  let i = 0;
-  while (i < trimmed.length && !/\s/.test(trimmed[i])) i++;
-  const name = trimmed.slice(0, i);
-  const attrs = {};
-  const raw = [];
-  const rest = trimmed.slice(i);
-  for (const m of rest.matchAll(ATTR_RE)) {
-    const rawValue = m[3] ?? m[4] ?? "";
-    attrs[localName(m[1])] = unescapeXml(rawValue);
-    raw.push([m[1], rawValue]);
-  }
-  return { name, attrs, raw };
-}
-function parseXml(src, options = {}) {
-  const namespaces = options.namespaces === true;
-  let i = 0;
-  const n = src.length;
-  const root = { name: "#root", attrs: {}, children: [], text: "" };
-  if (namespaces) root.content = [];
-  const stack = [root];
-  const scopes = [{ xml: XML_NS }];
-  const appendText = (text2) => {
-    const top = stack[stack.length - 1];
-    top.text += text2;
-    if (namespaces && text2 !== "") top.content.push(text2);
-  };
-  while (i < n) {
-    if (src[i] === "<") {
-      if (src.startsWith("<!--", i)) {
-        const end2 = src.indexOf("-->", i);
-        i = end2 < 0 ? n : end2 + 3;
-        continue;
-      }
-      if (src.startsWith("<![CDATA[", i)) {
-        const end2 = src.indexOf("]]>", i);
-        appendText(src.slice(i + 9, end2 < 0 ? n : end2));
-        i = end2 < 0 ? n : end2 + 3;
-        continue;
-      }
-      if (src.startsWith("<?", i)) {
-        const end2 = src.indexOf("?>", i);
-        i = end2 < 0 ? n : end2 + 2;
-        continue;
-      }
-      if (src.startsWith("<!", i)) {
-        const end2 = src.indexOf(">", i);
-        i = end2 < 0 ? n : end2 + 1;
-        continue;
-      }
-      if (src[i + 1] === "/") {
-        const end2 = src.indexOf(">", i);
-        if (stack.length > 1) {
-          stack.pop();
-          if (namespaces) scopes.pop();
-        }
-        i = end2 < 0 ? n : end2 + 1;
-        continue;
-      }
-      const end = findTagEnd(src, i + 1);
-      const tagContent = src.slice(i + 1, end);
-      const selfClosing = tagContent.endsWith("/");
-      const { name, attrs, raw } = parseTag(selfClosing ? tagContent.slice(0, -1) : tagContent);
-      const node = { name: localName(name), attrs, children: [], text: "" };
-      const parent = stack[stack.length - 1];
-      parent.children.push(node);
-      let scope;
-      if (namespaces) {
-        scope = resolveNamespaces(node, name, raw, scopes[scopes.length - 1]);
-        parent.content.push(node);
-      }
-      if (!selfClosing) {
-        stack.push(node);
-        if (scope) scopes.push(scope);
-      }
-      i = end + 1;
-    } else {
-      const next = src.indexOf("<", i);
-      const stop = next < 0 ? n : next;
-      appendText(unescapeXml(src.slice(i, stop)));
-      i = stop;
-    }
-  }
-  return root.children[0] ?? null;
-}
-function resolveNamespaces(node, qname, raw, parentScope) {
-  let scope = parentScope;
-  for (const [key, value] of raw) {
-    if (key === "xmlns" || key.startsWith("xmlns:")) {
-      if (scope === parentScope) scope = { ...parentScope };
-      scope[key === "xmlns" ? "" : key.slice(6)] = unescapeXml(value);
-    }
-  }
-  const colon = qname.indexOf(":");
-  node.ns = scope[colon >= 0 ? qname.slice(0, colon) : ""] ?? "";
-  node.content = [];
-  const nsAttrs = {};
-  for (const [key, value] of raw) {
-    if (key === "xmlns" || key.startsWith("xmlns:")) continue;
-    const idx = key.indexOf(":");
-    const normalised = unescapeXml(value.replace(/[\t\n\r]/g, " "));
-    if (idx < 0) {
-      nsAttrs[key] = normalised;
-    } else {
-      nsAttrs[`{${scope[key.slice(0, idx)] ?? ""}}${key.slice(idx + 1)}`] = normalised;
-    }
-  }
-  node.nsAttrs = nsAttrs;
-  return scope;
-}
-function el(node, name) {
-  return node?.children.find((c) => c.name === name);
-}
-function els(node, name) {
-  return node ? node.children.filter((c) => c.name === name) : [];
-}
-function at(node, name) {
-  return node?.attrs[name];
-}
-
 // src/reader/ods-reader.ts
 var MAX_ROWS = 1048576;
 var MAX_COLUMNS = 16384;
 var UNIX_EPOCH_SERIAL = 25569;
-var decoder3 = new TextDecoder();
+var decoder2 = new TextDecoder();
 var OdsReader = class {
   describe(bytes) {
     return WorkbookSchema.fromWorkbook(this.readWorkbook(bytes));
@@ -3458,7 +4002,8 @@ var OdsReader = class {
   }
   /** Read an already-unzipped package (name -> bytes). */
   readFiles(files) {
-    const getText = (name) => files[name] ? decoder3.decode(files[name]) : null;
+    const kind = sourceKind(filesView(files));
+    const getText = (name) => files[name] ? decoder2.decode(files[name]) : null;
     const content = getText("content.xml");
     if (content === null) throw new Error("[holy-sheet] missing content.xml");
     const contentDoc = parseXml(content, { namespaces: true });
@@ -3472,7 +4017,7 @@ var OdsReader = class {
       if (table.ns === NS.TABLE && table.name === "table") sheets.push(this.readSheet(table, styles));
     }
     const meta = getText("meta.xml");
-    return new Workbook(sheets, meta === null ? {} : readMeta(meta));
+    return new Workbook(sheets, meta === null ? {} : readMeta(meta), kind);
   }
   readSheet(table, styles) {
     const columns = [];
@@ -3820,7 +4365,7 @@ function points(ser) {
       byIndex.set(parseInt(idx, 10), color2);
     }
   }
-  return [...byIndex.entries()].sort((a, b) => a[0] - b[0]).map(([index, color2]) => ({ index, color: color2 }));
+  return [...byIndex.entries()].sort((a, b) => a[0] - b[0]).map(([index2, color2]) => ({ index: index2, color: color2 }));
 }
 function seriesColor(ser) {
   const spPr = el(ser, "spPr");
@@ -4128,7 +4673,7 @@ function parseFrozen(xml) {
 }
 
 // src/reader/xlsx-reader.ts
-var decoder4 = new TextDecoder();
+var decoder3 = new TextDecoder();
 var XlsxReader = class {
   describe(bytes) {
     return WorkbookSchema.fromWorkbook(this.readWorkbook(bytes));
@@ -4138,7 +4683,8 @@ var XlsxReader = class {
   }
   /** Read an already-unzipped package (name -> bytes), so a caller that sniffed it does not unzip twice. */
   readFiles(files) {
-    const getText = (name) => files[name] ? decoder4.decode(files[name]) : null;
+    const kind = sourceKind(filesView(files));
+    const getText = (name) => files[name] ? decoder3.decode(files[name]) : null;
     const stylesXml = getText("xl/styles.xml");
     const stylesIndex = stylesXml ? StylesParser.parse(stylesXml) : [];
     const sharedStringsXml = getText("xl/sharedStrings.xml");
@@ -4193,7 +4739,7 @@ var XlsxReader = class {
       i++;
     }
     const meta = this.parseDocProps(getText("docProps/core.xml"));
-    return new Workbook(sheets, meta);
+    return new Workbook(sheets, meta, kind);
   }
   parseDocProps(coreXml) {
     if (coreXml === null) return {};
@@ -5008,11 +5554,11 @@ var SheetReducer = {
       if (!isArr(get(op, "sheet"))) {
         return schema;
       }
-      const index = has(op, "index") ? phpInteger(op.index) : sheets.length;
-      if (index === null) {
+      const index2 = has(op, "index") ? phpInteger(op.index) : sheets.length;
+      if (index2 === null) {
         return schema;
       }
-      sheets.splice(Math.max(0, Math.min(sheets.length, index)), 0, op.sheet);
+      sheets.splice(Math.max(0, Math.min(sheets.length, index2)), 0, op.sheet);
       return { ...schema, sheets };
     }
     const at2 = find(sheets, phpString(get(op, "sheet") ?? ""));
@@ -5188,11 +5734,11 @@ function shiftColumns(sheet, at2, delta) {
   });
   if (isArr(get(sheet, "columnWidths"))) {
     const widths = /* @__PURE__ */ new Map();
-    for (const [index, width] of entriesOf(sheet.columnWidths)) {
-      if (!isIndexKey(index)) {
+    for (const [index2, width] of entriesOf(sheet.columnWidths)) {
+      if (!isIndexKey(index2)) {
         continue;
       }
-      const i = phpInt2(index);
+      const i = phpInt2(index2);
       const number = i + 1;
       if (number < at2) {
         widths.set(i, width);
@@ -5201,8 +5747,8 @@ function shiftColumns(sheet, at2, delta) {
       }
     }
     const sorted = {};
-    for (const [index, width] of [...widths.entries()].sort((x, y) => x[0] - y[0])) {
-      sorted[index] = width;
+    for (const [index2, width] of [...widths.entries()].sort((x, y) => x[0] - y[0])) {
+      sorted[index2] = width;
     }
     sheet = setOrUnset(sheet, "columnWidths", sorted, EMPTY);
   }
@@ -5465,22 +6011,22 @@ function granular(a, b) {
       ops.push({ type: "rename_sheet", sheet: name, name: renames.get(name) });
     }
   }
-  namesB.forEach((name, index) => {
+  namesB.forEach((name, index2) => {
     if (unmatchedAdded.includes(name)) {
-      ops.push({ type: "add_sheet", index, sheet: sheetsB[index] });
+      ops.push({ type: "add_sheet", index: index2, sheet: sheetsB[index2] });
     }
   });
   let state = SheetReducer.applyAll(a, ops);
-  namesB.forEach((name, index) => {
+  namesB.forEach((name, index2) => {
     const current = new Map(entriesOf(get(state, "sheets") ?? []).map(([key, sheet]) => [key, sheetName(sheet)]));
-    if ((current.get(String(index)) ?? null) !== name) {
-      const op = { type: "move_sheet", sheet: name, toIndex: index };
+    if ((current.get(String(index2)) ?? null) !== name) {
+      const op = { type: "move_sheet", sheet: name, toIndex: index2 };
       ops.push(op);
       state = SheetReducer.apply(state, op);
     }
   });
-  sheetsB.forEach((target, index) => {
-    const current = state.sheets[index];
+  sheetsB.forEach((target, index2) => {
+    const current = state.sheets[index2];
     if (SheetDiff.same(current, target)) {
       return;
     }
@@ -6131,7 +6677,7 @@ var holy_sheet_schema_default = {
 };
 
 // src/agent.ts
-var VERSION = "2.10.1";
+var VERSION = "2.11.0";
 function toU8(input) {
   return input instanceof Uint8Array ? input : new Uint8Array(input);
 }
@@ -6172,12 +6718,38 @@ var Agent = {
   read(input) {
     return readSpreadsheet(toU8(input), null);
   },
+  /**
+   * Turn an Excel `.xltx` / LibreOffice `.ots` template into its `.xlsx` /
+   * `.ods` twin, or back. `to` is `"document"`, `"template"`, or null to flip.
+   * Universal and synchronous: bytes in, bytes out. Mirrors PHP
+   * `Agent::convertTemplate()`.
+   *
+   * Only the declaration moves: the workbook part's content type in
+   * `[Content_Types].xml`, or the ODF `mimetype` entry together with the
+   * manifest's root media-type (ODF 1.3 requires them to agree). Every other
+   * member is copied as its original zip record, byte for byte.
+   *
+   * Throws `OfficeTemplateRefused` (macro-enabled, mismatched, already that
+   * kind), `ArchiveRefused` (archive guard), or `UnsupportedFormatException`
+   * for a package that is not a spreadsheet.
+   */
+  convertTemplate(input, to = null) {
+    const bytes = toU8(input);
+    const zip = SourceArchive.open(bytes);
+    const raw = zip.read("mimetype");
+    const mimetype = raw === null ? null : new TextDecoder().decode(raw).trim();
+    const odf = mimetype !== null && mimetype.startsWith("application/vnd.oasis.opendocument.spreadsheet");
+    if (!odf && (mimetype !== null || zip.read("xl/workbook.xml") === null)) {
+      throw UnsupportedFormatException.unknownPackage(null, mimetype);
+    }
+    return convert(bytes, to);
+  },
   /** Round-trip an xlsx or ods file on disk back to a schema (Node only). */
   async describe(path) {
     const fs = await import('fs');
     if (!fs.existsSync(path)) return { error: "not_found", path };
-    const bytes = fs.readFileSync(path);
-    return readSpreadsheet(new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength), path);
+    const bytes = await readFileBounded(path);
+    return readSpreadsheet(bytes, path);
   },
   /** Validate + conservative repairs in one call. */
   validateAndRepair(schema) {
@@ -6273,6 +6845,10 @@ var HolySheet = class {
   describe(path) {
     return Agent.describe(path);
   }
+  /** {@link Agent.convertTemplate}: .xltx/.ots to .xlsx/.ods and back. */
+  convertTemplate(input, to = null) {
+    return Agent.convertTemplate(input, to);
+  }
   validateAndRepair(schema) {
     return Agent.validateAndRepair(schema);
   }
@@ -6295,6 +6871,7 @@ var HolySheet = class {
 HolySheet.VERSION = VERSION;
 
 exports.Agent = Agent;
+exports.ArchiveRefused = ArchiveRefused;
 exports.ArrayBuilder = ArrayBuilder;
 exports.CellAddress = CellAddress;
 exports.CsvBuilder = CsvBuilder;
@@ -6304,6 +6881,7 @@ exports.HolySheet = HolySheet;
 exports.Inference = Inference;
 exports.Normalizer = Normalizer;
 exports.OdsReader = OdsReader;
+exports.OfficeTemplateRefused = OfficeTemplateRefused;
 exports.Repairer = Repairer;
 exports.SchemaException = SchemaException;
 exports.SheetDiff = SheetDiff;