reamkit 1.15.4 → 1.17.0

package/dist/esm/core/numbering/apply.d.ts

@@ -1,4 +1,4 @@
-import { BodyElement, Numbering } from '../document-model/index.js';
+import { BodyElement, Numbering, StyleSheet } from '../document-model/index.js';
 /**
  * Apply list numbering to a body as a FlowDoc transform (§17.9): walk the
  * elements (recursing into table cells), advancing list counters and prepending
@@ -8,9 +8,11 @@ import { BodyElement, Numbering } from '../document-model/index.js';
  *
  * @param body      The body elements to transform.
  * @param numbering The parsed numbering definitions, or `undefined`.
+ * @param styles    The style sheet, for a paragraph whose numbering comes from
+ *                  its STYLE (§17.9.24) rather than its own `w:numPr`.
  * @returns A new body with markers materialized.
  */
-export declare function applyNumbering(body: ReadonlyArray<BodyElement>, numbering: Numbering | undefined): Array<BodyElement>;
+export declare function applyNumbering(body: ReadonlyArray<BodyElement>, numbering: Numbering | undefined, styles?: StyleSheet): Array<BodyElement>;
 /**
  * Apply {@link applyNumbering} to each header/footer band independently (each
  * gets its own counter state), keyed as in the input map.
@@ -19,4 +21,4 @@ export declare function applyNumbering(body: ReadonlyArray<BodyElement>, numberi
  * @param numbering The parsed numbering definitions, or `undefined`.
  * @returns A new map with numbering applied (empty when `hf` is empty/absent).
  */
-export declare function applyNumberingToHeadersFooters(hf: ReadonlyMap<string, ReadonlyArray<BodyElement>> | undefined, numbering: Numbering | undefined): ReadonlyMap<string, ReadonlyArray<BodyElement>>;
+export declare function applyNumberingToHeadersFooters(hf: ReadonlyMap<string, ReadonlyArray<BodyElement>> | undefined, numbering: Numbering | undefined, styles?: StyleSheet): ReadonlyMap<string, ReadonlyArray<BodyElement>>;

package/dist/esm/core/numbering/apply.js

@@ -1,5 +1,13 @@
-import { NumberingState } from "./state.js";
+import { pt } from "../ir/units.js";
+import { NumberingState, effectiveAbstract } from "./state.js";
+import { resolveParagraphProperties } from "../style-cascade/resolver.js";
+import "../style-cascade/index.js";
 //#region src/core/numbering/apply.ts
+/** The height a picture bullet takes when neither the level nor the paragraph
+* mark states a font size — Word's own default text size. */
+var DEFAULT_BULLET_HEIGHT_PT = 11;
+/** SOFT HYPHEN, which a `w:lvlText` may spell a dash bullet with (§17.9.11). */
+var SOFT_HYPHEN = "­";
 /**
 * Apply list numbering to a body as a FlowDoc transform (§17.9): walk the
 * elements (recursing into table cells), advancing list counters and prepending
@@ -9,28 +17,51 @@ import { NumberingState } from "./state.js";
 *
 * @param body      The body elements to transform.
 * @param numbering The parsed numbering definitions, or `undefined`.
+* @param styles    The style sheet, for a paragraph whose numbering comes from
+*                  its STYLE (§17.9.24) rather than its own `w:numPr`.
 * @returns A new body with markers materialized.
 */
