@stll/folio-core 0.52.0 → 0.54.0

package/dist/docx/headerFooterReferenceNormalization.js

@@ -4,12 +4,9 @@ import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
 const DANGLING_HEADER_REFERENCE_WARNING = PARSE_WARNING_CODES.danglingHeaderReference;
 const DANGLING_FOOTER_REFERENCE_WARNING = PARSE_WARNING_CODES.danglingFooterReference;
 const normalizeHeaderFooterReferences = ({ documentBody, headers, footers }) => {
-	const seenSectionProperties = /* @__PURE__ */ new Set();
 	let removedDanglingHeaderReferences = 0;
 	let removedDanglingFooterReferences = 0;
 	const normalizeSectionProperties = (sectionProperties) => {
-		if (!sectionProperties || seenSectionProperties.has(sectionProperties)) return;
-		seenSectionProperties.add(sectionProperties);
 		const headerResult = removeDanglingReferences(sectionProperties.headerReferences, headers);
 		if (headerResult.changed) {
 			removedDanglingHeaderReferences += headerResult.removed;
@@ -23,34 +20,62 @@ const normalizeHeaderFooterReferences = ({ documentBody, headers, footers }) =>
 			else delete sectionProperties.footerReferences;
 		}
 	};
-	const normalizeParagraph = (paragraph) => {
-		normalizeSectionProperties(paragraph.sectionProperties);
+	forEachSectionProperties(documentBody, normalizeSectionProperties);
+	return {
+		removedDanglingHeaderReferences,
+		removedDanglingFooterReferences
 	};
-	const normalizeTable = (table) => {
-		for (const row of table.rows) for (const cell of row.cells) normalizeBlocks(cell.content);
+};
+/**
+* Visit every distinct section record once, in section order: the paragraph
+* carriers in document order, then the body's final `w:sectPr`.
+*/
+const forEachSectionProperties = (documentBody, visit) => {
+	const seen = /* @__PURE__ */ new Set();
+	const visitOnce = (sectionProperties) => {
+		if (!sectionProperties || seen.has(sectionProperties)) return;
+		seen.add(sectionProperties);
+		visit(sectionProperties);
 	};
-	const normalizeBlock = (block) => {
-		if (block.type === "paragraph") {
-			normalizeParagraph(block);
-			return;
-		}
-		if (block.type === "table") {
-			normalizeTable(block);
-			return;
-		}
-		if (block.type !== "blockSdt") return;
-		normalizeBlocks(block.content);
+	const visitBlocks = (blocks) => {
+		for (const block of blocks) if (block.type === "paragraph") visitOnce(block.sectionProperties);
+		else if (block.type === "table") visitTable(block);
+		else if (block.type === "blockSdt" || block.type === "blockCustomXml") visitBlocks(block.content);
 	};
-	const normalizeBlocks = (blocks) => {
-		for (const block of blocks) normalizeBlock(block);
+	const visitTable = (table) => {
+		for (const row of table.rows) for (const cell of row.cells) visitBlocks(cell.content);
 	};
-	normalizeBlocks(documentBody.content);
-	normalizeSectionProperties(documentBody.finalSectionProperties);
-	for (const section of documentBody.sections ?? []) normalizeSectionProperties(section.properties);
-	return {
-		removedDanglingHeaderReferences,
-		removedDanglingFooterReferences
+	visitBlocks(documentBody.content);
+	visitOnce(documentBody.finalSectionProperties);
+	for (const section of documentBody.sections ?? []) visitOnce(section.properties);
+};
+/**
+* Give each header and footer part the role a section reference states for
+* it.
+*
+* A part says nothing about which pages it serves: the `w:type` of the
+* `w:headerReference` / `w:footerReference` naming it does (ECMA-376 Part 1
+* §17.10.5, `ST_HdrFtr`). The parts are read from the document's
+* relationships, before any section is consulted, so each is read as a
+* default part and takes its role here, from the first section that
+* references it. A part no section references stays default; one several
+* sections reference in different roles keeps the first, and a reader that
+* needs every role reads the section references themselves.
+*/
+const assignHeaderFooterRoles = ({ documentBody, headers, footers }) => {
+	const assigned = /* @__PURE__ */ new Set();
+	const assign = (references, parts) => {
+		for (const { type, rId } of references ?? []) {
+			const part = parts?.get(rId);
+			if (!part || assigned.has(part)) continue;
+			assigned.add(part);
+			part.hdrFtrType = type;
+		}
 	};
+	forEachSectionProperties(documentBody, (sectionProperties) => {
+		assign(sectionProperties.headerReferences, headers);
+		assign(sectionProperties.footerReferences, footers);
+	});
 };
 const removeDanglingReferences = (references, validParts) => {
 	if (!references || !validParts) return {
@@ -66,4 +91,4 @@ const removeDanglingReferences = (references, validParts) => {
 	};
 };
 //#endregion
-export { DANGLING_FOOTER_REFERENCE_WARNING, DANGLING_HEADER_REFERENCE_WARNING, normalizeHeaderFooterReferences };
+export { DANGLING_FOOTER_REFERENCE_WARNING, DANGLING_HEADER_REFERENCE_WARNING, assignHeaderFooterRoles, normalizeHeaderFooterReferences };

package/dist/docx/hyperlinkParser.d.ts

@@ -1,8 +1,8 @@
 import { document_d_exports } from "../types/document.js";
 import { XmlElement } from "./xmlParser.js";
+import { ChildReader } from "./containerChildren.js";
 import { PreviewLedger } from "./previewBudget.js";
 import { StyleMap } from "./styleParser.js";
-import { ChildReader } from "./containerChildren.js";
 //#region src/docx/hyperlinkParser.d.ts
 /**
  * Parse a hyperlink element (w:hyperlink)

package/dist/docx/index.d.ts

@@ -1,6 +1,6 @@
 import { getCachedNumberingMap } from "./numberingParser.js";
+import { NO_NUMBERING_NUM_ID, NO_PARAGRAPH_NUMBERING, ParagraphNumberingOverride, ParagraphNumberingSlots, ResolvedParagraphNumbering, isNumberingReference, mergeParagraphNumbering, paragraphNumberingFromSlots, paragraphNumberingLevel, paragraphNumberingReferenceId, paragraphNumberingSlots, readParagraphNumbering, resolveParagraphNumbering, sameEffectiveParagraphNumbering, sameStatedParagraphNumbering } from "./numberingReference.js";
 import { DOCX_ENCRYPTION_ERROR_CODES, DocxEncryptionError, DocxEncryptionErrorCode, isDocxEncryptionError } from "./encryption/errors.js";
 import { DecryptDocxOptions, DecryptDocxResult, decryptDocxIfNeeded, openDocxBuffer } from "./encryption/openEncryptedDocx.js";
-import { NO_NUMBERING_NUM_ID, NO_PARAGRAPH_NUMBERING, ParagraphNumberingOverride, ParagraphNumberingSlots, ResolvedParagraphNumbering, isNumberingReference, mergeParagraphNumbering, paragraphNumberingFromSlots, paragraphNumberingLevel, paragraphNumberingReferenceId, paragraphNumberingSlots, readParagraphNumbering, resolveParagraphNumbering, sameEffectiveParagraphNumbering, sameStatedParagraphNumbering } from "./numberingReference.js";
 import { FOLIO_DOCUMENT_METADATA_PROPERTIES, FOLIO_DOCUMENT_PRIVACY_TRANSFORMS, FolioDocumentMetadataProperty, FolioDocumentPrivacyArchiveError, FolioDocumentPrivacyOptions, FolioDocumentPrivacyReport, FolioDocumentPrivacyTransform, InvalidFolioDocumentPrivacyOptionsError, RewriteDocxMetadataPrivacyResult, isFolioDocumentPrivacyTransform, rewriteDocxMetadataPrivacy } from "./metadataPrivacy.js";
 export { DOCX_ENCRYPTION_ERROR_CODES, type DecryptDocxOptions, type DecryptDocxResult, DocxEncryptionError, type DocxEncryptionErrorCode, FOLIO_DOCUMENT_METADATA_PROPERTIES, FOLIO_DOCUMENT_PRIVACY_TRANSFORMS, type FolioDocumentMetadataProperty, FolioDocumentPrivacyArchiveError, type FolioDocumentPrivacyOptions, type FolioDocumentPrivacyReport, type FolioDocumentPrivacyTransform, InvalidFolioDocumentPrivacyOptionsError, NO_NUMBERING_NUM_ID, NO_PARAGRAPH_NUMBERING, type ParagraphNumberingOverride, type ParagraphNumberingSlots, type ResolvedParagraphNumbering, type RewriteDocxMetadataPrivacyResult, decryptDocxIfNeeded, getCachedNumberingMap, isDocxEncryptionError, isFolioDocumentPrivacyTransform, isNumberingReference, mergeParagraphNumbering, openDocxBuffer, paragraphNumberingFromSlots, paragraphNumberingLevel, paragraphNumberingReferenceId, paragraphNumberingSlots, readParagraphNumbering, resolveParagraphNumbering, rewriteDocxMetadataPrivacy, sameEffectiveParagraphNumbering, sameStatedParagraphNumbering };

package/dist/docx/listNumberingInstances.d.ts

@@ -0,0 +1,59 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/docx/listNumberingInstances.d.ts
+/** The two kinds of list a command can create. */
+declare const LIST_KINDS: readonly ["bullet", "numbered"];
+type ListKind = (typeof LIST_KINDS)[number];
+/** What a numbered list's first level counts in and how its marker reads. */
+type ListLevelFormat = {
+  numFmt: document_d_exports.NumberFormat;
+  /** `w:lvlText` for level 0, e.g. `%1.` or `%1)`. */
+  lvlText: string;
+};
+/** The first-level appearance and start a new list is minted with. */
+type NewListDefinition = {
+  kind: ListKind;
+  /** Level-0 format of a numbered list; the template's `%1.` decimal otherwise. */
+  format?: ListLevelFormat | undefined;
+  /** The value the first item shows, stated as a level-0 `w:startOverride`. */
+  start?: number | undefined;
+};
+type MintedListInstance = {
+  definitions: document_d_exports.NumberingDefinitions;
+  numId: number;
+};
+/**
+ * Define a new list: a new `w:abstractNum` of the requested kind and the
+ * `w:num` naming it. `definitions` must already hold every instance the
+ * document references (see {@link completeListNumbering}), so the new ids
+ * collide with none of them.
+ */
+declare const mintListInstance: (definitions: document_d_exports.NumberingDefinitions | null | undefined, { kind, format, start }: NewListDefinition) => MintedListInstance;
+type RestartListInstanceOptions = {
+  abstractNumId: number;
+  ilvl: number;
+  start: number;
+};
+/**
+ * A new `w:num` over an existing `w:abstractNum`, with a `w:startOverride` at
+ * `ilvl`: *Restart Numbering* and *Set Numbering Value*. The override is what
+ * makes a consumer count the instance on its own rather than continue the
+ * other instances of the same definition.
+ */
+declare const restartListInstance: (definitions: document_d_exports.NumberingDefinitions | null | undefined, { abstractNumId, ilvl, start }: RestartListInstanceOptions) => MintedListInstance;
+/** One paragraph's numbering reference and the rendering it resolved to. */
+type ListInstanceReference = {
+  numId: number;
+  ilvl: number;
+  rendering: document_d_exports.ListRendering;
+};
+/**
+ * Define every instance `references` name that `definitions` does not.
+ *
+ * A reference the editor resolved carries its rendering, and a rendering is
+ * what a minted instance leaves behind; a reference without one (a dangling
+ * id read from a file) has no rendering and so is never defined here. Returns
+ * `definitions` itself when nothing is missing.
+ */
+declare const completeListNumbering: (definitions: document_d_exports.NumberingDefinitions | undefined, references: Iterable<ListInstanceReference>) => document_d_exports.NumberingDefinitions | undefined;
+//#endregion
+export { LIST_KINDS, ListInstanceReference, ListKind, ListLevelFormat, completeListNumbering, mintListInstance, restartListInstance };

package/dist/docx/listNumberingInstances.js

@@ -0,0 +1,249 @@
+import { NUMBER_FORMATS } from "@stll/docx-core/model";
+//#region src/docx/listNumberingInstances.ts
+/**
+* Numbering instances the editor defines itself.
+*
+* A list command in a document with no list of the requested kind has nothing
+* to reference: the package may have no numbering part at all. The command
+* then defines one, an `w:abstractNum` built from {@link defaultListLevels}
+* plus the `w:num` naming it, as a word processor does when a list is
+* started in a document without lists.
+*
+* The definition lives in two places without being stored twice. While the
+* document is edited, the paragraphs that reference the instance carry the
+* rendering it resolved to (`listAbstractNumId`, `listNumFmt`,
+* `listMarkerTemplate`, `listStartOverride`, …), and those attrs travel with
+* the paragraph through undo, collaboration and every save path.
+* {@link completeListNumbering} turns them back into the definition wherever
+* the package's own numbering has no entry for the id. Because a minted
+* definition is the template plus level-0 facts that the rendering states, the
+* definition it rebuilds is the one the command minted.
+*/
+/** The two kinds of list a command can create. */
+const LIST_KINDS = ["bullet", "numbered"];
+const INDENT_STEP_TWIPS = 720;
+const HANGING_TWIPS = 360;
+const ROMAN_HANGING_TWIPS = 180;
+const LEVEL_COUNT = 9;
+const levelIndent = (ilvl, hanging) => ({
+	indentLeft: INDENT_STEP_TWIPS * (ilvl + 1),
+	indentFirstLine: -hanging,
+	hangingIndent: true
+});
+/** The customary numbered-list cycle: `1.`, `a.`, `i.`, then again one level deeper. */
+const NUMBERED_CYCLE = [
+	{
+		numFmt: "decimal",
+		lvlJc: "left",
+		hanging: HANGING_TWIPS
+	},
+	{
+		numFmt: "lowerLetter",
+		lvlJc: "left",
+		hanging: HANGING_TWIPS
+	},
+	{
+		numFmt: "lowerRoman",
+		lvlJc: "right",
+		hanging: ROMAN_HANGING_TWIPS
+	}
+];
+/** The customary bullet cycle: a round bullet, an open circle, a square. */
+const BULLET_CYCLE = [
+	{
+		text: "•",
+		font: null
+	},
+	{
+		text: "o",
+		font: "Courier New"
+	},
+	{
+		text: "▪",
+		font: null
+	}
+];
+const cycleEntry = (cycle, ilvl) => cycle.at(ilvl % cycle.length) ?? cycle[0];
+const numberedLevel = (ilvl) => {
+	const { numFmt, lvlJc, hanging } = cycleEntry(NUMBERED_CYCLE, ilvl);
+	return {
+		ilvl,
+		start: 1,
+		numFmt,
+		lvlText: `%${ilvl + 1}.`,
+		lvlJc,
+		pPr: levelIndent(ilvl, hanging)
+	};
+};
+const bulletLevel = (ilvl) => {
+	const { text, font } = cycleEntry(BULLET_CYCLE, ilvl);
+	return {
+		ilvl,
+		start: 1,
+		numFmt: "bullet",
+		lvlText: text,
+		lvlJc: "left",
+		pPr: levelIndent(ilvl, HANGING_TWIPS),
+		...font === null ? {} : { rPr: { fontFamily: {
+			ascii: font,
+			hAnsi: font
+		} } }
+	};
+};
+/** The nine levels a list of `kind` is minted with. */
+const defaultListLevels = (kind) => Array.from({ length: LEVEL_COUNT }, (_, ilvl) => kind === "bullet" ? bulletLevel(ilvl) : numberedLevel(ilvl));
+const mintAbstractNumbering = ({ abstractNumId, kind, format }) => {
+	const levels = defaultListLevels(kind);
+	const first = levels[0];
+	if (first && kind === "numbered" && format) levels[0] = {
+		...first,
+		numFmt: format.numFmt,
+		lvlText: format.lvlText
+	};
+	return {
+		abstractNumId,
+		multiLevelType: "hybridMultilevel",
+		levels
+	};
+};
+/** The template counts from one, so only another first value needs an override. */
+const levelZeroStart = (start) => start === void 0 || start === 1 ? void 0 : [{
+	ilvl: 0,
+	startOverride: start
+}];
+const EMPTY_DEFINITIONS = {
+	abstractNums: [],
+	nums: []
+};
+const nextId = (ids, floor) => {
+	let next = floor;
+	for (const id of ids) next = Math.max(next, id + 1);
+	return next;
+};
+/** A fresh `w:numId` for `definitions`; zero is reserved for "no numbering". */
+const nextNumId = (definitions) => nextId((definitions?.nums ?? []).map(({ numId }) => numId), 1);
+/** A fresh `w:abstractNumId` for `definitions`. */
+const nextAbstractNumId = (definitions) => nextId((definitions?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId), 0);
+/**
+* Define a new list: a new `w:abstractNum` of the requested kind and the
+* `w:num` naming it. `definitions` must already hold every instance the
+* document references (see {@link completeListNumbering}), so the new ids
+* collide with none of them.
+*/
+const mintListInstance = (definitions, { kind, format, start }) => {
+	const current = definitions ?? EMPTY_DEFINITIONS;
+	const numId = nextNumId(current);
+	const abstractNumId = nextAbstractNumId(current);
+	const levelOverrides = levelZeroStart(start);
+	const instance = {
+		numId,
+		abstractNumId,
+		...levelOverrides ? { levelOverrides } : {}
+	};
+	return {
+		numId,
+		definitions: {
+			...current,
+			abstractNums: [...current.abstractNums, mintAbstractNumbering({
+				abstractNumId,
+				kind,
+				format
+			})],
+			nums: [...current.nums, instance]
+		}
+	};
+};
+/**
+* A new `w:num` over an existing `w:abstractNum`, with a `w:startOverride` at
+* `ilvl`: *Restart Numbering* and *Set Numbering Value*. The override is what
+* makes a consumer count the instance on its own rather than continue the
+* other instances of the same definition.
+*/
+const restartListInstance = (definitions, { abstractNumId, ilvl, start }) => {
+	const current = definitions ?? EMPTY_DEFINITIONS;
+	const numId = nextNumId(current);
+	const instance = {
+		numId,
+		abstractNumId,
+		levelOverrides: [{
+			ilvl,
+			startOverride: start
+		}]
+	};
+	return {
+		numId,
+		definitions: {
+			...current,
+			nums: [...current.nums, instance]
+		}
+	};
+};
+const NUMBER_FORMAT_SET = new Set(NUMBER_FORMATS);
+const isNumberFormat = (format) => format !== void 0 && NUMBER_FORMAT_SET.has(format);
+const levelZeroFormat = (references) => {
+	const first = references.find(({ ilvl }) => ilvl === 0)?.rendering;
+	const numFmt = first?.numFmt ?? references.find(({ rendering }) => rendering.levelNumFmts?.[0])?.rendering.levelNumFmts?.[0];
+	if (!isNumberFormat(numFmt)) return;
+	return {
+		numFmt,
+		lvlText: first?.markerTemplate ?? "%1."
+	};
+};
+const startOverridesOf = (references) => {
+	const byLevel = /* @__PURE__ */ new Map();
+	for (const { ilvl, rendering } of references) if (rendering.startOverride !== void 0 && !byLevel.has(ilvl)) byLevel.set(ilvl, rendering.startOverride);
+	return [...byLevel.entries()].toSorted(([left], [right]) => left - right).map(([ilvl, startOverride]) => ({
+		ilvl,
+		startOverride
+	}));
+};
+/**
+* Define every instance `references` name that `definitions` does not.
+*
+* A reference the editor resolved carries its rendering, and a rendering is
+* what a minted instance leaves behind; a reference without one (a dangling
+* id read from a file) has no rendering and so is never defined here. Returns
+* `definitions` itself when nothing is missing.
+*/
+const completeListNumbering = (definitions, references) => {
+	const definedNums = new Set((definitions?.nums ?? []).map(({ numId }) => numId));
+	const missing = /* @__PURE__ */ new Map();
+	for (const reference of references) {
+		if (definedNums.has(reference.numId)) continue;
+		const group = missing.get(reference.numId);
+		if (group) group.push(reference);
+		else missing.set(reference.numId, [reference]);
+	}
+	if (missing.size === 0) return definitions;
+	const current = definitions ?? EMPTY_DEFINITIONS;
+	const abstractIds = new Set(current.abstractNums.map(({ abstractNumId }) => abstractNumId));
+	const statedAbstractIds = [...missing.values()].flatMap((group) => group.flatMap(({ rendering }) => rendering.abstractNumId === void 0 ? [] : [rendering.abstractNumId]));
+	let freeAbstractId = nextId([...abstractIds, ...statedAbstractIds], 0);
+	const abstractNums = [];
+	const nums = [];
+	for (const [numId, group] of missing) {
+		const abstractNumId = group.find(({ rendering }) => rendering.abstractNumId !== void 0)?.rendering.abstractNumId ?? freeAbstractId++;
+		if (!abstractIds.has(abstractNumId)) {
+			abstractIds.add(abstractNumId);
+			const kind = group.some(({ rendering }) => rendering.isBullet) ? "bullet" : "numbered";
+			abstractNums.push(mintAbstractNumbering({
+				abstractNumId,
+				kind,
+				format: levelZeroFormat(group)
+			}));
+		}
+		const levelOverrides = startOverridesOf(group);
+		nums.push({
+			numId,
+			abstractNumId,
+			...levelOverrides.length > 0 ? { levelOverrides } : {}
+		});
+	}
+	return {
+		...current,
+		abstractNums: [...current.abstractNums, ...abstractNums],
+		nums: [...current.nums, ...nums]
+	};
+};
+//#endregion
+export { LIST_KINDS, completeListNumbering, mintListInstance, restartListInstance };

package/dist/docx/metadataPrivacy.js

@@ -1,3 +1,4 @@
+import { countCentralDirectoryRecords, createInflationBudget, inflateEntryWithinLimits } from "./archiveInflation.js";
 import { elementToXml, getLocalName, parseXmlDocument } from "./xmlParser.js";
 import { TaggedError } from "better-result";
 import JSZip from "jszip";
@@ -63,6 +64,10 @@ const loadPrivacyArchive = async (buffer) => {
 		message: "Document privacy input exceeded the compressed-size limit",
 		reason: "input-too-large"
 	});
+	if (countCentralDirectoryRecords(new Uint8Array(buffer), MAX_ARCHIVE_ENTRIES) > MAX_ARCHIVE_ENTRIES) throw new FolioDocumentPrivacyArchiveError({
+		message: "Document privacy input exceeded the package-entry limit",
+		reason: "too-many-entries"
+	});
 	let zip;
 	try {
 		zip = await JSZip.loadAsync(buffer);
@@ -109,6 +114,24 @@ const rewriteCorePropertiesPrivacy = (xml, transforms) => {
 		removedMetadataProperties: FOLIO_DOCUMENT_METADATA_PROPERTIES.filter((property) => removedPropertySet.has(property))
 	};
 };
+/**
+* Read the core-properties part within its size limit. The declared size was
+* checked when the archive loaded, but only the inflation itself can show that
+* the part is no larger than it claims.
+*/
+const readCoreProperties = async (entry) => {
+	const result = await inflateEntryWithinLimits({
+		entry,
+		maxEntryBytes: MAX_CORE_PROPERTIES_BYTES,
+		maxCompressionRatio: 200,
+		budget: createInflationBudget(MAX_CORE_PROPERTIES_BYTES)
+	});
+	if (!result.ok) throw new FolioDocumentPrivacyArchiveError({
+		message: "Document privacy core properties exceeded the part-size limit",
+		reason: "core-properties-too-large"
+	});
+	return new TextDecoder("utf-8", { ignoreBOM: true }).decode(result.bytes);
+};
 /** Rewrite selected package metadata fields without changing other package parts. */
 const rewriteDocxMetadataPrivacy = async (buffer, { transforms }) => {
 	const appliedTransforms = resolveFolioDocumentPrivacyTransforms(transforms);
@@ -121,7 +144,7 @@ const rewriteDocxMetadataPrivacy = async (buffer, { transforms }) => {
 			removedMetadataProperties: []
 		}
 	};
-	const rewritten = rewriteCorePropertiesPrivacy(await coreProperties.async("text"), appliedTransforms);
+	const rewritten = rewriteCorePropertiesPrivacy(await readCoreProperties(coreProperties), appliedTransforms);
 	if (rewritten.removedMetadataProperties.length === 0) return {
 		buffer,
 		privacyReport: {

package/dist/docx/normalizeBaseDirection.js

@@ -52,7 +52,8 @@ const normalizeCellBlock = (block, styles) => {
 	switch (block.type) {
 		case "paragraph": return normalizeParagraph(block, styles);
 		case "table": return normalizeTable(block, styles);
-		case "blockSdt": return {
+		case "blockSdt":
+		case "blockCustomXml": return {
 			...block,
 			content: block.content.map((child) => normalizeCellBlock(child, styles))
 		};

package/dist/docx/noteReferenceMark.d.ts

@@ -0,0 +1,15 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/docx/noteReferenceMark.d.ts
+type NoteKind = "footnote" | "endnote";
+/** The run carrying a note's in-note reference mark, in the note reference style. */
+declare const noteReferenceMarkRun: (kind: NoteKind) => document_d_exports.Run;
+/**
+ * A note's content with its reference mark run at the start of its first
+ * paragraph, added when the note has none.
+ */
+declare const withNoteReferenceMark: (kind: NoteKind, content: readonly document_d_exports.BlockContent[]) => document_d_exports.BlockContent[];
+/** A new note, as an editor adds one: its content led by its own reference mark. */
+declare function createNote(kind: "footnote", id: number, content: readonly document_d_exports.BlockContent[]): document_d_exports.Footnote;
+declare function createNote(kind: "endnote", id: number, content: readonly document_d_exports.BlockContent[]): document_d_exports.Endnote;
+//#endregion
+export { createNote, noteReferenceMarkRun, withNoteReferenceMark };

package/dist/docx/noteReferenceMark.js

@@ -0,0 +1,48 @@
+import { cloneParagraphWithPropertySource } from "./paragraphPropertySource.js";
+//#region src/docx/noteReferenceMark.ts
+const MARK_ELEMENT = /<(?:[\w.-]+:)?(?:footnote|endnote)Ref[\s/>]/u;
+/** The run carrying a note's in-note reference mark, in the note reference style. */
+const noteReferenceMarkRun = (kind) => ({
+	type: "run",
+	formatting: { styleId: kind === "footnote" ? "FootnoteReference" : "EndnoteReference" },
+	content: [{
+		type: "preservedXml",
+		xml: `<w:${kind}Ref/>`,
+		text: ""
+	}]
+});
+const holdsReferenceMark = (value) => {
+	if (Array.isArray(value)) return value.some(holdsReferenceMark);
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	if (record["type"] === "preservedXml" && typeof record["xml"] === "string") return MARK_ELEMENT.test(record["xml"]);
+	return Object.values(record).some(holdsReferenceMark);
+};
+/**
+* A note's content with its reference mark run at the start of its first
+* paragraph, added when the note has none.
+*/
+const withNoteReferenceMark = (kind, content) => {
+	if (holdsReferenceMark(content)) return [...content];
+	const index = content.findIndex((block) => block.type === "paragraph");
+	const mark = noteReferenceMarkRun(kind);
+	if (index === -1) return [{
+		type: "paragraph",
+		content: [mark]
+	}, ...content];
+	const paragraph = content[index];
+	return content.map((block, position) => position === index ? cloneParagraphWithPropertySource(paragraph, { content: [mark, ...paragraph.content] }) : block);
+};
+function createNote(kind, id, content) {
+	return kind === "footnote" ? {
+		type: "footnote",
+		id,
+		content: withNoteReferenceMark(kind, content)
+	} : {
+		type: "endnote",
+		id,
+		content: withNoteReferenceMark(kind, content)
+	};
+}
+//#endregion
+export { createNote, noteReferenceMarkRun, withNoteReferenceMark };

package/dist/docx/opaqueCarrier.d.ts

@@ -0,0 +1,7 @@
+//#region src/docx/opaqueCarrier.d.ts
+declare const OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC = "[Unsupported block-level tracked-change content]";
+declare const opaqueRevisionCarrierName: (xml: string) => string | undefined;
+declare const countOpaqueRevisionWrappers: (xml: string) => number;
+declare const isOpaqueNestedRowMarkup: (xml: string) => boolean;
+//#endregion
+export { OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC, countOpaqueRevisionWrappers, isOpaqueNestedRowMarkup, opaqueRevisionCarrierName };

package/dist/docx/opaqueCarrier.js

@@ -0,0 +1,38 @@
+import { OOXML_NAMESPACE_SCOPE, WORDPROCESSINGML_NAMESPACE_URIS, getChildElements, getLocalName, parseXml } from "./xmlParser.js";
+//#region src/docx/opaqueCarrier.ts
+const OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC = "[Unsupported block-level tracked-change content]";
+const REVISION_WRAPPERS = /* @__PURE__ */ new Set([
+	"ins",
+	"del",
+	"moveFrom",
+	"moveTo"
+]);
+const opaqueRevisionCarrierName = (xml) => {
+	const visit = (element) => {
+		const localName = getLocalName(element.name);
+		if (WORDPROCESSINGML_NAMESPACE_URIS.has(element.namespaceUri ?? "") && REVISION_WRAPPERS.has(localName)) return `w:${localName}`;
+		for (const child of getChildElements(element)) {
+			const match = visit(child);
+			if (match !== void 0) return match;
+		}
+	};
+	for (const root of getChildElements(parseXml(xml, OOXML_NAMESPACE_SCOPE))) {
+		const match = visit(root);
+		if (match !== void 0) return match;
+	}
+};
+const countOpaqueRevisionWrappers = (xml) => {
+	const count = (element) => {
+		const localName = getLocalName(element.name);
+		let total = WORDPROCESSINGML_NAMESPACE_URIS.has(element.namespaceUri ?? "") && REVISION_WRAPPERS.has(localName) ? 1 : 0;
+		for (const child of getChildElements(element)) total += count(child);
+		return total;
+	};
+	return getChildElements(parseXml(xml, OOXML_NAMESPACE_SCOPE)).reduce((total, element) => total + count(element), 0);
+};
+const isOpaqueNestedRowMarkup = (xml) => {
+	const element = getChildElements(parseXml(xml, OOXML_NAMESPACE_SCOPE)).at(0);
+	return element !== void 0 && getLocalName(element.name) === "tr" && WORDPROCESSINGML_NAMESPACE_URIS.has(element.namespaceUri ?? "");
+};
+//#endregion
+export { OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC, countOpaqueRevisionWrappers, isOpaqueNestedRowMarkup, opaqueRevisionCarrierName };

package/dist/docx/packageParts.js

@@ -58,7 +58,10 @@ const isPresent = (present, partPath) => present.has(normalizePartPath(partPath)
 const relationshipTarget = (element, relsPath) => {
 	if (TARGET_MODE_ATTRIBUTE.exec(element)?.groups?.["value"] === "External") return null;
 	const target = TARGET_ATTRIBUTE.exec(element)?.groups?.["value"];
-	return target === void 0 ? null : resolveRelativePath(relsPath, target);
+	if (target === void 0) return null;
+	const fragment = target.indexOf("#");
+	if (fragment === 0) return owningPartPath(relsPath) ?? "";
+	return resolveRelativePath(relsPath, fragment > 0 ? target.slice(0, fragment) : target);
 };
 /**
 * Every `.rels` part with its text. Read one at a time rather than through