@office-kit/xlsx 0.8.0

package/dist/xml/iterparse.d.ts

@@ -0,0 +1,22 @@
+export type SaxEvent = {
+    kind: 'start';
+    name: string;
+    attrs: Record<string, string>;
+} | {
+    kind: 'end';
+    name: string;
+} | {
+    kind: 'text';
+    text: string;
+};
+/**
+ * Streamable input: `Uint8Array`, plain string, or a Web `ReadableStream` of
+ * `Uint8Array` chunks (produced by xlsx zip entries via fflate, fetch, file
+ * streams, etc.).
+ */
+export type SaxInput = Uint8Array | string | ReadableStream<Uint8Array>;
+/**
+ * Parse the input as a stream of SAX events. Element / attribute names are
+ * returned in Clark notation (`{ns}local`).
+ */
+export declare function iterParse(input: SaxInput): AsyncIterableIterator<SaxEvent>;

package/dist/xml/namespaces.d.ts

@@ -0,0 +1,91 @@
+export declare const XML_NS = "http://www.w3.org/XML/1998/namespace";
+export declare const XSI_NS = "http://www.w3.org/2001/XMLSchema-instance";
+export declare const DCORE_NS = "http://purl.org/dc/elements/1.1/";
+export declare const DCTERMS_NS = "http://purl.org/dc/terms/";
+export declare const DCMITYPE_NS = "http://purl.org/dc/dcmitype/";
+export declare const DCTERMS_PREFIX = "dcterms";
+export declare const REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+export declare const COMMENTS_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments";
+export declare const IMAGE_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+export declare const VML_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing";
+export declare const EXTERNAL_LINK_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/externalLink";
+export declare const VTYPES_NS = "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes";
+export declare const XPROPS_NS = "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties";
+export declare const CUSTPROPS_NS = "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties";
+export declare const CPROPS_FMTID = "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}";
+export declare const PKG_REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+export declare const COREPROPS_NS = "http://schemas.openxmlformats.org/package/2006/metadata/core-properties";
+export declare const CONTYPES_NS = "http://schemas.openxmlformats.org/package/2006/content-types";
+export declare const SHEET_MAIN_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+export declare const CHART_NS = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+export declare const DRAWING_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
+export declare const SHEET_DRAWING_NS = "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing";
+export declare const CHART_DRAWING_NS = "http://schemas.openxmlformats.org/drawingml/2006/chartDrawing";
+export declare const PICTURE_NS = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+export declare const CUSTOMUI_NS = "http://schemas.microsoft.com/office/2006/relationships/ui/extensibility";
+export declare const MARKUP_COMPAT_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+export declare const X14_NS = "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main";
+export declare const X15_NS = "http://schemas.microsoft.com/office/spreadsheetml/2010/11/main";
+export declare const X16_NS = "http://schemas.microsoft.com/office/spreadsheetml/2014/revision";
+export declare const C14_NS = "http://schemas.microsoft.com/office/drawing/2010/chart";
+export declare const C15_NS = "http://schemas.microsoft.com/office/drawing/2012/chart";
+export declare const C16_NS = "http://schemas.microsoft.com/office/drawing/2017/03/chart";
+export declare const CX_NS = "http://schemas.microsoft.com/office/drawing/2014/chartex";
+export declare const THREADED_COMMENTS_NS = "http://schemas.microsoft.com/office/spreadsheetml/2018/threadedcomments";
+export declare const DEFAULT_PREFIXES: Readonly<Record<string, string>>;
+export declare const PACKAGE_PROPS = "docProps";
+export declare const PACKAGE_XL = "xl";
+export declare const PACKAGE_RELS = "_rels";
+export declare const PACKAGE_THEME = "xl/theme";
+export declare const PACKAGE_WORKSHEETS = "xl/worksheets";
+export declare const PACKAGE_CHARTSHEETS = "xl/chartsheets";
+export declare const PACKAGE_DRAWINGS = "xl/drawings";
+export declare const PACKAGE_CHARTS = "xl/charts";
+export declare const PACKAGE_IMAGES = "xl/media";
+export declare const PACKAGE_PIVOT_TABLE = "xl/pivotTables";
+export declare const PACKAGE_PIVOT_CACHE = "xl/pivotCache";
+export declare const PACKAGE_WORKSHEET_RELS = "xl/worksheets/_rels";
+export declare const PACKAGE_CHARTSHEETS_RELS = "xl/chartsheets/_rels";
+export declare const ARC_CONTENT_TYPES = "[Content_Types].xml";
+export declare const ARC_ROOT_RELS = "_rels/.rels";
+export declare const ARC_WORKBOOK_RELS = "xl/_rels/workbook.xml.rels";
+export declare const ARC_CORE = "docProps/core.xml";
+export declare const ARC_APP = "docProps/app.xml";
+export declare const ARC_CUSTOM = "docProps/custom.xml";
+export declare const ARC_WORKBOOK = "xl/workbook.xml";
+export declare const ARC_STYLE = "xl/styles.xml";
+export declare const ARC_THEME = "xl/theme/theme1.xml";
+export declare const ARC_SHARED_STRINGS = "xl/sharedStrings.xml";
+export declare const ARC_CUSTOM_UI = "customUI/customUI.xml";
+export declare const XLSX_TYPE: string;
+export declare const XLTX_TYPE: string;
+export declare const XLSM_TYPE: string;
+export declare const XLTM_TYPE: string;
+export declare const SHARED_STRINGS_TYPE: string;
+export declare const EXTERNAL_LINK_TYPE: string;
+export declare const WORKSHEET_TYPE: string;
+export declare const COMMENTS_TYPE: string;
+export declare const STYLES_TYPE: string;
+export declare const CHARTSHEET_TYPE: string;
+export declare const DRAWING_TYPE = "application/vnd.openxmlformats-officedocument.drawing+xml";
+export declare const CHART_TYPE = "application/vnd.openxmlformats-officedocument.drawingml.chart+xml";
+export declare const CHARTEX_TYPE = "application/vnd.ms-office.chartex+xml";
+export declare const CHARTSHAPE_TYPE = "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml";
+export declare const THEME_TYPE = "application/vnd.openxmlformats-officedocument.theme+xml";
+export declare const CPROPS_TYPE = "application/vnd.openxmlformats-officedocument.custom-properties+xml";
+export declare const VBA_TYPE = "application/vnd.ms-office.vbaProject";
+export declare const ACTIVEX_TYPE = "application/vnd.ms-office.activeX+xml";
+export declare const CTRLPROPS_TYPE = "application/vnd.ms-excel.controlproperties+xml";
+/**
+ * Build a Clark-notation QName: `{namespace}localname`. When `namespace` is
+ * empty / undefined the local name is returned as-is.
+ */
+export declare function qname(namespace: string | undefined, local: string): string;
+/**
+ * Inverse of {@link qname}. Returns `{ ns, local }`. For unprefixed names `ns`
+ * is the empty string.
+ */
+export declare function parseQName(name: string): {
+    ns: string;
+    local: string;
+};