-function applyNumbering(body, numbering) {
+function applyNumbering(body, numbering, styles) {
 	if (!numbering || numbering.abstractNums.size === 0) return body.map((b) => b);
 	const state = new NumberingState();
+	const numberingOf = (p) => p.properties.numbering ?? (styles ? resolveParagraphProperties(p.properties, styles).numbering : void 0);
 	const transformParagraph = (p) => {
-		const ref = p.properties.numbering;
+		if (p.properties.sectionBreak === true && p.runs.every((r) => r.text === "")) return p;
+		const ref = numberingOf(p);
 		if (!ref) return p;
 		const marker = state.resolveMarker(numbering, ref);
 		if (marker === null) return p;
 		const instance = numbering.numInstances.get(ref.numId);
-		const level = (instance ? numbering.abstractNums.get(instance.abstractNumId) : void 0)?.levels.get(ref.ilvl);
-		const markerRun = {
-			text: `${marker}\t`,
-			properties: level?.runProperties ?? {},
+		const level = (instance ? effectiveAbstract(numbering, instance) : void 0)?.levels.get(ref.ilvl);
+		const pic = level?.picBullet;
+		const bulletCapPt = level?.runProperties.fontSizePt ?? p.properties.runProperties?.fontSizePt ?? DEFAULT_BULLET_HEIGHT_PT;
+		const bulletScale = pic ? Math.min(1, bulletCapPt / Math.max(1, pic.heightPt)) : 1;
+		const markerRuns = pic ? [{
+			text: "",
+			properties: {},
+			listMarker: true,
+			inlineImage: {
+				resource: pic.resource,
+				width: pt(pic.widthPt * bulletScale),
+				height: pt(pic.heightPt * bulletScale)
+			}
+		}, {
+			text: "	",
+			properties: {},
 			listMarker: true
-		};
+		}] : [{
+			text: `${marker.replaceAll(SOFT_HYPHEN, "-")}\t`,
+			properties: {
+				...p.properties.runProperties,
+				...level?.runProperties
+			},
+			listMarker: true
+		}];
 		const newProps = mergeIndentFromLevel(p.properties, level?.paragraphProperties);
 		return {
 			...p,
 			properties: newProps,
-			runs: [markerRun, ...p.runs]
+			runs: [...markerRuns, ...p.runs]
 		};
 	};
 	const visit = (el) => {
@@ -73,11 +104,11 @@ function mergeIndentFromLevel(paragraphProps, levelProps) {
 * @param numbering The parsed numbering definitions, or `undefined`.
 * @returns A new map with numbering applied (empty when `hf` is empty/absent).
 */
-function applyNumberingToHeadersFooters(hf, numbering) {
+function applyNumberingToHeadersFooters(hf, numbering, styles) {
 	if (!hf || hf.size === 0) return /* @__PURE__ */ new Map();
 	if (!numbering || numbering.abstractNums.size === 0) return hf;
 	const out = /* @__PURE__ */ new Map();
-	for (const [key, value] of hf) out.set(key, applyNumbering(value, numbering));
+	for (const [key, value] of hf) out.set(key, applyNumbering(value, numbering, styles));
 	return out;
 }
 //#endregion

package/dist/esm/core/numbering/index.js

@@ -0,0 +1,2 @@
+import "./state.js";
+import "./apply.js";

package/dist/esm/core/numbering/state.d.ts

@@ -1,4 +1,15 @@
-import { AbstractNumbering, Numbering, NumberingLevel, NumberingReference } from '../document-model/index.js';
+import { AbstractNumbering, Numbering, NumberingInstance, NumberingLevel, NumberingReference } from '../document-model/index.js';
+/**
+ * §17.9.27 — the levels an INSTANCE actually numbers by: its abstract
+ * definition's, with any `w:lvlOverride/w:lvl` shadowing them. Cached per
+ * instance, since every list paragraph asks for it.
+ *
+ * @param numbering The parsed numbering definitions.
+ * @param instance  The `w:num` the paragraph refers to.
+ * @returns The effective abstract numbering, or `undefined` when the instance
+ *          names one that is not there.
+ */
+export declare function effectiveAbstract(numbering: Numbering, instance: NumberingInstance): AbstractNumbering | undefined;
 /**
  * Mutable list-counter state for one numbering scope (e.g. a body or a single
  * header/footer band). Tracks a counter per list per level and advances them as
@@ -6,6 +17,7 @@ import { AbstractNumbering, Numbering, NumberingLevel, NumberingReference } from
  */
 export declare class NumberingState {
     private readonly counters;
+    private readonly restarted;
     /**
      * Advance the counter for `ref` (resetting deeper levels) and format its
      * marker text. The first hit at a level seeds it from the level's `start`;

package/dist/esm/core/numbering/state.js

@@ -1,11 +1,37 @@
 //#region src/core/numbering/state.ts
 /**
+* §17.9.27 — the levels an INSTANCE actually numbers by: its abstract
+* definition's, with any `w:lvlOverride/w:lvl` shadowing them. Cached per
+* instance, since every list paragraph asks for it.
+*
+* @param numbering The parsed numbering definitions.
+* @param instance  The `w:num` the paragraph refers to.
+* @returns The effective abstract numbering, or `undefined` when the instance
+*          names one that is not there.
+*/
+function effectiveAbstract(numbering, instance) {
+	const base = numbering.abstractNums.get(instance.abstractNumId);
+	if (!base || !instance.levelOverrides || instance.levelOverrides.size === 0) return base;
+	const hit = effectiveCache.get(instance);
+	if (hit) return hit;
+	const levels = new Map(base.levels);
+	for (const [ilvl, lvl] of instance.levelOverrides) levels.set(ilvl, lvl);
+	const merged = {
+		id: base.id,
+		levels
+	};
+	effectiveCache.set(instance, merged);
+	return merged;
+}
+var effectiveCache = /* @__PURE__ */ new WeakMap();
+/**
 * Mutable list-counter state for one numbering scope (e.g. a body or a single
 * header/footer band). Tracks a counter per list per level and advances them as
 * paragraphs are visited in order.
 */
 var NumberingState = class {
 	counters = /* @__PURE__ */ new Map();
+	restarted = /* @__PURE__ */ new Set();
 	/**
 	* Advance the counter for `ref` (resetting deeper levels) and format its
 	* marker text. The first hit at a level seeds it from the level's `start`;
@@ -19,19 +45,27 @@ var NumberingState = class {
 	resolveMarker(numbering, ref) {
 		const instance = numbering.numInstances.get(ref.numId);
 		if (!instance) return null;
-		const abstractNum = numbering.abstractNums.get(instance.abstractNumId);
+		const abstractNum = effectiveAbstract(numbering, instance);
 		if (!abstractNum) return null;
 		const level = abstractNum.levels.get(ref.ilvl);
 		if (!level) return null;
-		let arr = this.counters.get(ref.numId);
+		let arr = this.counters.get(instance.abstractNumId);
 		if (!arr) {
-			arr = new Array(9).fill(0);
-			this.counters.set(ref.numId, arr);
+			arr = new Array(9).fill(void 0);
+			this.counters.set(instance.abstractNumId, arr);
+		}
+		for (let k = ref.ilvl + 1; k < arr.length; k++) arr[k] = void 0;
+		const startAt = (i, fallback) => instance.startOverrides?.get(i) ?? fallback ?? 0;
+		const restartKey = `${ref.numId}:${String(ref.ilvl)}`;
+		const override = instance.startOverrides?.get(ref.ilvl);
+		if (override !== void 0 && !this.restarted.has(restartKey)) {
+			this.restarted.add(restartKey);
+			arr[ref.ilvl] = override;
+		} else {
+			const current = arr[ref.ilvl];
+			arr[ref.ilvl] = current === void 0 ? startAt(ref.ilvl, level.start) : current + 1;
 		}
-		for (let k = ref.ilvl + 1; k < arr.length; k++) arr[k] = 0;
-		if (arr[ref.ilvl] === 0) arr[ref.ilvl] = level.start;
-		else arr[ref.ilvl] += 1;
-		return formatLevelMarker(abstractNum, level, arr);
+		return formatLevelMarker(abstractNum, level, arr.map((n, i) => n ?? startAt(i, abstractNum.levels.get(i)?.start)));
 	}
 };
 function formatLevelMarker(abstractNum, currentLevel, counters) {
@@ -40,20 +74,227 @@ function formatLevelMarker(abstractNum, currentLevel, counters) {
 		const lvlIdx = Number(n) - 1;
 		const level = abstractNum.levels.get(lvlIdx);
 		const counter = counters[lvlIdx] ?? 0;
-		return formatCounter(level?.format ?? "decimal", counter);
+		return formatCounter(currentLevel.isLegal === true && lvlIdx !== currentLevel.ilvl ? "decimal" : level?.format ?? "decimal", counter);
 	});
 }
 function formatCounter(format, n) {
-	if (n <= 0) return "";
+	if (n < 0) return "";
 	switch (format) {
 		case "decimal": return String(n);
-		case "lowerLetter": return toLetters(n).toLowerCase();
-		case "upperLetter": return toLetters(n);
-		case "lowerRoman": return toRoman(n).toLowerCase();
-		case "upperRoman": return toRoman(n);
+		case "decimalZero": return n < 10 ? `0${String(n)}` : String(n);
+		case "decimalFullWidth": return digitByDigit(n, FULL_WIDTH_DIGITS);
+		case "ordinal": return `${String(n)}${ordinalSuffix(n)}`;
+		case "lowerLetter": return n === 0 ? "" : toLetters(n).toLowerCase();
+		case "upperLetter": return n === 0 ? "" : toLetters(n);
+		case "lowerRoman": return n === 0 ? "" : toRoman(n).toLowerCase();
+		case "upperRoman": return n === 0 ? "" : toRoman(n);
+		case "ideographTraditional": return n === 0 ? "" : n <= HEAVENLY_STEMS.length ? HEAVENLY_STEMS[n - 1] : String(n);
+		case "ideographZodiac": return n === 0 ? "" : n <= EARTHLY_BRANCHES.length ? EARTHLY_BRANCHES[n - 1] : String(n);
+		case "ideographDigital":
+		case "koreanDigital2": return digitByDigit(n, IDEOGRAPH_DIGITS);
+		case "ideographLegalTraditional": return counting(n, LEGAL_DIGITS, LEGAL_UNITS, false);
+		case "chineseCounting":
+		case "chineseCountingThousand":
+		case "japaneseCounting":
+		case "koreanCounting":
+		case "taiwaneseCounting":
+		case "taiwaneseCountingThousand": return counting(n, IDEOGRAPH_DIGITS, COUNTING_UNITS, true);
+		case "hebrew1": return n === 0 ? "" : toHebrewNumeral(n);
+		case "hebrew2": return n === 0 ? "" : HEBREW_ALPHABET[(n - 1) % HEBREW_ALPHABET.length];
+		case "decimalEnclosedCircle": return n >= 1 && n <= 20 ? String.fromCodePoint(9311 + n) : String(n);
+		case "chicago":
+			if (n < 1) return "";
+			return CHICAGO_MARKS[(n - 1) % CHICAGO_MARKS.length].repeat(Math.floor((n - 1) / CHICAGO_MARKS.length) + 1);
 		default: return "";
 	}
 }
+var HEBREW_ONES = [
+	"",
+	"א",
+	"ב",
+	"ג",
+	"ד",
+	"ה",
+	"ו",
+	"ז",
+	"ח",
+	"ט"
+];
+var HEBREW_TENS = [
+	"",
+	"י",
+	"כ",
+	"ל",
+	"מ",
+	"נ",
+	"ס",
+	"ע",
+	"פ",
+	"צ"
+];
+var HEBREW_HUNDREDS = [
+	"",
+	"ק",
+	"ר",
+	"ש",
+	"ת"
+];
+var HEBREW_ALPHABET = [
+	"א",
+	"ב",
+	"ג",
+	"ד",
+	"ה",
+	"ו",
+	"ז",
+	"ח",
+	"ט",
+	"י",
+	"כ",
+	"ל",
+	"מ",
+	"נ",
+	"ס",
+	"ע",
+	"פ",
+	"צ",
+	"ק",
+	"ר",
+	"ש",
+	"ת"
+];
+function toHebrewNumeral(n) {
+	let rest = n;
+	let out = "";
+	while (rest >= 400) {
+		out += "ת";
+		rest -= 400;
+	}
+	out += HEBREW_HUNDREDS[Math.floor(rest / 100)] ?? "";
+	rest %= 100;
+	if (rest === 15 || rest === 16) out += rest === 15 ? "טו" : "טז";
+	else {
+		out += HEBREW_TENS[Math.floor(rest / 10)] ?? "";
+		out += HEBREW_ONES[rest % 10] ?? "";
+	}
+	return out;
+}
+var CHICAGO_MARKS = [
+	"*",
+	"†",
+	"‡",
+	"§"
+];
+var IDEOGRAPH_DIGITS = [
+	"零",
+	"一",
+	"二",
+	"三",
+	"四",
+	"五",
+	"六",
+	"七",
+	"八",
+	"九"
+];
+var COUNTING_UNITS = [
+	"",
+	"十",
+	"百",
+	"千"
+];
+var LEGAL_DIGITS = [
+	"零",
+	"壹",
+	"貳",
+	"參",
+	"肆",
+	"伍",
+	"陸",
+	"柒",
+	"捌",
+	"玖"
+];
+var LEGAL_UNITS = [
+	"",
+	"拾",
+	"佰",
+	"仟"
+];
+var HEAVENLY_STEMS = [
+	"甲",
+	"乙",
+	"丙",
+	"丁",
+	"戊",
+	"己",
+	"庚",
+	"辛",
+	"壬",
+	"癸"
+];
+var EARTHLY_BRANCHES = [
+	"子",
+	"丑",
+	"寅",
+	"卯",
+	"辰",
+	"巳",
+	"午",
+	"未",
+	"申",
+	"酉",
+	"戌",
+	"亥"
+];
+var FULL_WIDTH_DIGITS = [
+	"０",
+	"１",
+	"２",
+	"３",
+	"４",
+	"５",
+	"６",
+	"７",
+	"８",
+	"９"
+];
+/** Each decimal digit as its own glyph — no units, no elision (10 → 一零). */
+function digitByDigit(n, digits) {
+	return String(n).split("").map((d) => digits[Number(d)] ?? d).join("");
+}
+/**
+* The counting systems: digits carrying place units (十百千). `elideTen` drops
+* the leading 一 of the tens place, which is what the plain counting systems do
+* (11 → 十一) and the formal one does not (11 → 壹拾壹). Above the units the
+* table covers, plain digits — a list marker never gets that far.
+*/
+function counting(n, digits, units, elideTen) {
+	if (n >= 10 ** units.length) return String(n);
+	const ds = String(n).split("").map(Number);
+	let out = "";
+	ds.forEach((d, i) => {
+		const place = ds.length - 1 - i;
+		if (d === 0) {
+			if (out.length > 0 && !out.endsWith(digits[0]) && ds.slice(i).some((x) => x > 0)) out += digits[0];
+			return;
+		}
+		const head = elideTen && d === 1 && place === 1 && i === 0 ? "" : digits[d];
+		out += head + units[place];
+	});
+	return out;
+}
+/** `1st`, `2nd`, `3rd`, `4th` — the English ordinal suffixes (§17.18.59). */
+function ordinalSuffix(n) {
+	const two = n % 100;
+	if (two >= 11 && two <= 13) return "th";
+	switch (n % 10) {
+		case 1: return "st";
+		case 2: return "nd";
+		case 3: return "rd";
+		default: return "th";
+	}
+}
 function toLetters(n) {
 	let s = "";
 	let v = n;
@@ -95,4 +336,4 @@ function normalizeBullet(lvlText) {
 	return lvlText;
 }
 //#endregion
-export { NumberingState };
+export { NumberingState, effectiveAbstract, formatLevelMarker };

package/dist/esm/core/opc/alternate-content.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Replace every `<mc:AlternateContent>` with the markup its `<mc:Fallback>`
+ * holds, so the part reaching the XML parser is plain OOXML in its original
+ * element order. A block with no Fallback resolves to nothing — which is what
+ * §10.2 of the Markup Compatibility spec asks of a reader that understands
+ * none of the offered choices.
+ *
+ * Text with no AlternateContent is returned unchanged, which is most files.
+ *
+ * @param xml The decoded part, as read from the package.
+ * @returns The part with its compatibility blocks resolved.
+ */
+export declare function resolveAlternateContent(xml: string): string;

package/dist/esm/core/opc/alternate-content.js

@@ -0,0 +1,72 @@
+//#region src/core/opc/alternate-content.ts
+/** Deepest nesting of one AlternateContent inside another that we will unwrap. */
+var MAX_DEPTH = 8;
+var OPEN = /<(?:[A-Za-z_][\w.-]*:)?AlternateContent(?=[\s/>])/g;
+/**
+* Find the element starting at `from` (the index of its `<`) and return the
+* span of its content plus the index just past its closing tag. Returns
+* undefined for an unclosed element — malformed markup we leave alone.
+*/
+function elementAt(xml, from, local) {
+	const nameEnd = xml.indexOf(">", from);
+	if (nameEnd < 0) return void 0;
+	if (xml[nameEnd - 1] === "/") return {
+		inner: "",
+		end: nameEnd + 1
+	};
+	const open = new RegExp(`<(?:[A-Za-z_][\\w.-]*:)?${local}(?=[\\s/>])`, "g");
+	const close = new RegExp(`</(?:[A-Za-z_][\\w.-]*:)?${local}\\s*>`, "g");
+	let depth = 1;
+	let cursor = nameEnd + 1;
+	while (depth > 0) {
+		close.lastIndex = cursor;
+		const shut = close.exec(xml);
+		if (!shut) return void 0;
+		open.lastIndex = cursor;
+		for (let o = open.exec(xml); o && o.index < shut.index; o = open.exec(xml)) if (xml[xml.indexOf(">", o.index) - 1] !== "/") depth++;
+		depth--;
+		cursor = shut.index + shut[0].length;
+		if (depth === 0) return {
+			inner: xml.slice(nameEnd + 1, shut.index),
+			end: cursor
+		};
+	}
+}
+/** The content of the first `<mc:Fallback>` directly inside `inner`, or ''. */
+function fallbackOf(inner) {
+	const at = (/* @__PURE__ */ new RegExp("<(?:[A-Za-z_][\\w.-]*:)?Fallback(?=[\\s/>])")).exec(inner);
+	if (!at) return "";
+	return elementAt(inner, at.index, "Fallback")?.inner ?? "";
+}
+/**
+* Replace every `<mc:AlternateContent>` with the markup its `<mc:Fallback>`
+* holds, so the part reaching the XML parser is plain OOXML in its original
+* element order. A block with no Fallback resolves to nothing — which is what
+* §10.2 of the Markup Compatibility spec asks of a reader that understands
+* none of the offered choices.
+*
+* Text with no AlternateContent is returned unchanged, which is most files.
+*
+* @param xml The decoded part, as read from the package.
+* @returns The part with its compatibility blocks resolved.
+*/
+function resolveAlternateContent(xml) {
+	let out = xml;
+	for (let pass = 0; pass < MAX_DEPTH; pass++) {
+		if (!out.includes("AlternateContent")) return out;
+		let cursor = 0;
+		let next = "";
+		OPEN.lastIndex = 0;
+		for (let found = OPEN.exec(out); found; found = OPEN.exec(out)) {
+			const el = elementAt(out, found.index, "AlternateContent");
+			if (!el) break;
+			next += out.slice(cursor, found.index) + fallbackOf(el.inner);
+			cursor = el.end;
+			OPEN.lastIndex = cursor;
+		}
+		out = next + out.slice(cursor);
+	}
+	return out;
+}
+//#endregion
+export { resolveAlternateContent };

package/dist/esm/core/opc/core-properties.js

@@ -2,6 +2,7 @@ import { XMLParser } from "fast-xml-parser";
 //#region src/core/opc/core-properties.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	textNodeName: "#text",

package/dist/esm/core/opc/package.d.ts

@@ -28,6 +28,7 @@ export declare class OpcPackage {
      */
     private constructor();
     private readonly relsCache;
+    private folded;
     /**
      * Unzip and validate a package's bytes. Rejects an OLE compound file (an
      * encrypted OOXML container or a legacy binary `.doc`/`.xls`) and enforces the
@@ -37,8 +38,20 @@ export declare class OpcPackage {
      *         `_rels/.rels` is missing.
      */
     static open(buffer: Uint8Array, options?: OpcOpenOptions): OpcPackage;
-    /** The bytes of the part at `path`, or undefined when absent. */
+    /**
+     * The bytes of the part at `path`, or undefined when absent.
+     *
+     * OPC part names are compared case-insensitively (ISO/IEC 29500-2 §9.1.1.1),
+     * so two names differing only in case are the SAME part. Producers do mix
+     * them: 123233_charts.xlsx writes `xl/worksheets/Sheet1.xml` and its
+     * relationships as `_rels/sheet1.xml.rels`, and an exact lookup found no
+     * relationships for that sheet at all — which cost it four charts, silently,
+     * because a sheet with no drawing rel is indistinguishable from one with no
+     * drawing. An exact hit still wins; the fold is only a fallback.
+     */
     getPart(path: string): Uint8Array | undefined;
+    /** Parts keyed by their case-folded path, built once on first miss. */
+    private foldedParts;
     /**
      * The bytes of the part at `path`.
      *

package/dist/esm/core/opc/package.js

@@ -19,6 +19,7 @@ var OpcPackage = class OpcPackage {
 		this.rootRelationships = rootRelationships;
 	}
 	relsCache = /* @__PURE__ */ new Map();
+	folded;
 	/**
 	* Unzip and validate a package's bytes. Rejects an OLE compound file (an
 	* encrypted OOXML container or a legacy binary `.doc`/`.xls`) and enforces the
@@ -37,7 +38,7 @@ var OpcPackage = class OpcPackage {
 		let total = 0;
 		let count = 0;
 		let violation;
-		const entries = unzipSync(buffer, { filter: (info) => {
+		const entries = unzipGuarded(buffer, { filter: (info) => {
 			if (++count > maxEntries) {
 				violation ??= `more than ${maxEntries} entries`;
 				return false;
@@ -61,9 +62,32 @@ var OpcPackage = class OpcPackage {
 		if (!relsBytes) throw new Error(`OPC package missing ${ROOT_RELS_PATH}`);
 		return new OpcPackage(parts, parseRelationships(relsBytes));
 	}
-	/** The bytes of the part at `path`, or undefined when absent. */
+	/**
+	* The bytes of the part at `path`, or undefined when absent.
+	*
+	* OPC part names are compared case-insensitively (ISO/IEC 29500-2 §9.1.1.1),
+	* so two names differing only in case are the SAME part. Producers do mix
+	* them: 123233_charts.xlsx writes `xl/worksheets/Sheet1.xml` and its
+	* relationships as `_rels/sheet1.xml.rels`, and an exact lookup found no
+	* relationships for that sheet at all — which cost it four charts, silently,
+	* because a sheet with no drawing rel is indistinguishable from one with no
+	* drawing. An exact hit still wins; the fold is only a fallback.
+	*/
 	getPart(path) {
-		return this.parts.get(normalizePath(path));
+		const normalized = normalizePath(path);
+		return this.parts.get(normalized) ?? this.foldedParts().get(normalized.toLowerCase());
+	}
+	/** Parts keyed by their case-folded path, built once on first miss. */
+	foldedParts() {
+		if (!this.folded) {
+			const folded = /* @__PURE__ */ new Map();
+			for (const [path, data] of this.parts) {
+				const key = path.toLowerCase();
+				if (!folded.has(key)) folded.set(key, data);
+			}
+			this.folded = folded;
+		}
+		return this.folded;
 	}
 	/**
 	* The bytes of the part at `path`.
@@ -92,7 +116,7 @@ var OpcPackage = class OpcPackage {
 		const dir = slash >= 0 ? normalized.substring(0, slash) : "";
 		const base = slash >= 0 ? normalized.substring(slash + 1) : normalized;
 		const relsPath = dir.length > 0 ? `${dir}/_rels/${base}.rels` : `_rels/${base}.rels`;
-		const data = this.parts.get(relsPath);
+		const data = this.getPart(relsPath);
 		const rels = data ? parseRelationships(data) : [];
 		this.relsCache.set(normalized, rels);
 		return rels;
@@ -162,5 +186,20 @@ function collapseDotSegments(p) {
 	}
 	return out.join("/");
 }
+/**
+* {@link unzipSync}, with a decompression failure turned into a named refusal.
+*
+* @param buffer  The archive bytes.
+* @param options The fflate options (the zip-bomb entry filter).
+* @returns The decompressed entries.
+* @throws Error naming the archive as invalid when inflation fails.
+*/
+function unzipGuarded(buffer, options) {
+	try {
+		return unzipSync(buffer, options);
+	} catch (e) {
+		throw new Error(`invalid zip data: ${e instanceof Error ? e.message : String(e)}`);
+	}
+}
 //#endregion
 export { OpcPackage };

package/dist/esm/core/opc/relationships.js

@@ -2,6 +2,7 @@ import { XMLParser } from "fast-xml-parser";
 //#region src/core/opc/relationships.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
 	parseAttributeValue: false,