@stll/folio-core 0.62.0 → 0.63.1

package/dist/docx/trackedMoveRangeNormalization.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/docx/trackedMoveRangeNormalization.d.ts
 /** The code this normalisation is reported under, owned here, not at the caller. */
-declare const UNBALANCED_MOVE_RANGE_WARNING: "unbalanced-move-range";
+export declare const UNBALANCED_MOVE_RANGE_WARNING: "unbalanced-move-range";
 type NormalizeTrackedMoveRangesInput = {
   documentBody: document_d_exports.DocumentBody;
   headers?: Map<string, document_d_exports.HeaderFooter>;
@@ -12,6 +12,6 @@ type NormalizeTrackedMoveRangesInput = {
 type NormalizeTrackedMoveRangesResult = {
   removedUnbalancedMoveRangeMarkers: number;
 };
-declare const normalizeTrackedMoveRanges: ({ documentBody, headers, footers, footnotes, endnotes }: NormalizeTrackedMoveRangesInput) => NormalizeTrackedMoveRangesResult;
+export declare const normalizeTrackedMoveRanges: ({ documentBody, headers, footers, footnotes, endnotes }: NormalizeTrackedMoveRangesInput) => NormalizeTrackedMoveRangesResult;
 //#endregion
-export { UNBALANCED_MOVE_RANGE_WARNING, normalizeTrackedMoveRanges };
+export {};

package/dist/docx/trackedMoveRangeNormalization.js

@@ -1,26 +1,29 @@
+import { buildSections } from "./documentParser.js";
 import { InlineContentRemovals } from "./inlineContentRemovals.js";
-import { visitDocxParagraphs, visitInlineContentSlots } from "./paragraphTraversal.js";
+import { visitDocxContentSlots } from "./paragraphTraversal.js";
+import { panic } from "better-result";
 import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
 //#region src/docx/trackedMoveRangeNormalization.ts
 /** The code this normalisation is reported under, owned here, not at the caller. */
 const UNBALANCED_MOVE_RANGE_WARNING = PARSE_WARNING_CODES.unbalancedMoveRange;
 const normalizeTrackedMoveRanges = ({ documentBody, headers, footers, footnotes, endnotes }) => {
 	const rangeMarkers = [];
-	visitDocxParagraphs({
+	visitDocxContentSlots({
 		documentBody,
 		headers,
 		footers,
 		footnotes,
 		endnotes
-	}, (paragraph) => {
-		visitInlineContentSlots(paragraph, ({ content, index, item }) => {
-			const marker = toMoveRangeMarkerRef(content, index, item);
-			if (marker) rangeMarkers.push(marker);
-		});
+	}, (slot) => {
+		const marker = toMoveRangeMarkerRef(slot);
+		if (marker) rangeMarkers.push(marker);
+	});
+	return removeUnbalancedMoveRangeMarkers({
+		rangeMarkers,
+		documentBody
 	});
-	return { removedUnbalancedMoveRangeMarkers: removeUnbalancedMoveRangeMarkers(rangeMarkers) };
 };
-const removeUnbalancedMoveRangeMarkers = (rangeMarkers) => {
+const removeUnbalancedMoveRangeMarkers = ({ rangeMarkers, documentBody }) => {
 	const byRange = /* @__PURE__ */ new Map();
 	for (const marker of rangeMarkers) {
 		const key = `${marker.kind}:${marker.id}`;
@@ -32,8 +35,23 @@ const removeUnbalancedMoveRangeMarkers = (rangeMarkers) => {
 		byRange.set(key, [marker]);
 	}
 	const removals = new InlineContentRemovals();
-	const markForRemoval = (marker) => {
-		removals.mark(marker);
+	const blockRemovals = /* @__PURE__ */ new Map();
+	const markForRemoval = ({ slot }) => {
+		switch (slot.type) {
+			case "inline":
+				removals.mark(slot);
+				return;
+			case "block": {
+				const indexes = blockRemovals.get(slot.content);
+				if (indexes) {
+					indexes.add(slot.index);
+					return;
+				}
+				blockRemovals.set(slot.content, /* @__PURE__ */ new Set([slot.index]));
+				return;
+			}
+			default: panic(`Unsupported move range ownership: ${JSON.stringify(slot)}`);
+		}
 	};
 	for (const markers of byRange.values()) {
 		let openStart = null;
@@ -54,33 +72,46 @@ const removeUnbalancedMoveRangeMarkers = (rangeMarkers) => {
 		}
 		if (openStart) markForRemoval(openStart);
 	}
-	return removals.apply();
+	let removedUnbalancedMoveRangeMarkers = removals.apply();
+	for (const [content, indexes] of blockRemovals) {
+		const kept = content.filter((_, index) => !indexes.has(index));
+		removedUnbalancedMoveRangeMarkers += content.length - kept.length;
+		content.length = 0;
+		content.push(...kept);
+	}
+	if (blockRemovals.has(documentBody.content) && documentBody.sections) {
+		const rebuiltSections = buildSections(documentBody.content, documentBody.finalSectionProperties);
+		if (rebuiltSections.length !== documentBody.sections.length) panic("Removing move range markers changed the document section count");
+		for (const [index, section] of documentBody.sections.entries()) {
+			const rebuilt = rebuiltSections.at(index);
+			if (!rebuilt) panic("Missing rebuilt section after move range normalization");
+			section.content = rebuilt.content;
+		}
+	}
+	return { removedUnbalancedMoveRangeMarkers };
 };
-const toMoveRangeMarkerRef = (content, index, marker) => {
+const toMoveRangeMarkerRef = (slot) => {
+	const marker = slot.item;
 	if (marker.type === "moveFromRangeStart") return {
-		content,
-		index,
+		slot,
 		id: marker.id,
 		kind: "moveFrom",
 		side: "start"
 	};
 	if (marker.type === "moveFromRangeEnd") return {
-		content,
-		index,
+		slot,
 		id: marker.id,
 		kind: "moveFrom",
 		side: "end"
 	};
 	if (marker.type === "moveToRangeStart") return {
-		content,
-		index,
+		slot,
 		id: marker.id,
 		kind: "moveTo",
 		side: "start"
 	};
 	if (marker.type === "moveToRangeEnd") return {
-		content,
-		index,
+		slot,
 		id: marker.id,
 		kind: "moveTo",
 		side: "end"

package/dist/docx/transitionalSpelling.d.ts

@@ -7,13 +7,13 @@ import { PercentUnit, SlotEncoding } from "./strictValueEncodings.gen.js";
  * declaring a Strict URI on a Transitional root puts every element under that
  * prefix back into the wrong vocabulary.
  */
-declare const toTransitionalNamespaceUri: (uri: string) => string;
+export declare const toTransitionalNamespaceUri: (uri: string) => string;
 /** True for a namespace ECMA-376 Part 4 republished under `purl.oclc.org`. */
-declare const isStrictNamespaceUri: (uri: string) => boolean;
+export declare const isStrictNamespaceUri: (uri: string) => boolean;
 /** Namespaces ECMA-376 Part 4 republished; nothing else starts with this. */
-declare const STRICT_URI_PREFIX = "http://purl.oclc.org/ooxml/";
+export declare const STRICT_URI_PREFIX = "http://purl.oclc.org/ooxml/";
 /** How many of a unit's numbers make one whole percent. */
-declare const NUMBERS_PER_PERCENT: Readonly<Record<PercentUnit, number>>;
+export declare const NUMBERS_PER_PERCENT: Readonly<Record<PercentUnit, number>>;
 /**
  * The percent a value spells out, or undefined when it is not spelled as one.
  *
@@ -22,13 +22,12 @@ declare const NUMBERS_PER_PERCENT: Readonly<Record<PercentUnit, number>>;
  * verbatim-capture conversion, and `CT_TblWidth`, whose `w:type` is optional —
  * ask here rather than testing for a `%` themselves.
  */
-declare const percentageSpelling: (value: string) => number | undefined;
+export declare const percentageSpelling: (value: string) => number | undefined;
 /**
  * How one slot's Transitional type spells its value as a number.
  *
  * `namespaceUri` is the element's, in either conformance class; the lookup
  * translates it. Omit `attributeLocalName` for element text content.
  */
-declare const transitionalSlotEncoding: (namespaceUri: string | undefined, elementLocalName: string, attributeLocalName?: string) => SlotEncoding | undefined;
-//#endregion
-export { NUMBERS_PER_PERCENT, STRICT_URI_PREFIX, isStrictNamespaceUri, percentageSpelling, toTransitionalNamespaceUri, transitionalSlotEncoding };
+export declare const transitionalSlotEncoding: (namespaceUri: string | undefined, elementLocalName: string, attributeLocalName?: string) => SlotEncoding | undefined;
+//#endregion

package/dist/docx/universalMeasure.d.ts

@@ -9,12 +9,11 @@
  * what one of those strings is worth. They share this module so they cannot.
  */
 /** The unit a Transitional attribute's number is counted in. */
-type MeasureUnit = "emu" | "halfPoints" | "hundredthPoints" | "twips";
+export type MeasureUnit = "emu" | "halfPoints" | "hundredthPoints" | "twips";
 /** Round half away from zero, so a negative offset keeps a positive one's magnitude. */
-declare const roundHalfAwayFromZero: (value: number) => number;
+export declare const roundHalfAwayFromZero: (value: number) => number;
 /** The value of a universal measure in points, or `undefined` if it is not one. */
-declare const universalMeasureInPoints: (value: string) => number | undefined;
+export declare const universalMeasureInPoints: (value: string) => number | undefined;
 /** A universal measure as the whole number a Transitional attribute of `unit` holds. */
-declare const universalMeasureAs: (value: string, unit: MeasureUnit) => number | undefined;
-//#endregion
-export { MeasureUnit, roundHalfAwayFromZero, universalMeasureAs, universalMeasureInPoints };
+export declare const universalMeasureAs: (value: string, unit: MeasureUnit) => number | undefined;
+//#endregion

package/dist/docx/unzip.d.ts

@@ -1,9 +1,9 @@
 import JSZip from "jszip";
 //#region src/docx/unzip.d.ts
-declare class DocxSecurityError extends Error {
+export declare class DocxSecurityError extends Error {
   constructor(message: string);
 }
-type DocxUnzipLimits = {
+export type DocxUnzipLimits = {
   maxInputBytes: number;
   maxFiles: number;
   /**
@@ -42,7 +42,7 @@ type DocxUnzipLimits = {
   maxXmlAttributesPerPackage: number;
   allowedMediaMimeTypes: ReadonlySet<string>;
 };
-type DocxUnzipOptions = Partial<Omit<DocxUnzipLimits, "allowedMediaMimeTypes">> & {
+export type DocxUnzipOptions = Partial<Omit<DocxUnzipLimits, "allowedMediaMimeTypes">> & {
   allowedMediaMimeTypes?: Iterable<string>;
   /** Extract every XML part into allXml instead of only parts used by the parser. */
   extractAllXml?: boolean;
@@ -52,7 +52,7 @@ type DocxUnzipOptions = Partial<Omit<DocxUnzipLimits, "allowedMediaMimeTypes">>
 /**
  * Raw extracted content from a DOCX file
  */
-type RawDocxContent = {
+export type RawDocxContent = {
   documentXml: string | null;
   stylesXml: string | null;
   themeXml: string | null;
@@ -83,7 +83,7 @@ type RawDocxContent = {
   wasEncrypted: boolean;
 };
 /** How {@link unzipDocx} treats the parts it does not extract. */
-type UnzipDocxBehavior = {
+export type UnzipDocxBehavior = {
   /**
    * Inflate every part the unzip does not extract, within its declared size,
    * so a later read of the returned package can trust that size. Callers
@@ -98,24 +98,24 @@ type UnzipDocxBehavior = {
  * @param buffer - DOCX file as ArrayBuffer
  * @returns Promise resolving to extracted content
  */
-declare function unzipDocx(buffer: ArrayBuffer, options?: DocxUnzipOptions, { verifyUnreadEntries }?: UnzipDocxBehavior): Promise<RawDocxContent>;
+export declare function unzipDocx(buffer: ArrayBuffer, options?: DocxUnzipOptions, { verifyUnreadEntries }?: UnzipDocxBehavior): Promise<RawDocxContent>;
 /** Keep extracted projections and the source ZIP aligned after parser normalization. */
-declare const replaceRawDocxXmlParts: (content: RawDocxContent, parts: ReadonlyMap<string, string>) => Promise<void>;
-declare function getEntryUncompressedSize(file: JSZip.JSZipObject): number | null;
+export declare const replaceRawDocxXmlParts: (content: RawDocxContent, parts: ReadonlyMap<string, string>) => Promise<void>;
+export declare function getEntryUncompressedSize(file: JSZip.JSZipObject): number | null;
 /**
  * Get a list of all files in the DOCX
  *
  * @param content - Extracted DOCX content
  * @returns Array of file paths
  */
-declare function getFileList(content: RawDocxContent): string[];
+export declare function getFileList(content: RawDocxContent): string[];
 /**
  * Get the MIME type for a media file based on extension
  *
  * @param path - File path
  * @returns MIME type string
  */
-declare function getMediaMimeType(path: string): string;
+export declare function getMediaMimeType(path: string): string;
 /**
  * Convert media file to data URL
  *
@@ -123,7 +123,7 @@ declare function getMediaMimeType(path: string): string;
  * @param mimeType - MIME type
  * @returns Data URL string
  */
-declare function mediaToDataUrl(data: ArrayBuffer, mimeType: string): string;
+export declare function mediaToDataUrl(data: ArrayBuffer, mimeType: string): string;
 /**
  * Extract a specific file from the original ZIP
  *
@@ -131,7 +131,7 @@ declare function mediaToDataUrl(data: ArrayBuffer, mimeType: string): string;
  * @param path - File path within the ZIP
  * @returns File content as string or ArrayBuffer, or null if not found
  */
-declare function extractFile(content: RawDocxContent, path: string): Promise<string | ArrayBuffer | null>;
+export declare function extractFile(content: RawDocxContent, path: string): Promise<string | ArrayBuffer | null>;
 /**
  * Check if a file exists in the DOCX
  *
@@ -139,14 +139,14 @@ declare function extractFile(content: RawDocxContent, path: string): Promise<str
  * @param path - File path to check
  * @returns true if file exists
  */
-declare function hasFile(content: RawDocxContent, path: string): boolean;
+export declare function hasFile(content: RawDocxContent, path: string): boolean;
 /**
  * Get summary of DOCX content
  *
  * @param content - Extracted DOCX content
  * @returns Object with file counts and presence flags
  */
-declare function getContentSummary(content: RawDocxContent): {
+export declare function getContentSummary(content: RawDocxContent): {
   hasDocument: boolean;
   hasStyles: boolean;
   hasTheme: boolean;
@@ -161,5 +161,4 @@ declare function getContentSummary(content: RawDocxContent): {
   fontCount: number;
   totalFiles: number;
 };
-//#endregion
-export { DocxSecurityError, DocxUnzipLimits, DocxUnzipOptions, RawDocxContent, UnzipDocxBehavior, extractFile, getContentSummary, getEntryUncompressedSize, getFileList, getMediaMimeType, hasFile, mediaToDataUrl, replaceRawDocxXmlParts, unzipDocx };
+//#endregion

package/dist/docx/unzip.js

@@ -6,8 +6,8 @@ import { openDocxBuffer } from "./encryption/openEncryptedDocx.js";
 import { RASTER_MIME_TYPES, detectRasterMimeType } from "./rasterMime.js";
 import { decodeXmlBytes } from "./xmlEncoding.js";
 import { FOLIO_XML_RESOURCE_LIMITS, assertXmlResourceLimits, createXmlPackageBudget } from "./xmlResourceLimits.js";
-import { writeZipPart } from "@stll/docx-core/zip";
 import JSZip from "jszip";
+import { writeZipPart } from "@stll/docx-core/zip";
 //#region src/docx/unzip.ts
 /**
 * DOCX Unzipper
@@ -51,7 +51,7 @@ const PRESERVABLE_MEDIA_MIME_TYPES = /* @__PURE__ */ new Set([
 	"image/x-wmf",
 	"image/x-emf"
 ]);
-const MEBIBYTE = 1024 * 1024;
+const MEBIBYTE = 1048576;
 const DEFAULT_UNZIP_LIMITS = {
 	maxInputBytes: 50 * MEBIBYTE,
 	maxFiles: 5e3,

package/dist/docx/verbatimCapture.d.ts

@@ -1,13 +1,14 @@
 import { document_d_exports } from "../types/document.js";
 import { XmlElement, XmlNamespaceScope } from "./xmlParser.js";
+import { TaggedErrorClass } from "better-result";
 //#region src/docx/verbatimCapture.d.ts
-declare const UntranslatableStrictNamespaceError_base: import("better-result").TaggedErrorClass<"UntranslatableStrictNamespaceError">;
+declare const UntranslatableStrictNamespaceErrorBase: TaggedErrorClass<"UntranslatableStrictNamespaceError">;
 /** A Strict fragment uses a namespace that has no Transitional counterpart. */
-declare class UntranslatableStrictNamespaceError extends UntranslatableStrictNamespaceError_base<{
+export declare class UntranslatableStrictNamespaceError extends UntranslatableStrictNamespaceErrorBase<{
   message: string;
   uri: string;
 }> {}
-declare const captureVerbatimXml: (element: XmlElement) => string;
+export declare const captureVerbatimXml: (element: XmlElement) => string;
 type SanitizeCapturedXmlOptions = {
   allowedLocalNames: ReadonlySet<string>;
   allowedNamespaceUris: ReadonlySet<string>;
@@ -17,7 +18,7 @@ type SanitizeCapturedXmlOptions = {
   validate?: (element: XmlElement) => boolean;
 };
 /** Validate a complete XML part immediately before package output. */
-declare const isSafeCapturedXmlDocument: (xml: string) => boolean;
+export declare const isSafeCapturedXmlDocument: (xml: string) => boolean;
 /**
  * {@link sanitizeCapturedXmlElement} over fixed options, memoized by source
  * string.
@@ -29,7 +30,7 @@ declare const isSafeCapturedXmlDocument: (xml: string) => boolean;
  * string they carry is the one the parser produced. `transform` and `validate`
  * must therefore depend on nothing but the element they are given.
  */
-declare const createCapturedXmlSanitizer: (options: SanitizeCapturedXmlOptions) => ((xml: string | undefined) => string | null);
-declare const captureSourceProfileXml: (element: XmlElement, conformance: document_d_exports.DocxConformanceClass | undefined) => string;
+export declare const createCapturedXmlSanitizer: (options: SanitizeCapturedXmlOptions) => ((xml: string | undefined) => string | null);
+export declare const captureSourceProfileXml: (element: XmlElement, conformance: document_d_exports.DocxConformanceClass | undefined) => string;
 //#endregion
-export { UntranslatableStrictNamespaceError, captureSourceProfileXml, captureVerbatimXml, createCapturedXmlSanitizer, isSafeCapturedXmlDocument };
+export {};

package/dist/docx/verbatimCapture.js

@@ -24,8 +24,9 @@ import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
 * to know: {@link captureVerbatimXml} is the only producer of replayed markup,
 * and a fragment that carries no Strict namespace passes through byte for byte.
 */
+const UntranslatableStrictNamespaceErrorBase = TaggedError("UntranslatableStrictNamespaceError");
 /** A Strict fragment uses a namespace that has no Transitional counterpart. */
-var UntranslatableStrictNamespaceError = class extends TaggedError("UntranslatableStrictNamespaceError") {};
+var UntranslatableStrictNamespaceError = class extends UntranslatableStrictNamespaceErrorBase {};
 const TRANSITIONAL_URIS = new Set(TRANSITIONAL_NAMESPACE_BY_STRICT_URI.values());
 const XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace";
 const XMLNS_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/";
@@ -249,7 +250,8 @@ const hasBoundNamespaces = (root) => {
 			}
 			const prefix = getNamespacePrefix(name);
 			if (prefix === "xmlns" || prefix !== null && prefix !== "xml" && resolveNamespaceBinding(element.namespaceScope, prefix) === void 0) return false;
-			const expandedName = `${toTransitionalNamespaceUri((prefix === null ? "" : resolveNamespaceBinding(element.namespaceScope, prefix)) ?? "")}\u0000${getLocalName(name)}`;
+			const attributeNamespace = prefix === null ? "" : resolveNamespaceBinding(element.namespaceScope, prefix);
+			const expandedName = `${toTransitionalNamespaceUri(attributeNamespace ?? "")}\u0000${getLocalName(name)}`;
 			if (expandedAttributeNames.has(expandedName)) return false;
 			expandedAttributeNames.add(expandedName);
 			if (referencedNamespacePrefixes(element, name, value) === null) return false;
@@ -333,7 +335,7 @@ const sanitizeCapturedXmlElement = (xml, options) => {
 * capture is a few hundred characters, so this holds every distinct capture of
 * a large document while bounding what outlives the documents it came from.
 */
-const CAPTURED_XML_SANITIZER_CACHE_CHARACTERS = 2 * 1024 * 1024;
+const CAPTURED_XML_SANITIZER_CACHE_CHARACTERS = 2097152;
 /**
 * What one cache entry costs beyond its strings, in characters. Charging it
 * keeps many short keys from holding far more memory than their text, and

package/dist/docx/verticalMergeProjection.d.ts

@@ -1,17 +1,16 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/docx/verticalMergeProjection.d.ts
 /** The reader and revision resolver share which continuation cells remain visible. */
-type RowSpanInfo = {
+export type RowSpanInfo = {
   rowSpan: number;
   skip: boolean;
   preserveVMergeRestart?: boolean;
   continuationCells?: document_d_exports.TableCell[];
 };
-declare function calculateRowSpans(table: document_d_exports.Table): Map<string, RowSpanInfo>;
+export declare function calculateRowSpans(table: document_d_exports.Table): Map<string, RowSpanInfo>;
 /**
  * Whether a cell carries content a vertical-merge continuation must not hide.
  * The reader keeps such a continuation as a cell of its own.
  */
-declare function tableCellHasMeaningfulContent(cell: document_d_exports.TableCell): boolean;
-//#endregion
-export { RowSpanInfo, calculateRowSpans, tableCellHasMeaningfulContent };
+export declare function tableCellHasMeaningfulContent(cell: document_d_exports.TableCell): boolean;
+//#endregion

package/dist/docx/verticalMergeProjection.js

@@ -105,7 +105,7 @@ function tableCellHasMeaningfulContent(cell) {
 }
 function blockHasMeaningfulContent(block) {
 	if (block.type === "preservedBlock") return true;
-	if (block.type === "bookmarkStart" || block.type === "bookmarkEnd") return true;
+	if (block.type === "bookmarkStart" || block.type === "bookmarkEnd" || block.type === "moveFromRangeStart" || block.type === "moveFromRangeEnd" || block.type === "moveToRangeStart" || block.type === "moveToRangeEnd") return true;
 	if (block.type === "table") return block.rows.some((row) => row.cells.some((cell) => tableCellHasMeaningfulContent(cell)));
 	if (block.type === "blockSdt" || block.type === "blockCustomXml") return true;
 	return block.content.some(paragraphContentHasMeaningfulContent);

package/dist/docx/vmlImageParser.d.ts

@@ -20,7 +20,7 @@ import { PreviewLedger } from "./previewBudget.js";
  * watermark owner removes its own artwork from the model instead, by emptying
  * the paragraph it detached, so this predicate need not guess who claimed what.
  */
-declare function shouldPreserveRawVmlPict(pictElement: XmlElement): boolean;
+export declare function shouldPreserveRawVmlPict(pictElement: XmlElement): boolean;
 /**
  * Parse a `w:pict` element into an inline image, or null when it carries no
  * ordinary VML picture (no resolvable `<v:imagedata>`, or a watermark shape).
@@ -30,7 +30,7 @@ declare function shouldPreserveRawVmlPict(pictElement: XmlElement): boolean;
  * when the producer bound WordprocessingML / relationship / VML namespaces to
  * non-canonical prefixes the serializer's root does not declare.
  */
-declare function parseVmlImageContent(pictElement: XmlElement, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null, previews: PreviewLedger, rootXmlns?: Record<string, string>): document_d_exports.DrawingContent | null;
+export declare function parseVmlImageContent(pictElement: XmlElement, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null, previews: PreviewLedger, rootXmlns?: Record<string, string>): document_d_exports.DrawingContent | null;
 /**
  * Whether the run parser turns this `w:pict` into run content of its own.
  *
@@ -47,6 +47,5 @@ declare function parseVmlImageContent(pictElement: XmlElement, rels: document_d_
  * either result: a preview built here would be registered against the package
  * budget for a drawing the model never holds.
  */
-declare const isVmlPictParsedByRunParser: (pictElement: XmlElement, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null) => boolean;
-//#endregion
-export { isVmlPictParsedByRunParser, parseVmlImageContent, shouldPreserveRawVmlPict };
+export declare const isVmlPictParsedByRunParser: (pictElement: XmlElement, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null) => boolean;
+//#endregion

package/dist/docx/vmlPreview.d.ts

@@ -1,6 +1,6 @@
 import { XmlElement } from "./xmlParser.js";
 //#region src/docx/vmlPreview.d.ts
-type VmlPreviewResult = {
+export type VmlPreviewResult = {
   type: "rendered";
   svg: string;
   widthPx: number;
@@ -12,18 +12,17 @@ type VmlPreviewResult = {
   type: "invalid";
 };
 /** Parse a VML/CSS length into CSS pixels without accepting partial numbers. */
-declare const vmlCssLengthToPx: (raw: string | undefined) => number | undefined;
+export declare const vmlCssLengthToPx: (raw: string | undefined) => number | undefined;
 /** Read a VML `style` attribute into a prototype-free lowercased record. */
-declare const parseVmlStyle: (style: string | null) => Record<string, string>;
+export declare const parseVmlStyle: (style: string | null) => Record<string, string>;
 /** Parse a finite VML number without exponent or partial-number coercion. */
-declare const parseVmlNumber: (raw: string | null | undefined) => number | undefined;
+export declare const parseVmlNumber: (raw: string | null | undefined) => number | undefined;
 /** Check a physical preview dimension against the retained SVG layout bound. */
-declare const isValidVmlPreviewDimension: (value: number | undefined) => value is number;
+export declare const isValidVmlPreviewDimension: (value: number | undefined) => value is number;
 /** Whether a generated, already-sanitized SVG is within the output cap a preview may retain. */
-declare const fitsVmlSvgCap: (svg: string) => boolean;
+export declare const fitsVmlSvgCap: (svg: string) => boolean;
 /** Render a bounded standalone VML rectangle or oval preview. */
-declare const renderStandaloneVmlPreview: (shape: XmlElement) => VmlPreviewResult;
+export declare const renderStandaloneVmlPreview: (shape: XmlElement) => VmlPreviewResult;
 /** Render a VML group through bounded, non-clipping local-coordinate transforms. */
-declare const renderVmlGroupPreview: (group: XmlElement) => VmlPreviewResult;
-//#endregion
-export { VmlPreviewResult, fitsVmlSvgCap, isValidVmlPreviewDimension, parseVmlNumber, parseVmlStyle, renderStandaloneVmlPreview, renderVmlGroupPreview, vmlCssLengthToPx };
+export declare const renderVmlGroupPreview: (group: XmlElement) => VmlPreviewResult;
+//#endregion

package/dist/docx/vmlPreview.js

@@ -316,8 +316,6 @@ const renderVmlPath = (raw, budget) => {
 					type: "between-sets",
 					pathSets: state.pathSets
 				};
-				break;
-			default:
 		}
 	}
 	switch (state.type) {
@@ -440,7 +438,6 @@ const renderGroupChildren = (group, budget, depth) => {
 				break;
 			case "empty": break;
 			case "invalid": return INVALID_RESULT;
-			default:
 		}
 	}
 	return fragments.length > 0 ? {

package/dist/docx/watermarkParser.d.ts

@@ -8,7 +8,7 @@ import { XmlElement } from "./xmlParser.js";
  * round-trips byte-exact), and a reference to that hosting paragraph
  * so the regular body parser can skip it.
  */
-type ParsedWatermark = {
+export type ParsedWatermark = {
   watermark: document_d_exports.Watermark;
   rawParagraphXml: string;
   hostingParagraph: XmlElement;
@@ -26,7 +26,7 @@ type ParsedWatermark = {
  * leave watermark shapes to this module, so a header watermark is not also
  * rendered as an inline picture.
  */
-declare function isWatermarkShape(shape: XmlElement): boolean;
+export declare function isWatermarkShape(shape: XmlElement): boolean;
 /**
  * Walk a parsed `<w:hdr>` element and return the watermark it carries,
  * or `undefined` when none is present. Scans every candidate shape /
@@ -37,6 +37,5 @@ declare function isWatermarkShape(shape: XmlElement): boolean;
  * paragraph (so the serializer can replay it byte-exact), and a
  * reference to that paragraph so the regular body parser can skip it.
  */
-declare function parseWatermark(header: XmlElement): ParsedWatermark | undefined;
-//#endregion
-export { ParsedWatermark, isWatermarkShape, parseWatermark };
+export declare function parseWatermark(header: XmlElement): ParsedWatermark | undefined;
+//#endregion

package/dist/docx/wmfSvg.d.ts

@@ -0,0 +1,10 @@
+//#region src/docx/wmfSvg.d.ts
+/**
+ * Render a deliberately small, browser-safe WMF subset to generated SVG.
+ *
+ * Minified bundle cost (measured with `bun build --minify`): 7,002 bytes.
+ * Unsupported records fail closed; original WMF bytes remain authoritative.
+ */
+/** Convert the supported WMF vector subset to inert generated SVG. */
+export declare function renderWmfSvg(data: ArrayBuffer | Uint8Array): string | null;
+//#endregion