package/dist/xml/parser.d.ts

@@ -0,0 +1,7 @@
+import { type XmlNode } from './tree';
+/**
+ * Parse a UTF-8 XML payload into an {@link XmlNode} tree. Element and attribute
+ * names are returned in Clark notation. Throws {@link OpenXmlSchemaError} on
+ * DTD/entity declarations or on multi-root documents.
+ */
+export declare function parseXml(input: Uint8Array | string): XmlNode;

package/dist/xml/serializer.d.ts

@@ -0,0 +1,14 @@
+import type { XmlNode } from './tree';
+export interface SerializeOptions {
+    /** Emit `<?xml … ?>` declaration. Defaults to true. */
+    xmlDeclaration?: boolean;
+    /** `standalone` attribute on the declaration. Defaults to 'yes'. */
+    standalone?: 'yes' | 'no' | 'omit';
+}
+/**
+ * Serialize an {@link XmlNode} tree into a UTF-8 byte payload. The
+ * inverse of {@link parseXml}: `parseXml(serializeXml(n))` yields a
+ * tree structurally equivalent to `n` modulo attribute insertion order
+ * (which both directions preserve on Node 18+ / V8).
+ */
+export declare function serializeXml(root: XmlNode, opts?: SerializeOptions): Uint8Array;

package/dist/xml/stream-writer.d.ts

@@ -0,0 +1,39 @@
+import type { XmlNode } from './tree';
+export interface XmlStreamWriterOptions {
+    /** Map of namespace URI → prefix. Merged on top of DEFAULT_PREFIXES. */
+    prefixMap?: Readonly<Record<string, string>>;
+    /** Emit `<?xml … ?>` declaration first. Defaults to true. */
+    xmlDeclaration?: boolean;
+    /** `standalone` attribute on the declaration. Defaults to 'yes'. */
+    standalone?: 'yes' | 'no' | 'omit';
+    /**
+     * Auto-flush threshold in bytes. Once the in-flight string buffer crosses
+     * this size it gets encoded into a chunk and parked. Larger values trade
+     * memory for fewer TextEncoder calls; smaller values lower peak memory at the
+     * cost of CPU.
+     */
+    flushBytes?: number;
+}
+export interface XmlStreamWriter {
+    /**
+     * Open an element. Names are in Clark notation (`{ns}local`); the writer
+     * prefixes them via the configured prefix map.
+     */
+    start(name: string, attrs?: Record<string, string>): void;
+    /** Emit a text node inside the currently open element. */
+    text(s: string): void;
+    /** Emit a complete subtree. Closes any pending start tag first. */
+    writeNode(n: XmlNode): void;
+    /** Emit pre-rendered XML bytes verbatim — escape-hatch for hot paths. */
+    writeRaw(s: string): void;
+    /** Close the currently open element (matched against the start stack). */
+    end(): void;
+    /** Force any buffered bytes into the chunk store immediately. */
+    flush(): void;
+    /**
+     * Materialise everything written so far. Throws if any element is still open.
+     * Idempotent.
+     */
+    result(): Uint8Array;
+}
+export declare function createXmlStreamWriter(opts?: XmlStreamWriterOptions): XmlStreamWriter;

package/dist/xml/tree.d.ts

