@office-open/core 0.14.0 → 0.14.1

package/dist/index.d.mts

@@ -128,7 +128,9 @@ declare class ParsedArchive {
   private readonly parts;
   private readonly modified;
   private readonly wrapperCache;
+  private readonly order;
   constructor(data: Uint8Array);
+  static open(data: Uint8Array | Blob): Promise<ParsedArchive>;
   private inflate;
   get(path: string, parseOptions?: ParseOptions): Element | undefined;
   set(path: string, element: Element): void;

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/opc/media.ts","../src/opc/embeddings.ts","../src/opc/variant-types.ts","../src/opc/app-properties.ts","../src/opc/custom-properties.ts","../src/opc/encryption.ts","../src/util/base64.ts","../src/opc/parser.ts","../src/opc/namespaces.ts","../src/opc/part-registry.ts","../src/opc/opc-consistency.ts","../src/opc/content-type-overrides.ts","../src/opc/content-types-input.ts","../src/opc/passthrough.ts","../src/table/types.ts","../src/picture/types.ts","../src/connector/types.ts","../src/group/types.ts"],"mappings":";;;;;;;;;;;;;;UAyBiB;EACf;EACA,MAAM;EACN;;cAeW,MAAM,UAAU;mBACV;mBAEA;mBAEA;UACT;UAGA;EAYD,SACL,MAAM,YACN,cACA,QAAQ,qBAAqB,GAC7B,oBACC;UAuCK;UAaA;UAoBA;MASG,SAAS;;;;UC3IL;EAEf;EAEA,MAAM;EAEN;EAOA;;cAQW;UACH;UACA;UAEA;EAGD;EAeA,aACL,MAAM,YACN,wBACA,iBACA,mBAAmB,oCAClB;MAsBQ,SAAS;UAKZ;;;;KC9DE,2CAA2C;iBA+CvC,sBAAsB,OAAO,cAAc;iBAkB3C,kBAAkB,IAAI,UAAU;iBAuBhC,sBAAsB;iBAgBtB,YAAY,IAAI,sBAAsB;;;UCpGrC;EAEf;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA;EAMA,SAAS;EAET;EAEA;EAEA;EAEA;EAEA;EAEA;EAEA,eAAe;EAEf;EAMA;;UAIe;EAEf;EAEA;;KAIU,qBAAqB;cAEpB,mBAAmB,iBAAiB;;;UC9EhC;EAEf;EAEA,OAAO;EAMP;;UAIe;EACf,YAAY;;cAGD,sBAAsB,iBAAiB;;;UCpBnC;EAEf,MAAM;;iBAIQ,qBAAqB,MAAM;iBAQ3B,yBAAyB,UAAU,YACjD;EAAQ,YAAY;GACpB,MAAM,GACN,mBACC,aAAa;iBAOA,yBAAyB;EACvC,YAAY;IACV,eAAe;iBAmBH,yBACd;EAAQ,YAAY;GACpB;;;iBCvDc,aAAa,gBAAgB;iBAkB7B,aAAa,OAAO;;;cCKvB;mBACM;mBAEA;mBAEA;mBACA;mBACA;EAEE,YAAA,MAAM;UAkBjB;EAyBD,IAAI,cAAc,eAAe,eAAe;EAwBhD,IAAI,cAAc,SAAS;EAU3B,OAAO,eAAe;EAKtB,OAAO,cAAc,MAAM;EAM3B,OAAO;EAMP,IAAI;EAKJ,KAAK;EAeL,QAAQ;;iBAqBD,aAAa,MAAM,aAAa;;;cChCnC,0BAA0B,SAAS;;;KCzHpC;WACG;;WACA;WAA8B;;WAC9B;WAA2B;;UAEzB;EAKf;EAMA;EACA,UAAU;;UAGK;EACf;EACA,gBAAgB;EAMhB;;cAKW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoLA,iBAAiB,OAAO,+BAA+B;;;KClkBxD;KAEA;UAEK;EACf,MAAM;EACN,UAAU;EAEV;EACA;;iBA0Ic,uBACd,SAAS,6BACT,UAAU,sBACT;iBAmIa,mBAAmB,iBAAiB;EAClD;EACA;;;;UC/Re;EACf;EACA;;iBAcc,0BACd,UAAU,qBACV,OAAO,wCACN;;;UCjBc;EACf;EACA;;UAGe;EACf;EACA;;UAOe;EACf,UAAU;EACV,WAAW;;cAKA,kBAAkB,iBAAiB;KAiDpC,2BAA2B;iBAgBvB,qBAAqB,UAAU,sBAAsB;UAgBpD;EAGf,SAAS;EAET,mBAAmB,SAAS;EAE5B,eAAe;EAMf,YAAY;IAAgB;IAAc;;EAU1C,SAAS;EAQT,gBAAgB;;iBAkBF,mBACd,WAAW,kBACX,SAAS,4BACR;cAyJU,2BAA2B;;;UC5SvB;EACf;EACA,MAAM;EAON;;UAGe;EAKf;EACA;EAEA;EAEA;EAEA;;UAGe;EACf,OAAO;EACP,eAAe;;iBAuBD,wBACd,SAAS,eACT,cAAc,mBACb;iBA+Ga,4BACd,OAAO,UACP,mCAAmC;;;UClLpB;EAEf;EAEA;EAEA;;UAKe,oBAAoB,QAAQ;EAC3C,OAAO;;UAKQ,iBAAiB,OAAO;EACvC,MAAM;EAMN,yBAAyB;EAEzB;EACA;EACA;EACA;EACA;EACA;;;;UCnCe,2BAA2B;EAM1C,OAAO;EAOP;EAEA;;;;UCXe,6BAA6B;EAE5C,UAAU;EAEV,kBAAkB;EAElB,gBAAgB;;iBAQF,kBACd,MAAM,mCACL,QAAQ;;;UClBM,yBAAyB;EAOxC,UAAU;;iBAQI,cAAc,MAAM,+BAA+B,QAAQ"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/opc/media.ts","../src/opc/embeddings.ts","../src/opc/variant-types.ts","../src/opc/app-properties.ts","../src/opc/custom-properties.ts","../src/opc/encryption.ts","../src/util/base64.ts","../src/opc/parser.ts","../src/opc/namespaces.ts","../src/opc/part-registry.ts","../src/opc/opc-consistency.ts","../src/opc/content-type-overrides.ts","../src/opc/content-types-input.ts","../src/opc/passthrough.ts","../src/table/types.ts","../src/picture/types.ts","../src/connector/types.ts","../src/group/types.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { A as ZIP_STORED_LEVEL, B as OoxmlMimeType, C as replaceVideoPlaceholders, D as addBinaryFile, E as randomBytes, F as strFromU8, H as inflateZipEntry, I as unzipSync, L as zipAndConvert, M as createPacker, N as createZipStream, O as compileMapping, P as levelForMediaName, R as zipSync, S as replaceSmartArtPlaceholders, T as hashPasswordAgile, U as nativeCrc32, V as convertOutput, W as readCentralDirectory, _ as replaceMediaPlaceholders, a as getAudioRefs, b as replaceOlePlaceholders, c as getReferencedMedia, d as replaceAllPlaceholders, f as replaceAudioPlaceholders, g as replaceImagePlaceholders, h as replaceImageLinkPlaceholders, i as formatId, j as ZipStreamWriter, k as ZIP_DEFLATE_LEVEL, l as getVideoRefs, m as replaceHyperlinkPlaceholders, n as collectPlaceholderKeys, o as getMediaRefs, p as replaceChartPlaceholders, r as findAndReplaceImagePlaceholders, s as getOleRefs, t as addSmartArtRelationships, u as hasPlaceholders, v as replaceNumberingPlaceholders, w as derivePasswordHash, x as replacePlaceholders, y as replaceOleLinkPlaceholders, z as zipSyncAndConvert } from "./util-B3K-9ODR.mjs";
+import { A as ZIP_STORED_LEVEL, B as OoxmlMimeType, C as replaceVideoPlaceholders, D as addBinaryFile, E as randomBytes, F as strFromU8, G as readCentralDirectory, H as inflateRawWindow, I as unzipSync, K as readCentralDirectoryAsync, L as zipAndConvert, M as createPacker, N as createZipStream, O as compileMapping, P as levelForMediaName, R as zipSync, S as replaceSmartArtPlaceholders, T as hashPasswordAgile, U as inflateZipEntry, V as convertOutput, W as nativeCrc32, _ as replaceMediaPlaceholders, a as getAudioRefs, b as replaceOlePlaceholders, c as getReferencedMedia, d as replaceAllPlaceholders, f as replaceAudioPlaceholders, g as replaceImagePlaceholders, h as replaceImageLinkPlaceholders, i as formatId, j as ZipStreamWriter, k as ZIP_DEFLATE_LEVEL, l as getVideoRefs, m as replaceHyperlinkPlaceholders, n as collectPlaceholderKeys, o as getMediaRefs, p as replaceChartPlaceholders, r as findAndReplaceImagePlaceholders, s as getOleRefs, t as addSmartArtRelationships, u as hasPlaceholders, v as replaceNumberingPlaceholders, w as derivePasswordHash, x as replacePlaceholders, y as replaceOleLinkPlaceholders, z as zipSyncAndConvert } from "./util-D61LJ_Wz.mjs";
 import { _ as toJson, a as appendOverride, b as buildCorePropertiesXmlString, c as createTraverser, d as TokenNotFoundError, f as createSplitInject, g as patchSpaceAttribute, h as nextNumericId, i as appendContentType, l as createRunRenderer, m as getFirstLevelElements, n as appendRelationship, o as removeOverride, p as createTextElementContents, r as getNextRelationshipIndex, s as createReplacer, t as applyCorePropertiesOverride, u as createTokenReplacer, v as DOCX_NS, x as parseCorePropsElement, y as PPTX_NS } from "./patch-AkQY17CD.mjs";
 import { $ as xsdErrorValueType, $t as shortHexNumber, A as parsePercent, At as xsdTextVerticalType, B as xsdAxisCrosses, C as convertUniversalMeasureToInch, Ct as xsdStrikeStyle, D as emitPercent, Dt as xsdTextBuild, E as emitAngle, Et as xsdTextAnchor, F as xsdAnimClass, Ft as isBase64DataURL, G as xsdChartBuild, Gt as hexColorValue, H as xsdAxisOrientation, Ht as decimalNumber, I as xsdAnimLevel, It as toUint8Array, J as xsdConsolidateFunction, Jt as measurementOrPercentValue, K as xsdComments, Kt as hpsMeasureValue, L as xsdAnimValueType, Lt as toUint8ArrayAsync, M as parseUniversalMeasure, Mt as xsdTrendlineType, N as invertMap, Nt as xsdUnderlineStyle, O as mapOptional, Ot as xsdTextCaps, P as xsdAnimCalcMode, Pt as xsdVerticalMergeRev, Q as xsdEffectContainer, Qt as positiveUniversalMeasureValue, R as xsdAnimationDgmBuild, Rt as decodeBase64, S as convertUniversalMeasureToEmu, St as xsdSplitType, T as convertUniversalMeasureToTwip, Tt as xsdTextAlign, U as xsdAxisPosition, Ut as eighthPointMeasureValue, V as xsdAxisLabelAlignment, Vt as dateTimeValue, W as xsdBlendMode, Wt as hexBinary, X as xsdDiagramBuild, Xt as percentageValue, Y as xsdDataLabelPosition, Yt as parseOnOff, Z as xsdDiagramDirection, Zt as pointMeasureValue, _ as convertToEmu, _t as xsdRectAlignment, a as uniqueNumericIdCreator, an as universalMeasureValue, at as xsdLegendPosition, b as convertToTwip, bt as xsdSizeRepresents, c as convertEmuToPixels, ct as xsdLineEndSize, d as convertInchesToEmu, dt as xsdOrient, en as signedHpsMeasureValue, et as xsdFontAlignment, f as convertInchesToTwip, ft as xsdPathFillMode, g as convertPointsToTwip, gt as xsdPresetShadow, h as convertPointsToEmu, ht as xsdPlaceholderType, i as uniqueId, in as uCharHexNumber, it as xsdJcAlignment, j as parsePercentAttr, jt as xsdTotalsRowFunction, k as parseAngle, kt as xsdTextTabAlignment, l as convertEmuToPoints, lt as xsdMaterialType, m as convertPixelsToEmu, mt as xsdPenAlignment, n as imageTypeFromPath, nn as stripColorHashPrefix, nt as xsdHueDirection, o as uniqueUuid, on as unsignedDecimalNumber, ot as xsdLightRigDirection, p as convertMillimetersToTwip, pt as xsdPattern, q as xsdCompoundLine, qt as longHexNumber, r as hashedId, rn as twipsMeasureValue, rt as xsdIterateType, s as convertEmuToInches, st as xsdLineCap, t as extUriMatches, tn as signedTwipsMeasureValue, tt as xsdHierBranch, u as convertEmuToTwip, ut as xsdMathStyle, v as convertToInch, vt as xsdResizeHandles, w as convertUniversalMeasureToPt, wt as xsdTableWidthType, x as convertTwipToEmu, xt as xsdSlideLayoutType, y as convertToPt, yt as xsdShadingPattern, z as xsdAxisCrossBetween, zt as encodeBase64 } from "./ext-uri-5jTDczSP.mjs";
 import { C as stringifyDataModelOptions, D as COLOR_CATEGORIES, E as stringifyConnection, O as LAYOUT_CATEGORIES, S as stringifyDataModel, T as stringifyTransPoint, _ as parseLayoutDefinition, a as getColorXml, b as withDiagramNamespaces, c as parseStyleDefinition, d as styleDefDesc, f as colorsDefDesc, g as layoutDefDesc, h as stringifyColorDefinitionPart, i as DEFAULT_DRAWING_XML, k as STYLE_CATEGORIES, l as stringifyStyleDefinition, m as stringifyColorDefinition, n as SmartArtCollection, o as getLayoutXml, p as parseColorDefinition, r as definitionId, s as getStyleXml, t as createDataModel, u as stringifyStyleDefinitionPart, v as stringifyLayoutDefinition, w as stringifyPoint, x as parseDataModelOptions, y as stringifyLayoutDefinitionPart } from "./smartart-CrVPot34.mjs";
@@ -770,6 +770,21 @@ function assertEncryptedExclusive(file, hasContent) {
 	if (file.encrypted && hasContent) throw new Error("Encrypted passthrough carries no editable content — clear the content fields or drop `encrypted`.");
 }
 //#endregion
+//#region src/opc/byte-source.ts
+/** Blob/File source — every read is a `slice()` window, the package never materializes. */
+function blobSource(blob) {
+	return {
+		byteLength: blob.size,
+		async read(offset, length) {
+			const buf = await blob.slice(offset, offset + length).arrayBuffer();
+			return new Uint8Array(buf);
+		},
+		stream(offset, length) {
+			return blob.slice(offset, offset + length).stream();
+		}
+	};
+}
+//#endregion
 //#region src/opc/gfxdata.ts
 /**
 * Byte-level strip of oversized `o:gfxdata` attribute values from XML parts.
@@ -842,6 +857,84 @@ function findNeedle(xml, from) {
 	}
 	return -1;
 }
+const QUOTE = 34;
+/** Chunks can split the needle; this many tail bytes are held back between chunks. */
+const NEEDLE_LEN = 11;
+function concatChunks(chunks) {
+	let total = 0;
+	for (const c of chunks) total += c.length;
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const c of chunks) {
+		out.set(c, offset);
+		offset += c.length;
+	}
+	return out;
+}
+/**
+* Transform stream removing oversized `o:gfxdata="…"` attribute values on the
+* fly. Feed it inflated XML chunks; the readable side yields the XML with
+* those attributes already gone.
+*/
+function gfxdataStripStream(threshold = GFXDATA_STRIP_THRESHOLD) {
+	let carry = /* @__PURE__ */ new Uint8Array(0);
+	let mode = "scan";
+	let collected = [];
+	let valueLen = 0;
+	return new TransformStream({
+		transform(chunk, controller) {
+			const buf = carry.length > 0 ? concatChunks([carry, chunk]) : chunk;
+			carry = /* @__PURE__ */ new Uint8Array(0);
+			let i = 0;
+			const out = [];
+			const emitPending = () => {
+				if (out.length === 1) controller.enqueue(out[0]);
+				else if (out.length > 1) controller.enqueue(concatChunks(out));
+			};
+			while (true) if (mode === "scan") {
+				if (i >= buf.length) break;
+				const hit = findNeedle(buf, i);
+				if (hit === -1) {
+					const keepFrom = Math.max(i, buf.length - 10);
+					if (keepFrom > i) out.push(buf.subarray(i, keepFrom));
+					carry = buf.slice(keepFrom);
+					break;
+				}
+				if (hit > i) out.push(buf.subarray(i, hit));
+				collected = Array.from(NEEDLE, (ch) => ch.charCodeAt(0));
+				valueLen = 0;
+				mode = "collecting";
+				i = hit + NEEDLE_LEN;
+			} else {
+				let q = i;
+				while (q < buf.length && buf[q] !== QUOTE) {
+					if (mode === "collecting") {
+						collected.push(buf[q]);
+						valueLen++;
+						if (valueLen > threshold) {
+							mode = "discarding";
+							collected = [];
+						}
+					}
+					q++;
+				}
+				if (q === buf.length) break;
+				if (mode === "collecting") out.push(new Uint8Array(collected));
+				out.push(buf.subarray(q, q + 1));
+				collected = [];
+				mode = "scan";
+				i = q + 1;
+			}
+			emitPending();
+		},
+		flush(controller) {
+			if (mode === "collecting") controller.enqueue(new Uint8Array(collected));
+			else if (mode === "scan" && carry.length > 0) controller.enqueue(carry);
+			carry = /* @__PURE__ */ new Uint8Array(0);
+			collected = [];
+		}
+	});
+}
 //#endregion
 //#region src/opc/namespaces.ts
 /**
@@ -1031,6 +1124,43 @@ const OOXML_CANONICAL_PREFIXES = {
 	[`${SCHEMAS_MS}/office/spreadsheetml/2016/revision6`]: "xr6",
 	[`${SCHEMAS_MS}/office/spreadsheetml/2016/revision10`]: "xr10"
 };
+/**
+* Inflate a compressed zip entry from `source`, streaming when the entry is
+* an oversized XML part (the gfxdata-stripping transform rides along) and
+* reading a plain window otherwise. STORE entries skip decompression. No
+* CRC-32 is verified on the streaming path — the JS table costs more than
+* the inflate itself at these sizes, and the fflate fallback parity is
+* check-free by contract. XML parts get oversized `o:gfxdata` values
+* stripped on both paths, matching the bytes-backed archive behavior.
+*/
+async function inflateEntryFrom(source, entry) {
+	const xml = entry.name.endsWith(".xml");
+	const raw = await source.read(entry.dataStart, entry.compSize);
+	if (entry.method === 0) return xml ? stripOversizedGfxdata(raw) : raw;
+	if (xml && entry.uncompSize > 33554432 && typeof DecompressionStream !== "undefined") return inflateRawStreaming(source, entry);
+	const data = inflateRawWindow(raw, entry);
+	return xml ? stripOversizedGfxdata(data) : data;
+}
+/** Stream `slice → DecompressionStream → gfxdata strip` and join the output. */
+async function inflateRawStreaming(source, entry) {
+	const decoded = source.stream(entry.dataStart, entry.compSize).pipeThrough(new DecompressionStream("deflate-raw")).pipeThrough(gfxdataStripStream());
+	const chunks = [];
+	let total = 0;
+	const reader = decoded.getReader();
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+		total += value.length;
+	}
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return out;
+}
 //#endregion
 //#region src/opc/parser.ts
 const XML_PARSE_OPTIONS = {
@@ -1051,7 +1181,7 @@ const XML_PARSE_OPTIONS = {
 * Provides unstorage-style API (get/set/getRaw/setRaw/remove/has/keys)
 * for reading and modifying individual parts, then serializing back to a ZIP buffer.
 */
-var ParsedArchive = class {
+var ParsedArchive = class ParsedArchive {
 	source;
 	/** Compressed entries not yet inflated (empty on the eager fallback path). */
 	index;
@@ -1059,6 +1189,13 @@ var ParsedArchive = class {
 	parts = /* @__PURE__ */ new Map();
 	modified = /* @__PURE__ */ new Map();
 	wrapperCache = /* @__PURE__ */ new Map();
+	/**
+	* Central-directory order of every entry. keys() is ordered by this so a
+	* bytes-backed archive (entries migrate index→parts as they are read) and
+	* a Blob-backed one (hydrated wholesale) list parts identically — callers
+	* compare parsed documents, and part order leaks into them.
+	*/
+	order;
 	constructor(data) {
 		this.source = data;
 		let entries;
@@ -1068,19 +1205,49 @@ var ParsedArchive = class {
 			const eager = unzipSync$1(data);
 			for (const [name, bytes] of Object.entries(eager)) this.parts.set(name, bytes);
 			this.index = /* @__PURE__ */ new Map();
+			this.order = Object.keys(eager);
 			return;
 		}
 		this.index = new Map(entries.map((e) => [e.name, e]));
+		this.order = entries.map((e) => e.name);
+	}
+	/**
+	* Open an archive from bytes or a `Blob`/`File`. Bytes take the synchronous
+	* constructor path; a Blob is read through {@link blobSource} random-access
+	* windows — the package never materializes as one contiguous buffer — and
+	* every entry is decompressed up front (oversized XML through the streaming
+	* pipeline), so the returned archive serves the same synchronous
+	* `get`/`getRaw` API as a bytes-backed one.
+	*/
+	static async open(data) {
+		if (!(data instanceof Blob)) return new ParsedArchive(data);
+		const source = blobSource(data);
+		let entries;
+		try {
+			entries = await readCentralDirectoryAsync(source);
+		} catch {
+			return new ParsedArchive(await toUint8ArrayAsync(data));
+		}
+		const archive = Object.create(ParsedArchive.prototype);
+		archive.source = source;
+		archive.index = new Map(entries.map((e) => [e.name, e]));
+		archive.parts = /* @__PURE__ */ new Map();
+		archive.modified = /* @__PURE__ */ new Map();
+		archive.wrapperCache = /* @__PURE__ */ new Map();
+		archive.order = entries.map((e) => e.name);
+		await hydrateArchive(archive);
+		return archive;
 	}
 	/** Inflate and cache the compressed entry for `path`, if still compressed. */
 	inflate(path) {
 		const entry = this.index.get(path);
 		if (entry === void 0) return void 0;
+		const bytes = this.source;
 		let data;
 		try {
-			data = inflateZipEntry(this.source, entry);
+			data = inflateZipEntry(bytes, entry);
 		} catch {
-			const raw = this.source.subarray(entry.dataStart, entry.dataStart + entry.compSize);
+			const raw = bytes.subarray(entry.dataStart, entry.dataStart + entry.compSize);
 			data = entry.method === 0 ? raw.slice() : inflateSync(raw);
 		}
 		if (path.endsWith(".xml")) data = stripOversizedGfxdata(data);
@@ -1147,13 +1314,16 @@ var ParsedArchive = class {
 	has(path) {
 		return this.modified.has(path) || this.parts.has(path) || this.index.has(path);
 	}
-	/** List all paths matching an optional prefix. */
+	/** List all paths matching an optional prefix, in central-directory order. */
 	keys(prefix) {
-		const all = /* @__PURE__ */ new Set();
-		for (const key of this.index.keys()) if (!prefix || key.startsWith(prefix)) all.add(key);
-		for (const key of this.parts.keys()) if (!prefix || key.startsWith(prefix)) all.add(key);
-		for (const key of this.modified.keys()) if (!prefix || key.startsWith(prefix)) all.add(key);
-		return [...all];
+		const seen = /* @__PURE__ */ new Set();
+		const collect = (key) => {
+			if (!prefix || key.startsWith(prefix)) seen.add(key);
+		};
+		for (const key of this.order) collect(key);
+		for (const key of this.parts.keys()) collect(key);
+		for (const key of this.modified.keys()) collect(key);
+		return [...seen];
 	}
 	/** Serialize back to a ZIP buffer, inflating any untouched compressed entries. */
 	save() {
@@ -1161,7 +1331,7 @@ var ParsedArchive = class {
 		const collect = (path, data) => {
 			files[path] = [data, { level: levelForMediaName(path, 6) }];
 		};
-		for (const path of /* @__PURE__ */ new Set([...this.index.keys(), ...this.parts.keys()])) {
+		for (const path of this.keys()) {
 			if (this.modified.has(path)) continue;
 			const data = this.parts.get(path) ?? this.inflate(path);
 			if (data !== void 0) collect(path, data);
@@ -1174,6 +1344,18 @@ var ParsedArchive = class {
 function parseArchive(data) {
 	return new ParsedArchive(data);
 }
+/** Decompress every indexed entry (Blob-backed open — after this, sync reads). */
+async function hydrateArchive(archive) {
+	const source = archive.source;
+	for (const entry of archive.index.values()) {
+		const data = await inflateEntryFrom(source, entry).catch(async () => {
+			const raw = await source.read(entry.dataStart, entry.compSize);
+			return entry.method === 0 ? raw.slice() : inflateSync(raw);
+		});
+		archive.index.delete(entry.name);
+		archive.parts.set(entry.name, data);
+	}
+}
 //#endregion
 //#region src/opc/opc-consistency.ts
 /**