@@ -0,0 +1,37 @@
+export interface XmlNode {
+    /** Clark-notation qualified name: `{namespace}local` or just `local`. */
+    name: string;
+    /** Attribute table; values are always strings (no value coercion at this layer). */
+    attrs: Record<string, string>;
+    /**
+     * Optional element text. When an element has both text and child elements,
+     * callers should set `text` and rely on `children` for mixed content; the
+     * serializer emits `text` then children.
+     */
+    text?: string;
+    /** Child element nodes in document order. */
+    children: XmlNode[];
+}
+/**
+ * Build an XmlNode from primitive bits. Attributes / children default to empty;
+ * pass `undefined` for `text` to omit the text node.
+ *
+ * The element's name is always supplied in Clark notation. Use the {@link
+ * qname} helper from `./namespaces` to keep call sites readable.
+ */
+export declare function el(name: string, attrs?: Readonly<Record<string, string | number | boolean | null | undefined>>, children?: ReadonlyArray<XmlNode>, text?: string): XmlNode;
+/**
+ * Convenience: element with a Clark-notation name composed from a namespace URI
+ * and local name.
+ */
+export declare function elNs(namespace: string | undefined, local: string, attrs?: Readonly<Record<string, string | number | boolean | null | undefined>>, children?: ReadonlyArray<XmlNode>, text?: string): XmlNode;
+/** Locate the first child matching the supplied Clark-notation name. */
+export declare function findChild(node: XmlNode, name: string): XmlNode | undefined;
+/** All children matching the supplied Clark-notation name, in document order. */
+export declare function findChildren(node: XmlNode, name: string): XmlNode[];
+/**
+ * Append `child` to `parent`. Mutates and returns `parent` for chaining during
+ * construction. Avoid in hot paths — for cell writing the worksheet writer goes
+ * through a templated emitter rather than building XmlNode trees per cell.
+ */
+export declare function appendChild(parent: XmlNode, child: XmlNode): XmlNode;

package/dist/xml.mjs

@@ -0,0 +1,140 @@
+import { i as OpenXmlIoError } from "./exceptions-D-CFwxgm.mjs";
+import { n as escapeXmlAttr, r as escapeXmlText } from "./escape-DFTE7ZJc.mjs";
+import { $ as PACKAGE_PIVOT_CACHE, A as COREPROPS_NS, At as parseQName, B as DCTERMS_PREFIX, C as CHARTSHEET_TYPE, Ct as XLSM_TYPE, D as COMMENTS_NS, Dt as XML_NS, E as CHART_TYPE, Et as XLTX_TYPE, F as CUSTPROPS_NS, G as EXTERNAL_LINK_TYPE, H as DRAWING_NS, I as CX_NS, J as PACKAGE_CHARTS, K as IMAGE_NS, L as DCMITYPE_NS, M as CPROPS_TYPE, N as CTRLPROPS_TYPE, O as COMMENTS_TYPE, Ot as XPROPS_NS, P as CUSTOMUI_NS, Q as PACKAGE_IMAGES, R as DCORE_NS, S as CHARTSHAPE_TYPE, St as X16_NS, T as CHART_NS, Tt as XLTM_TYPE, U as DRAWING_TYPE, V as DEFAULT_PREFIXES, W as EXTERNAL_LINK_NS, X as PACKAGE_CHARTSHEETS_RELS, Y as PACKAGE_CHARTSHEETS, Z as PACKAGE_DRAWINGS, _ as ARC_WORKBOOK_RELS, _t as VML_NS, a as findChildren, at as PACKAGE_WORKSHEET_RELS, b as C16_NS, bt as X14_NS, c as ARC_CONTENT_TYPES, ct as PKG_REL_NS, d as ARC_CUSTOM_UI, dt as SHEET_DRAWING_NS, et as PACKAGE_PIVOT_TABLE, f as ARC_ROOT_RELS, ft as SHEET_MAIN_NS, g as ARC_WORKBOOK, gt as VBA_TYPE, h as ARC_THEME, ht as THREADED_COMMENTS_NS, i as findChild, it as PACKAGE_WORKSHEETS, j as CPROPS_FMTID, jt as qname, k as CONTYPES_NS, kt as XSI_NS, l as ARC_CORE, lt as REL_NS, m as ARC_STYLE, mt as THEME_TYPE, n as el, nt as PACKAGE_RELS, o as ACTIVEX_TYPE, ot as PACKAGE_XL, p as ARC_SHARED_STRINGS, pt as STYLES_TYPE, q as MARKUP_COMPAT_NS, r as elNs, rt as PACKAGE_THEME, s as ARC_APP, st as PICTURE_NS, t as appendChild, tt as PACKAGE_PROPS, u as ARC_CUSTOM, ut as SHARED_STRINGS_TYPE, v as C14_NS, vt as VTYPES_NS, w as CHART_DRAWING_NS, wt as XLSX_TYPE, xt as X15_NS, y as C15_NS, yt as WORKSHEET_TYPE, z as DCTERMS_NS } from "./tree-Bbs1C8Rc.mjs";
+import { t as parseXml } from "./parser-DuLejQy1.mjs";
+import { t as serializeXml } from "./serializer-BwbgHYJV.mjs";
+import { n as iterParse, t as utf8ByteLength } from "./utf8-D91g1XTG.mjs";
+//#region src/xml/stream-writer.ts
+const DEFAULT_FLUSH_BYTES = 64 * 1024;
+const encoder = new TextEncoder();
+const buildPrefixMap = (user) => {
+	const out = /* @__PURE__ */ new Map();
+	for (const [ns, prefix] of Object.entries(DEFAULT_PREFIXES)) out.set(ns, prefix);
+	out.set(XML_NS, "xml");
+	if (user !== void 0) for (const [ns, prefix] of Object.entries(user)) out.set(ns, prefix);
+	return out;
+};
+function createXmlStreamWriter(opts = {}) {
+	const { xmlDeclaration = true, standalone = "yes", flushBytes = DEFAULT_FLUSH_BYTES } = opts;
+	const prefixOf = buildPrefixMap(opts.prefixMap);
+	const chunks = [];
+	let buf = "";
+	let bufBytes = 0;
+	let openStartTag = false;
+	let finalised = false;
+	const stack = [];
+	const append = (s) => {
+		buf += s;
+		bufBytes += utf8ByteLength(s);
+	};
+	const elementName = (name) => {
+		const { ns, local } = parseQName(name);
+		if (ns === "") return local;
+		const prefix = prefixOf.get(ns);
+		if (prefix === void 0 || prefix === "") return local;
+		return `${prefix}:${local}`;
+	};
+	const attributeName = (name) => {
+		const { ns, local } = parseQName(name);
+		if (ns === "") return local;
+		const prefix = prefixOf.get(ns);
+		if (prefix === void 0 || prefix === "") return local;
+		return `${prefix}:${local}`;
+	};
+	const flushImpl = () => {
+		if (buf.length === 0) return;
+		chunks.push(encoder.encode(buf));
+		buf = "";
+		bufBytes = 0;
+	};
+	const maybeFlush = () => {
+		if (bufBytes >= flushBytes) flushImpl();
+	};
+	const closeStartTagIfOpen = () => {
+		if (!openStartTag) return;
+		append(">");
+		openStartTag = false;
+	};
+	if (xmlDeclaration) {
+		append("<?xml version=\"1.0\" encoding=\"UTF-8\"");
+		if (standalone !== "omit") append(` standalone="${standalone}"`);
+		append("?>\n");
+	}
+	const emitNodeInline = (n) => {
+		const tag = elementName(n.name);
+		append(`<${tag}`);
+		for (const [name, value] of Object.entries(n.attrs)) append(` ${attributeName(name)}="${escapeXmlAttr(value)}"`);
+		const text = n.text;
+		const hasText = text !== void 0 && text !== "";
+		const hasChildren = n.children.length > 0;
+		if (!hasText && !hasChildren) {
+			append("/>");
+			return;
+		}
+		append(">");
+		if (hasText) append(escapeXmlText(text));
+		for (const c of n.children) emitNodeInline(c);
+		append(`</${tag}>`);
+	};
+	return {
+		start(name, attrs) {
+			if (finalised) throw new OpenXmlIoError("XmlStreamWriter: start() after result()");
+			closeStartTagIfOpen();
+			const tag = elementName(name);
+			append(`<${tag}`);
+			if (attrs !== void 0) for (const [k, v] of Object.entries(attrs)) append(` ${attributeName(k)}="${escapeXmlAttr(v)}"`);
+			stack.push(tag);
+			openStartTag = true;
+			maybeFlush();
+		},
+		text(s) {
+			if (finalised) throw new OpenXmlIoError("XmlStreamWriter: text() after result()");
+			closeStartTagIfOpen();
+			append(escapeXmlText(s));
+			maybeFlush();
+		},
+		writeNode(n) {
+			if (finalised) throw new OpenXmlIoError("XmlStreamWriter: writeNode() after result()");
+			closeStartTagIfOpen();
+			emitNodeInline(n);
+			maybeFlush();
+		},
+		writeRaw(s) {
+			if (finalised) throw new OpenXmlIoError("XmlStreamWriter: writeRaw() after result()");
+			closeStartTagIfOpen();
+			append(s);
+			maybeFlush();
+		},
+		end() {
+			if (finalised) throw new OpenXmlIoError("XmlStreamWriter: end() after result()");
+			const tag = stack.pop();
+			if (tag === void 0) throw new OpenXmlIoError("XmlStreamWriter: end() with no open element");
+			if (openStartTag) {
+				append("/>");
+				openStartTag = false;
+			} else append(`</${tag}>`);
+			maybeFlush();
+		},
+		flush() {
+			flushImpl();
+		},
+		result() {
+			if (stack.length > 0) throw new OpenXmlIoError(`XmlStreamWriter: ${stack.length} unclosed element(s) at result()`);
+			flushImpl();
+			finalised = true;
+			let total = 0;
+			for (const c of chunks) total += c.byteLength;
+			const out = new Uint8Array(total);
+			let off = 0;
+			for (const c of chunks) {
+				out.set(c, off);
+				off += c.byteLength;
+			}
+			return out;
+		}
+	};
+}
+//#endregion
+export { ACTIVEX_TYPE, ARC_APP, ARC_CONTENT_TYPES, ARC_CORE, ARC_CUSTOM, ARC_CUSTOM_UI, ARC_ROOT_RELS, ARC_SHARED_STRINGS, ARC_STYLE, ARC_THEME, ARC_WORKBOOK, ARC_WORKBOOK_RELS, C14_NS, C15_NS, C16_NS, CHARTSHAPE_TYPE, CHARTSHEET_TYPE, CHART_DRAWING_NS, CHART_NS, CHART_TYPE, COMMENTS_NS, COMMENTS_TYPE, CONTYPES_NS, COREPROPS_NS, CPROPS_FMTID, CPROPS_TYPE, CTRLPROPS_TYPE, CUSTOMUI_NS, CUSTPROPS_NS, CX_NS, DCMITYPE_NS, DCORE_NS, DCTERMS_NS, DCTERMS_PREFIX, DEFAULT_PREFIXES, DRAWING_NS, DRAWING_TYPE, EXTERNAL_LINK_NS, EXTERNAL_LINK_TYPE, IMAGE_NS, MARKUP_COMPAT_NS, PACKAGE_CHARTS, PACKAGE_CHARTSHEETS, PACKAGE_CHARTSHEETS_RELS, PACKAGE_DRAWINGS, PACKAGE_IMAGES, PACKAGE_PIVOT_CACHE, PACKAGE_PIVOT_TABLE, PACKAGE_PROPS, PACKAGE_RELS, PACKAGE_THEME, PACKAGE_WORKSHEETS, PACKAGE_WORKSHEET_RELS, PACKAGE_XL, PICTURE_NS, PKG_REL_NS, REL_NS, SHARED_STRINGS_TYPE, SHEET_DRAWING_NS, SHEET_MAIN_NS, STYLES_TYPE, THEME_TYPE, THREADED_COMMENTS_NS, VBA_TYPE, VML_NS, VTYPES_NS, WORKSHEET_TYPE, X14_NS, X15_NS, X16_NS, XLSM_TYPE, XLSX_TYPE, XLTM_TYPE, XLTX_TYPE, XML_NS, XPROPS_NS, XSI_NS, appendChild, createXmlStreamWriter, el, elNs, findChild, findChildren, iterParse, parseQName, parseXml, qname, serializeXml };
+
+//# sourceMappingURL=xml.mjs.map

package/dist/xml.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml.mjs","names":[],"sources":["../src/xml/stream-writer.ts"],"sourcesContent":["// Streaming XML emitter. Used by writers that need to compose larger documents\n// incrementally — chiefly the worksheet writer where the `<sheetData>` block is\n// emitted row-by-row to keep heap use bounded.\n//\n// Phase 1 §5: buffered output only (a chunk array materialised on `result()`).\n// Streaming via `WritableStream<Uint8Array>` is added in the phase-4 streaming\n// worksheet writer; the structural API stays the same so that change is\n// mechanical.\n//\n// The worksheet hot path emits cells through templated strings, NOT through\n// this writer's start / end / writeNode methods. Use `writeRaw` to splice those\n// in.\n\nimport { escapeXmlAttr, escapeXmlText } from '../utils/escape';\nimport { OpenXmlIoError } from '../utils/exceptions';\nimport { utf8ByteLength } from '../utils/utf8';\nimport { DEFAULT_PREFIXES, parseQName, XML_NS } from './namespaces';\nimport type { XmlNode } from './tree';\n\nexport interface XmlStreamWriterOptions {\n  /** Map of namespace URI → prefix. Merged on top of DEFAULT_PREFIXES. */\n  prefixMap?: Readonly<Record<string, string>>;\n  /** Emit `<?xml … ?>` declaration first. Defaults to true. */\n  xmlDeclaration?: boolean;\n  /** `standalone` attribute on the declaration. Defaults to 'yes'. */\n  standalone?: 'yes' | 'no' | 'omit';\n  /**\n   * Auto-flush threshold in bytes. Once the in-flight string buffer crosses\n   * this size it gets encoded into a chunk and parked. Larger values trade\n   * memory for fewer TextEncoder calls; smaller values lower peak memory at the\n   * cost of CPU.\n   */\n  flushBytes?: number;\n}\n\nexport interface XmlStreamWriter {\n  /**\n   * Open an element. Names are in Clark notation (`{ns}local`); the writer\n   * prefixes them via the configured prefix map.\n   */\n  start(name: string, attrs?: Record<string, string>): void;\n  /** Emit a text node inside the currently open element. */\n  text(s: string): void;\n  /** Emit a complete subtree. Closes any pending start tag first. */\n  writeNode(n: XmlNode): void;\n  /** Emit pre-rendered XML bytes verbatim — escape-hatch for hot paths. */\n  writeRaw(s: string): void;\n  /** Close the currently open element (matched against the start stack). */\n  end(): void;\n  /** Force any buffered bytes into the chunk store immediately. */\n  flush(): void;\n  /**\n   * Materialise everything written so far. Throws if any element is still open.\n   * Idempotent.\n   */\n  result(): Uint8Array;\n}\n\nconst DEFAULT_FLUSH_BYTES = 64 * 1024;\nconst encoder = new TextEncoder();\n\nconst buildPrefixMap = (user: Readonly<Record<string, string>> | undefined): Map<string, string> => {\n  const out = new Map<string, string>();\n  for (const [ns, prefix] of Object.entries(DEFAULT_PREFIXES)) out.set(ns, prefix);\n  // The xml prefix is reserved by the XMLNS spec for XML_NS; never override.\n  out.set(XML_NS, 'xml');\n  if (user !== undefined) {\n    for (const [ns, prefix] of Object.entries(user)) out.set(ns, prefix);\n  }\n  return out;\n};\n\nexport function createXmlStreamWriter(opts: XmlStreamWriterOptions = {}): XmlStreamWriter {\n  const { xmlDeclaration = true, standalone = 'yes', flushBytes = DEFAULT_FLUSH_BYTES } = opts;\n  const prefixOf = buildPrefixMap(opts.prefixMap);\n\n  const chunks: Uint8Array[] = [];\n  let buf = '';\n  // Running UTF-8 byte count of `buf`, maintained incrementally via `append()`.\n  // Without this the flush threshold compares UTF-16 code units against a\n  // byte budget — non-ASCII payloads then balloon past the configured limit.\n  let bufBytes = 0;\n  let openStartTag = false;\n  let finalised = false;\n  const stack: string[] = [];\n\n  const append = (s: string): void => {\n    buf += s;\n    bufBytes += utf8ByteLength(s);\n  };\n\n  const elementName = (name: string): string => {\n    const { ns, local } = parseQName(name);\n    if (ns === '') return local;\n    const prefix = prefixOf.get(ns);\n    if (prefix === undefined || prefix === '') return local;\n    return `${prefix}:${local}`;\n  };\n  const attributeName = (name: string): string => {\n    const { ns, local } = parseQName(name);\n    if (ns === '') return local;\n    const prefix = prefixOf.get(ns);\n    if (prefix === undefined || prefix === '') return local;\n    return `${prefix}:${local}`;\n  };\n\n  const flushImpl = (): void => {\n    if (buf.length === 0) return;\n    chunks.push(encoder.encode(buf));\n    buf = '';\n    bufBytes = 0;\n  };\n\n  const maybeFlush = (): void => {\n    if (bufBytes >= flushBytes) flushImpl();\n  };\n\n  const closeStartTagIfOpen = (): void => {\n    if (!openStartTag) return;\n    append('>');\n    openStartTag = false;\n  };\n\n  if (xmlDeclaration) {\n    append('<?xml version=\"1.0\" encoding=\"UTF-8\"');\n    if (standalone !== 'omit') append(` standalone=\"${standalone}\"`);\n    append('?>\\n');\n  }\n\n  // ---- writeNode internals\n  // ---------------------------------------------------\n\n  const emitNodeInline = (n: XmlNode): void => {\n    const tag = elementName(n.name);\n    append(`<${tag}`);\n    for (const [name, value] of Object.entries(n.attrs)) {\n      append(` ${attributeName(name)}=\"${escapeXmlAttr(value)}\"`);\n    }\n    const text = n.text;\n    const hasText = text !== undefined && text !== '';\n    const hasChildren = n.children.length > 0;\n    if (!hasText && !hasChildren) {\n      append('/>');\n      return;\n    }\n    append('>');\n    if (hasText) append(escapeXmlText(text));\n    for (const c of n.children) emitNodeInline(c);\n    append(`</${tag}>`);\n  };\n\n  // ---- public surface\n  // --------------------------------------------------------\n\n  return {\n    start(name, attrs) {\n      if (finalised) throw new OpenXmlIoError('XmlStreamWriter: start() after result()');\n      closeStartTagIfOpen();\n      const tag = elementName(name);\n      append(`<${tag}`);\n      if (attrs !== undefined) {\n        for (const [k, v] of Object.entries(attrs)) {\n          append(` ${attributeName(k)}=\"${escapeXmlAttr(v)}\"`);\n        }\n      }\n      stack.push(tag);\n      openStartTag = true;\n      maybeFlush();\n    },\n    text(s) {\n      if (finalised) throw new OpenXmlIoError('XmlStreamWriter: text() after result()');\n      closeStartTagIfOpen();\n      append(escapeXmlText(s));\n      maybeFlush();\n    },\n    writeNode(n) {\n      if (finalised) throw new OpenXmlIoError('XmlStreamWriter: writeNode() after result()');\n      closeStartTagIfOpen();\n      emitNodeInline(n);\n      maybeFlush();\n    },\n    writeRaw(s) {\n      if (finalised) throw new OpenXmlIoError('XmlStreamWriter: writeRaw() after result()');\n      closeStartTagIfOpen();\n      append(s);\n      maybeFlush();\n    },\n    end() {\n      if (finalised) throw new OpenXmlIoError('XmlStreamWriter: end() after result()');\n      const tag = stack.pop();\n      if (tag === undefined) throw new OpenXmlIoError('XmlStreamWriter: end() with no open element');\n      if (openStartTag) {\n        append('/>');\n        openStartTag = false;\n      } else {\n        append(`</${tag}>`);\n      }\n      maybeFlush();\n    },\n    flush() {\n      flushImpl();\n    },\n    result(): Uint8Array {\n      if (stack.length > 0) {\n        throw new OpenXmlIoError(`XmlStreamWriter: ${stack.length} unclosed element(s) at result()`);\n      }\n      flushImpl();\n      finalised = true;\n      let total = 0;\n      for (const c of chunks) total += c.byteLength;\n      const out = new Uint8Array(total);\n      let off = 0;\n      for (const c of chunks) {\n        out.set(c, off);\n        off += c.byteLength;\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/zip/decompression-guard.d.ts

@@ -0,0 +1,70 @@
+import { OpenXmlDecompressionBombError } from '../utils/exceptions';
+/** Per-archive limits enforced during {@link openZip}. */
+export interface DecompressionLimits {
+    /**
+     * Maximum decompressed bytes for a single archive entry. Default 512 MiB.
+     * Legitimate xlsx sheets stay well below this even with millions of cells.
+     */
+    maxEntryUncompressedBytes?: number;
+    /**
+     * Maximum decompressed bytes summed across every entry the caller reads.
+     * Default 1 GiB.
+     */
+    maxTotalUncompressedBytes?: number;
+    /**
+     * Maximum allowed `uncompressed / compressed` ratio for a single entry.
+     * Default 1000. xml usually compresses 5–20×, but highly repetitive payloads
+     * (long runs of zeros, sparse worksheets) can hit several hundred ×
+     * legitimately. Classic zip-bombs run 10 000× and up, so a 1000× ceiling
+     * still catches them while admitting realistic content. The implementation
+     * treats compressed sizes below 64 B as exempt — there's no amplification
+     * budget worth policing on such small entries, and the absolute per-entry /
+     * archive limits already cover them.
+     */
+    maxCompressionRatio?: number;
+}
+/** Resolved limits with no `undefined` fields. */
+export interface ResolvedDecompressionLimits {
+    readonly maxEntryUncompressedBytes: number;
+    readonly maxTotalUncompressedBytes: number;
+    readonly maxCompressionRatio: number;
+}
+/** Default safeguards applied when the caller doesn't override them. */
+export declare const DEFAULT_DECOMPRESSION_LIMITS: ResolvedDecompressionLimits;
+/**
+ * `DecompressionLimits` plus the sentinel `false` to disable the guard.
+ * Anything else is treated as "use defaults".
+ */
+export type DecompressionLimitsInput = DecompressionLimits | false | undefined;
+/** Returns null when the guard is disabled. */
+export declare function resolveDecompressionLimits(input: DecompressionLimitsInput): ResolvedDecompressionLimits | null;
+/**
+ * Per-archive byte accounting shared across every read of an archive opened
+ * with the given limits. Tracks total inflated bytes so the cap is enforced
+ * even when individual entries stay below the per-entry ceiling.
+ */
+export interface DecompressionBudget {
+    readonly limits: ResolvedDecompressionLimits;
+    totalInflated: number;
+}
+export declare function createBudget(limits: ResolvedDecompressionLimits): DecompressionBudget;
+/**
+ * Per-entry inflate cap, accounting for both the absolute per-entry bound and
+ * the ratio-based bound. Returns the smaller of the two — whichever fires
+ * first stops the inflate loop.
+ */
+export declare function entryInflateCap(budget: DecompressionBudget, compressedSize: number): number;
+/** Throw if the declared central-directory totals already exceed the limits. */
+export declare function checkDeclaredTotals(budget: DecompressionBudget, declaredEntries: ReadonlyArray<{
+    path: string;
+    compSize: number;
+    uncompSize: number;
+}>): void;
+/**
+ * Record `bytes` against the global budget. Throws when the running total
+ * crosses {@link ResolvedDecompressionLimits.maxTotalUncompressedBytes}. Called
+ * from both sync and streaming inflate code paths.
+ */
+export declare function recordInflated(budget: DecompressionBudget, path: string, bytes: number): void;
+/** Build the message thrown when a single entry exceeds its cap mid-inflate. */
+export declare function entryOverflowError(path: string, cap: number): OpenXmlDecompressionBombError;

package/dist/zip/index.d.ts

@@ -0,0 +1,6 @@
+export type { DecompressionLimits, ResolvedDecompressionLimits, } from './decompression-guard';
+export { DEFAULT_DECOMPRESSION_LIMITS } from './decompression-guard';
+export type { OpenZipOptions, ZipArchive } from './reader';
+export { openZip } from './reader';
+export type { StreamingEntryWriter, ZipWriter } from './writer';
+export { createZipWriter } from './writer';

package/dist/zip/random-access-reader.d.ts

@@ -0,0 +1,16 @@
+import { type DecompressionLimitsInput } from './decompression-guard';
+import type { ZipArchive } from './reader';
+/**
+ * Open a buffered xlsx archive in random-access mode. The archive bytes stay
+ * resident; entries inflate on demand inside `read(path)`.
+ *
+ * Falls back to `fflate.unzipSync` when the central directory uses ZIP64
+ * sentinel values (entry count == 0xFFFF or any size field == 0xFFFFFFFF) so
+ * external ZIP64 archives still load. xlsx files in the wild fit comfortably in
+ * ZIP32; the fallback exists for safety.
+ *
+ * `decompressionLimits` opts the archive into the zip-bomb safeguards
+ * documented on {@link DecompressionLimits}; pass `false` to disable. Defaults
+ * fit any legitimate xlsx.
+ */
+export declare function openRandomAccessArchive(bytes: Uint8Array, decompressionLimits?: DecompressionLimitsInput): ZipArchive;

package/dist/zip/reader.d.ts

@@ -0,0 +1,45 @@
+import type { XlsxSource } from '../io/source';
+import type { DecompressionLimits } from './decompression-guard';
+export interface ZipArchive {
+    /** Sorted list of all entry paths in the archive. */
+    list(): string[];
+    /** Synchronous read; throws OpenXmlIoError when the path is unknown. */
+    read(path: string): Uint8Array;
+    /** Promise variant for symmetry with the future streaming reader. */
+    readAsync(path: string): Promise<Uint8Array>;
+    /**
+     * Streaming read: returns the entry's inflated bytes as a Web
+     * `ReadableStream<Uint8Array>` chunk-by-chunk. Lets callers (the streaming
+     * worksheet iterator, in particular) push the inflated payload through a SAX
+     * parser without first materialising it in full — peak memory for a sheet
+     * walk drops to the inflate window + SAX state instead of the entire
+     * uncompressed worksheet body. Throws OpenXmlIoError when the path is
+     * unknown.
+     */
+    readStream(path: string): ReadableStream<Uint8Array>;
+    /** Whether the archive holds an entry at the given path. */
+    has(path: string): boolean;
+    /** Release the in-memory entry table. Subsequent reads throw. */
+    close(): void;
+}
+/** Options for {@link openZip}. */
+export interface OpenZipOptions {
+    /**
+     * Decompression-bomb safeguards applied while inflating archive entries. The
+     * default limits admit any legitimate xlsx and reject pathological archives
+     * (extreme compression ratios, gigabyte-scale entries). Pass `false` to
+     * disable the guard entirely — only safe when the source is fully trusted.
+     * See {@link DecompressionLimits} for the individual knobs.
+     */
+    decompressionLimits?: DecompressionLimits | false;
+}
+/**
+ * Open a zip archive from any {@link XlsxSource}. The source is fully
+ * materialised in memory, the central directory is parsed once, and each
+ * entry is inflated on demand by {@link openRandomAccessArchive} — peak memory
+ * stays at compressed-archive size plus per-entry inflate scratch rather than
+ * holding every uncompressed entry resident. The fflate `unzipSync` fallback
+ * is preserved internally for ZIP64 / non-standard archives the random-access
+ * reader rejects.
+ */
+export declare function openZip(source: XlsxSource, opts?: OpenZipOptions): Promise<ZipArchive>;

package/dist/zip/writer.d.ts

@@ -0,0 +1,65 @@
+import type { XlsxSink } from '../io/sink';
+export interface ZipWriter {
+    /**
+     * Stage an entry. Bytes are pushed through fflate's `ZipDeflate` /
+     * `ZipPassThrough` stream synchronously, so the deflated chunks land on the
+     * sink as the call runs (no per-entry buffering — see the streaming-behaviour
+     * test in `tests/phase-1/zip/writer.test.ts`). Streams (`ReadableStream`)
+     * are not accepted today; pass an already-materialised entry, or use
+     * {@link addStreamingEntry} for chunked writes.
+     *
+     * `compress` defaults to `true`. Pass `false` for already-compressed payloads
+     * (PNG/JPEG/zip-as-binary content like vbaProject.bin) so we don't pay
+     * deflate costs for no gain.
+     */
+    addEntry(path: string, bytes: Uint8Array | ReadableStream<Uint8Array>, opts?: {
+        compress?: boolean;
+    }): Promise<void>;
+    /**
+     * Open a streaming entry. Returns a writer the caller can `write()` chunks to
+     * and `end()` to seal the entry. Each chunk pushes through the same fflate
+     * `ZipDeflate` / `ZipPassThrough` machinery as `addEntry`, so peak memory
+     * stays at one chunk + deflate scratch even for multi-GB worksheets.
+     *
+     * Sequencing: only one streaming entry may be open at a time — `addEntry` and
+     * a second `addStreamingEntry` both throw until the current entry's `end()`
+     * resolves.
+     */
+    addStreamingEntry(path: string, opts?: {
+        compress?: boolean;
+    }): StreamingEntryWriter;
+    /**
+     * Build the central directory and flush all bytes through the sink.
+     * Idempotent; subsequent calls resolve to the same payload.
+     */
+    finalize(): Promise<Uint8Array>;
+    /**
+     * Release the sink and underlying writer without producing a valid archive.
+     * Use this from a surrounding catch block when serialization fails part-way
+     * through — without it, streaming sinks (`toFile` / `toWritable`) keep their
+     * file descriptors / writables open and the half-written xlsx looks valid on
+     * disk. Idempotent; safe to call after `finalize()`.
+     */
+    abort(cause?: unknown): void;
+}
+/** Writer handle for a single streaming entry. */
+export interface StreamingEntryWriter {
+    /** Push a chunk of bytes (already-encoded). Throws after `end()`. */
+    write(chunk: Uint8Array): void;
+    /** Seal the entry. Subsequent `write()` throws. Idempotent. */
+    end(): Promise<void>;
+}
+/**
+ * ZIP writer backed by fflate's streaming `Zip` class. Entries are pushed
+ * through `ZipDeflate` / `ZipPassThrough` streams as they arrive, so peak
+ * memory stays at the size of the in-flight entry plus the output buffer rather
+ * than the full archive.
+ *
+ * The sink contract is `toBytes()`, but that name is historical: the sink is
+ * driven by a chunked `write(chunk)` API that fans bytes out as they arrive.
+ * The buffered Node/browser sinks (`toBuffer`, `toBlob`, `toArrayBuffer`)
+ * concatenate the chunks for a single-shot result; streaming sinks
+ * (`toFile`, `toWritable`) forward each chunk to disk / the wrapped writable
+ * without ever holding the full archive resident. Either kind plugs in here.
+ */
+export declare function createZipWriter(sink: XlsxSink): ZipWriter;

package/dist/zip/zip64-patch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Splice ZIP64 EOCD record + locator into fflate's final chunk and
+ * patch the trailing EOCD entry-count fields with the 0xFFFF sentinel.
+ *
+ * `finalChunk` must be the [CD | EOCD] block fflate emits as its last
+ * ondata callback (everything before it is per-entry LFH/data/DD that
+ * we leave untouched). Returns a new chunk; the input is not mutated.
+ *
+ * Assumes per-entry sizes and central-directory offset fit in 32 bits;
+ * throws if not (xlsx archives never approach those limits).
+ */
+export declare function applyZip64EntryCountPatch(finalChunk: Uint8Array, totalEntries: number): Uint8Array;

package/dist/zip.mjs

@@ -0,0 +1,3 @@
+import { n as DEFAULT_DECOMPRESSION_LIMITS, t as openZip } from "./reader-D1fNW9k1.mjs";
+import { t as createZipWriter } from "./writer-DspzfkNA.mjs";
+export { DEFAULT_DECOMPRESSION_LIMITS, createZipWriter, openZip };