@stll/folio-core 0.62.0 → 0.63.1

package/dist/docx/wmfSvg.js

@@ -0,0 +1,451 @@
+import { assembleMetafileSvg, metafileColorRefToCss, metafileNumberText, transformMetafilePoint } from "./metafileSvgShared.js";
+//#region src/docx/wmfSvg.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.
+*/
+const PLACEABLE_KEY = 2596720087;
+const HEADER_WORDS = 9;
+const MAX_WMF_RECORDS = 1e4;
+const MAX_WMF_POINTS = 2e4;
+const MAX_WMF_DIMENSION = 32768;
+const MAX_WMF_OUTPUT_CHARACTERS = 1e6;
+const MAX_WMF_STATE_DEPTH = 256;
+const MAX_WMF_OBJECTS = 4096;
+const META = {
+	eof: 0,
+	setBkMode: 258,
+	setMapMode: 259,
+	setPolyFillMode: 262,
+	restoreDc: 295,
+	selectObject: 301,
+	setWindowOrg: 523,
+	setWindowExt: 524,
+	setViewportOrg: 525,
+	setViewportExt: 526,
+	lineTo: 531,
+	moveTo: 532,
+	createPenIndirect: 762,
+	createBrushIndirect: 764,
+	deleteObject: 496,
+	polygon: 804,
+	polyline: 805,
+	saveDc: 30,
+	ellipse: 1048,
+	rectangle: 1051,
+	polyPolygon: 1336
+};
+const MAP_MODE_TEXT = 1;
+const MAP_MODE_ISOTROPIC = 7;
+const MAP_MODE_ANISOTROPIC = 8;
+const POLY_FILL_ALTERNATE = 1;
+const POLY_FILL_WINDING = 2;
+const cloneState = (state) => ({
+	...state,
+	origin: { ...state.origin },
+	extent: state.extent ? { ...state.extent } : null,
+	viewportOrigin: { ...state.viewportOrigin },
+	viewportExtent: state.viewportExtent ? { ...state.viewportExtent } : null,
+	current: { ...state.current }
+});
+const word = (view, offset, end) => offset >= 0 && offset + 2 <= end ? view.getUint16(offset, true) : void 0;
+const short = (view, offset, end) => offset >= 0 && offset + 2 <= end ? view.getInt16(offset, true) : void 0;
+const dword = (view, offset, end) => offset >= 0 && offset + 4 <= end ? view.getUint32(offset, true) : void 0;
+const mappedPoint = (state, point) => {
+	if (state.mapMode === MAP_MODE_TEXT) return {
+		x: state.viewportOrigin.x + point.x - state.origin.x,
+		y: state.viewportOrigin.y + point.y - state.origin.y
+	};
+	const extent = state.extent;
+	const viewportExtent = state.viewportExtent;
+	if (!extent || !viewportExtent || extent.x === 0 || extent.y === 0) return void 0;
+	if (state.mapMode === MAP_MODE_ISOTROPIC) {
+		const scale = Math.min(Math.abs(viewportExtent.x / extent.x), Math.abs(viewportExtent.y / extent.y));
+		return {
+			x: state.viewportOrigin.x + (point.x - state.origin.x) * Math.sign(viewportExtent.x / extent.x) * scale,
+			y: state.viewportOrigin.y + (point.y - state.origin.y) * Math.sign(viewportExtent.y / extent.y) * scale
+		};
+	}
+	return transformMetafilePoint({
+		point,
+		windowOrigin: state.origin,
+		windowExtent: extent,
+		viewportOrigin: state.viewportOrigin,
+		viewportExtent,
+		outputOrigin: {
+			x: 0,
+			y: 0
+		},
+		maxCoordinate: MAX_WMF_DIMENSION * 100
+	});
+};
+const mappedPenWidth = (state, pen) => {
+	const width = pen?.width ?? 0;
+	if (width === 0) return 1;
+	if (state.mapMode === MAP_MODE_TEXT) return width;
+	const extent = state.extent;
+	const viewportExtent = state.viewportExtent;
+	if (!extent || !viewportExtent || extent.x === 0 || extent.y === 0) return void 0;
+	const xScale = Math.abs(viewportExtent.x / extent.x);
+	const yScale = Math.abs(viewportExtent.y / extent.y);
+	const mapped = width * (state.mapMode === MAP_MODE_ISOTROPIC ? Math.min(xScale, yScale) : (xScale + yScale) / 2);
+	return Number.isFinite(mapped) ? mapped : void 0;
+};
+const pathPoint = (command, point) => `${command}${metafileNumberText(point.x)} ${metafileNumberText(point.y)}`;
+const paint = (state) => {
+	if (!state.brush && !state.pen) return void 0;
+	const fill = state.brush?.fill ?? "none";
+	const stroke = state.pen?.stroke ?? "none";
+	const width = mappedPenWidth(state, state.pen);
+	if (width === void 0) return void 0;
+	return `fill="${fill}" stroke="${stroke}" stroke-width="${metafileNumberText(width)}"`;
+};
+const readPoint = (view, offset, end) => {
+	const x = short(view, offset, end);
+	const y = short(view, offset + 2, end);
+	return x === void 0 || y === void 0 ? void 0 : {
+		x,
+		y
+	};
+};
+/** Convert the supported WMF vector subset to inert generated SVG. */
+function renderWmfSvg(data) {
+	const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+	if (bytes.byteLength < 18) return null;
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let headerOffset = 0;
+	let placeableOrigin = null;
+	let placeableExtent = null;
+	if (dword(view, 0, bytes.byteLength) === PLACEABLE_KEY) {
+		if (bytes.byteLength < 40) return null;
+		const left = short(view, 6, 22);
+		const top = short(view, 8, 22);
+		const right = short(view, 10, 22);
+		const bottom = short(view, 12, 22);
+		let checksum = 0;
+		for (let offset = 0; offset < 20; offset += 2) checksum ^= view.getUint16(offset, true);
+		if (left === void 0 || top === void 0 || right === void 0 || bottom === void 0 || checksum !== word(view, 20, 22)) return null;
+		placeableOrigin = {
+			x: left,
+			y: top
+		};
+		placeableExtent = {
+			x: right - left,
+			y: bottom - top
+		};
+		headerOffset = 22;
+	}
+	const type = word(view, headerOffset, bytes.byteLength);
+	const headerWords = word(view, headerOffset + 2, bytes.byteLength);
+	const version = word(view, headerOffset + 4, bytes.byteLength);
+	const fileWords = dword(view, headerOffset + 6, bytes.byteLength);
+	const objectCount = word(view, headerOffset + 10, bytes.byteLength);
+	const maxRecordWords = dword(view, headerOffset + 12, bytes.byteLength);
+	const parameterCount = word(view, headerOffset + 16, bytes.byteLength);
+	if (type !== 1 && type !== 2 || headerWords !== HEADER_WORDS || version !== 256 && version !== 768 || fileWords === void 0 || fileWords * 2 !== bytes.byteLength - headerOffset || objectCount === void 0 || objectCount > MAX_WMF_OBJECTS || maxRecordWords === void 0 || maxRecordWords < 3 || maxRecordWords * 2 > bytes.byteLength - headerOffset || parameterCount !== 0) return null;
+	const initialExtent = placeableExtent;
+	if (initialExtent && (initialExtent.x === 0 || initialExtent.y === 0 || Math.abs(initialExtent.x) > MAX_WMF_DIMENSION || Math.abs(initialExtent.y) > MAX_WMF_DIMENSION)) return null;
+	let state = {
+		mapMode: MAP_MODE_TEXT,
+		origin: placeableOrigin ?? {
+			x: 0,
+			y: 0
+		},
+		extent: initialExtent,
+		viewportOrigin: {
+			x: 0,
+			y: 0
+		},
+		viewportExtent: initialExtent ? {
+			x: Math.abs(initialExtent.x),
+			y: Math.abs(initialExtent.y)
+		} : null,
+		current: {
+			x: 0,
+			y: 0
+		},
+		fillRule: "evenodd",
+		pen: {
+			type: "pen",
+			stroke: "#000000",
+			width: 1
+		},
+		brush: {
+			type: "brush",
+			fill: "#ffffff"
+		}
+	};
+	let outputExtent = state.viewportExtent;
+	const stack = [];
+	const objects = [];
+	const output = [];
+	let outputCharacters = 0;
+	let points = 0;
+	let records = 0;
+	let offset = headerOffset + 18;
+	let sawEof = false;
+	const append = (element) => {
+		outputCharacters += element.length;
+		if (outputCharacters > MAX_WMF_OUTPUT_CHARACTERS) return false;
+		output.push(element);
+		return true;
+	};
+	const addPoints = (count) => {
+		if (count <= 0 || count > MAX_WMF_POINTS - points) return false;
+		points += count;
+		return true;
+	};
+	const addObject = (object) => {
+		let handle = objects.indexOf(null);
+		if (handle < 0) handle = objects.length;
+		if (handle >= objectCount || handle >= MAX_WMF_OBJECTS) return false;
+		objects[handle] = object;
+		return true;
+	};
+	while (offset + 6 <= bytes.byteLength) {
+		records += 1;
+		if (records > MAX_WMF_RECORDS) return null;
+		const sizeWords = dword(view, offset, bytes.byteLength);
+		const fn = word(view, offset + 4, bytes.byteLength);
+		if (sizeWords === void 0 || fn === void 0 || sizeWords < 3) return null;
+		const size = sizeWords * 2;
+		if (size > bytes.byteLength - offset || sizeWords > maxRecordWords) return null;
+		const end = offset + size;
+		const params = offset + 6;
+		switch (fn) {
+			case META.eof:
+				if (size !== 6 || end !== bytes.byteLength) return null;
+				sawEof = true;
+				break;
+			case META.setMapMode: {
+				const mode = short(view, params, end);
+				if (size !== 8 || mode !== MAP_MODE_TEXT && mode !== MAP_MODE_ISOTROPIC && mode !== MAP_MODE_ANISOTROPIC) return null;
+				state.mapMode = mode;
+				break;
+			}
+			case META.setBkMode: {
+				const mode = word(view, params, end);
+				if (size !== 8 || mode !== 1 && mode !== 2) return null;
+				break;
+			}
+			case META.setPolyFillMode: {
+				const mode = word(view, params, end);
+				if (size !== 8 || mode !== POLY_FILL_ALTERNATE && mode !== POLY_FILL_WINDING) return null;
+				state.fillRule = mode === POLY_FILL_ALTERNATE ? "evenodd" : "nonzero";
+				break;
+			}
+			case META.setWindowOrg:
+			case META.setWindowExt:
+			case META.setViewportOrg:
+			case META.setViewportExt: {
+				const y = short(view, params, end);
+				const x = short(view, params + 2, end);
+				if (size !== 10 || x === void 0 || y === void 0) return null;
+				if (fn === META.setWindowOrg) state.origin = {
+					x,
+					y
+				};
+				else if (fn === META.setViewportOrg) state.viewportOrigin = {
+					x,
+					y
+				};
+				else {
+					if (x === 0 || y === 0 || Math.abs(x) > MAX_WMF_DIMENSION || Math.abs(y) > MAX_WMF_DIMENSION) return null;
+					if (fn === META.setWindowExt) {
+						state.extent = {
+							x,
+							y
+						};
+						state.viewportExtent ??= {
+							x: Math.abs(x),
+							y: Math.abs(y)
+						};
+					} else state.viewportExtent = {
+						x,
+						y
+					};
+					outputExtent ??= {
+						x: Math.abs(x),
+						y: Math.abs(y)
+					};
+				}
+				break;
+			}
+			case META.saveDc:
+				if (size !== 6 || stack.length >= MAX_WMF_STATE_DEPTH) return null;
+				stack.push(cloneState(state));
+				break;
+			case META.restoreDc: {
+				const relative = short(view, params, end);
+				if (size !== 8 || relative === void 0 || relative >= 0 || -relative > stack.length) return null;
+				let restored;
+				for (let index = 0; index < -relative; index += 1) restored = stack.pop();
+				if (!restored) return null;
+				state = restored;
+				break;
+			}
+			case META.createPenIndirect: {
+				const style = word(view, params, end);
+				const width = short(view, params + 2, end);
+				const widthY = short(view, params + 4, end);
+				const color = dword(view, params + 6, end);
+				if (size !== 16 || style === void 0 || width === void 0 || widthY === void 0 || color === void 0 || widthY !== 0 || (style & 15) > 5) return null;
+				if (!addObject({
+					type: "pen",
+					stroke: (style & 15) === 5 ? null : metafileColorRefToCss(color),
+					width: Math.abs(width)
+				})) return null;
+				break;
+			}
+			case META.createBrushIndirect: {
+				const style = word(view, params, end);
+				const color = dword(view, params + 2, end);
+				const hatch = word(view, params + 6, end);
+				if (size !== 14 || style === void 0 || color === void 0 || hatch === void 0 || style !== 0 && style !== 1) return null;
+				if (!addObject({
+					type: "brush",
+					fill: style === 1 ? null : metafileColorRefToCss(color)
+				})) return null;
+				break;
+			}
+			case META.selectObject: {
+				const handle = word(view, params, end);
+				const object = handle === void 0 ? void 0 : objects[handle];
+				if (size !== 8 || handle === void 0 || !object) return null;
+				if (object.type === "pen") state.pen = object;
+				else state.brush = object;
+				break;
+			}
+			case META.deleteObject: {
+				const handle = word(view, params, end);
+				const object = handle === void 0 ? void 0 : objects[handle];
+				if (size !== 8 || handle === void 0 || !object) return null;
+				if (state.pen === object) state.pen = null;
+				if (state.brush === object) state.brush = null;
+				for (const saved of stack) {
+					if (saved.pen === object) saved.pen = null;
+					if (saved.brush === object) saved.brush = null;
+				}
+				objects[handle] = null;
+				break;
+			}
+			case META.moveTo:
+			case META.lineTo: {
+				const y = short(view, params, end);
+				const x = short(view, params + 2, end);
+				if (size !== 10 || x === void 0 || y === void 0) return null;
+				if (fn === META.lineTo) {
+					const start = mappedPoint(state, state.current);
+					const finish = mappedPoint(state, {
+						x,
+						y
+					});
+					const stroke = state.pen?.stroke;
+					const strokeWidth = mappedPenWidth(state, state.pen);
+					if (!start || !finish || !stroke || strokeWidth === void 0 || !append(`<path d="${pathPoint("M", start)} ${pathPoint("L", finish)}" fill="none" stroke="${stroke}" stroke-width="${metafileNumberText(strokeWidth)}"/>`)) return null;
+				}
+				state.current = {
+					x,
+					y
+				};
+				break;
+			}
+			case META.polygon:
+			case META.polyline: {
+				const count = word(view, params, end);
+				if (count === void 0 || size !== 8 + count * 4 || !addPoints(count)) return null;
+				const commands = [];
+				for (let index = 0; index < count; index += 1) {
+					const point = readPoint(view, params + 2 + index * 4, end);
+					const mapped = point && mappedPoint(state, point);
+					if (!mapped) return null;
+					commands.push(pathPoint(index === 0 ? "M" : "L", mapped));
+				}
+				if (fn === META.polygon) commands.push("Z");
+				const attributes = paint(state);
+				if (!attributes) return null;
+				let shapeAttributes = attributes;
+				if (fn === META.polyline) {
+					const pen = state.pen;
+					if (!pen?.stroke) return null;
+					const strokeWidth = mappedPenWidth(state, pen);
+					if (strokeWidth === void 0) return null;
+					shapeAttributes = `fill="none" stroke="${pen.stroke}" stroke-width="${metafileNumberText(strokeWidth)}"`;
+				} else shapeAttributes += ` fill-rule="${state.fillRule}"`;
+				if (!append(`<path d="${commands.join(" ")}" ${shapeAttributes}/>`)) return null;
+				break;
+			}
+			case META.polyPolygon: {
+				const polygonCount = word(view, params, end);
+				if (polygonCount === void 0 || polygonCount === 0) return null;
+				const pointsStart = params + 2 + polygonCount * 2;
+				if (pointsStart > end) return null;
+				let total = 0;
+				const counts = [];
+				for (let index = 0; index < polygonCount; index += 1) {
+					const count = word(view, params + 2 + index * 2, end);
+					if (count === void 0 || count < 2) return null;
+					counts.push(count);
+					total += count;
+				}
+				if (size !== 8 + polygonCount * 2 + total * 4 || !addPoints(total)) return null;
+				const commands = [];
+				let consumed = 0;
+				for (const count of counts) {
+					for (let index = 0; index < count; index += 1) {
+						const point = readPoint(view, pointsStart + (consumed + index) * 4, end);
+						const mapped = point && mappedPoint(state, point);
+						if (!mapped) return null;
+						commands.push(pathPoint(index === 0 ? "M" : "L", mapped));
+					}
+					commands.push("Z");
+					consumed += count;
+				}
+				const attributes = paint(state);
+				if (!attributes || !append(`<path d="${commands.join(" ")}" ${attributes} fill-rule="${state.fillRule}"/>`)) return null;
+				break;
+			}
+			case META.rectangle:
+			case META.ellipse: {
+				const bottom = short(view, params, end);
+				const right = short(view, params + 2, end);
+				const top = short(view, params + 4, end);
+				const left = short(view, params + 6, end);
+				const first = left === void 0 || top === void 0 ? void 0 : mappedPoint(state, {
+					x: left,
+					y: top
+				});
+				const second = right === void 0 || bottom === void 0 ? void 0 : mappedPoint(state, {
+					x: right,
+					y: bottom
+				});
+				const attributes = paint(state);
+				if (size !== 14 || !first || !second || !attributes) return null;
+				const x = Math.min(first.x, second.x);
+				const y = Math.min(first.y, second.y);
+				const width = Math.abs(second.x - first.x);
+				const height = Math.abs(second.y - first.y);
+				if (width === 0 || height === 0) return null;
+				if (!append(fn === META.rectangle ? `<rect x="${metafileNumberText(x)}" y="${metafileNumberText(y)}" width="${metafileNumberText(width)}" height="${metafileNumberText(height)}" ${attributes}/>` : `<ellipse cx="${metafileNumberText(x + width / 2)}" cy="${metafileNumberText(y + height / 2)}" rx="${metafileNumberText(width / 2)}" ry="${metafileNumberText(height / 2)}" ${attributes}/>`)) return null;
+				break;
+			}
+			default: return null;
+		}
+		offset = end;
+		if (sawEof) break;
+	}
+	if (!sawEof || !outputExtent || output.length === 0) return null;
+	const width = Math.abs(outputExtent.x);
+	const height = Math.abs(outputExtent.y);
+	if (width <= 0 || height <= 0 || width > MAX_WMF_DIMENSION || height > MAX_WMF_DIMENSION) return null;
+	return assembleMetafileSvg({
+		width,
+		height,
+		elements: output,
+		maxCharacters: MAX_WMF_OUTPUT_CHARACTERS
+	});
+}
+//#endregion
+export { renderWmfSvg };

package/dist/docx/wordprocessingPrefixes.d.ts

@@ -17,7 +17,7 @@
  * scope. A prefix conflict on one of those names is refused.
  */
 /** How one part spells the namespaces a string-level patcher scans for. */
-type WordprocessingPrefixes = {
+export type WordprocessingPrefixes = {
   /**
    * Prefixes bound to WordprocessingML (Transitional or Strict), `""` for the
    * default namespace. Never empty: an undeclared part reads as `w`.
@@ -38,16 +38,16 @@ type WordprocessingPrefixes = {
    */
   canonical: boolean;
 };
-type WordprocessingPrefixResolution = {
+export type WordprocessingPrefixResolution = {
   type: "resolved";
   prefixes: WordprocessingPrefixes;
 } | {
   type: "unsupported";
   reason: string;
 };
-declare const resolveWordprocessingPrefixes: (xml: string) => WordprocessingPrefixResolution;
+export declare const resolveWordprocessingPrefixes: (xml: string) => WordprocessingPrefixResolution;
 /** Root spelling for a selective scan whose relevant nested names are checked separately. */
-declare const resolveSelectiveScanPrefixes: (xml: string) => WordprocessingPrefixResolution;
+export declare const resolveSelectiveScanPrefixes: (xml: string) => WordprocessingPrefixResolution;
 /**
  * Whether a patcher that reads `<w:…>` literally sees every element it looks
  * for in `xml`, and may splice the serializer's `w:` markup into it.
@@ -57,22 +57,21 @@ declare const resolveSelectiveScanPrefixes: (xml: string) => WordprocessingPrefi
  * names the patcher scans under that alias, or binds markup compatibility
  * under another prefix. Relevant nested names are checked in their own scope.
  */
-declare const splicesAsCanonical: (xml: string, localNames: readonly string[]) => boolean;
+export declare const splicesAsCanonical: (xml: string, localNames: readonly string[]) => boolean;
 /** The names the paragraph splices scan for: paragraphs, their containers and ids. */
-declare const PARAGRAPH_SCAN_NAMES: readonly ["p", "tc", "txbxContent", "paraId", "textId"];
+export declare const PARAGRAPH_SCAN_NAMES: readonly ["p", "tc", "txbxContent", "paraId", "textId"];
 /** Whether `xml` spells WordprocessingML the way folio's serializer does. */
-declare const hasCanonicalWordprocessingPrefixes: (xml: string) => boolean;
+export declare const hasCanonicalWordprocessingPrefixes: (xml: string) => boolean;
 /** `<p`, `<w:p`, … — the open-tag literal of `localName` under `prefix`. */
-declare const openTagLiteral: (prefix: string, localName: string) => string;
+export declare const openTagLiteral: (prefix: string, localName: string) => string;
 /** `</p>`, `</w:p>`, … — the close-tag literal of `localName` under `prefix`. */
-declare const closeTagLiteral: (prefix: string, localName: string) => string;
+export declare const closeTagLiteral: (prefix: string, localName: string) => string;
 /**
  * Whether `xml` opens `localName` under one of `prefixes` at `start`, and the
  * length of the literal that matched (`-1` when none did). The character after
  * the name must end it, so `<w:pPr` is not `<w:p`.
  */
-declare const matchOpenTag: (xml: string, start: number, prefixes: readonly string[], localName: string) => number;
+export declare const matchOpenTag: (xml: string, start: number, prefixes: readonly string[], localName: string) => number;
 /** The length of the close tag of `localName` under one of `prefixes` at `start`, or -1. */
-declare const matchCloseTag: (xml: string, start: number, prefixes: readonly string[], localName: string) => number;
-//#endregion
-export { PARAGRAPH_SCAN_NAMES, WordprocessingPrefixResolution, WordprocessingPrefixes, closeTagLiteral, hasCanonicalWordprocessingPrefixes, matchCloseTag, matchOpenTag, openTagLiteral, resolveSelectiveScanPrefixes, resolveWordprocessingPrefixes, splicesAsCanonical };
+export declare const matchCloseTag: (xml: string, start: number, prefixes: readonly string[], localName: string) => number;
+//#endregion

package/dist/docx/wrapPolygon.d.ts

@@ -11,7 +11,7 @@ import { document_d_exports } from "../types/document.js";
  * module exists to end. The rectangle is minted only where the alternative is
  * omitting a child the type requires.
  */
-declare const requiredWrapPolygon: (authored: document_d_exports.ImageWrapPolygon | undefined) => document_d_exports.ImageWrapPolygon;
+export declare const requiredWrapPolygon: (authored: document_d_exports.ImageWrapPolygon | undefined) => document_d_exports.ImageWrapPolygon;
 /**
  * The polygon a wrap of `type` has to state, or undefined when its type
  * declares none.
@@ -21,10 +21,9 @@ declare const requiredWrapPolygon: (authored: document_d_exports.ImageWrapPolygo
  * fact of the document the author can see and undo — and every save after that
  * writes back what the model then holds.
  */
-declare const wrapPolygonFor: (type: document_d_exports.ImageWrap["type"], authored: document_d_exports.ImageWrapPolygon | undefined) => document_d_exports.ImageWrapPolygon | undefined;
+export declare const wrapPolygonFor: (type: document_d_exports.ImageWrap["type"], authored: document_d_exports.ImageWrapPolygon | undefined) => document_d_exports.ImageWrapPolygon | undefined;
 /** A copy, deep enough that a ProseMirror attr cannot share a point with the model. */
-declare const copiedWrapPolygon: (polygon: document_d_exports.ImageWrapPolygon | undefined) => document_d_exports.ImageWrapPolygon | undefined;
+export declare const copiedWrapPolygon: (polygon: document_d_exports.ImageWrapPolygon | undefined) => document_d_exports.ImageWrapPolygon | undefined;
 /** `wp:wrapPolygon`, written from a polygon {@link wrapPolygonFor} has approved. */
-declare const serializeWrapPolygon: (polygon: document_d_exports.ImageWrapPolygon) => string;
-//#endregion
-export { copiedWrapPolygon, requiredWrapPolygon, serializeWrapPolygon, wrapPolygonFor };
+export declare const serializeWrapPolygon: (polygon: document_d_exports.ImageWrapPolygon) => string;
+//#endregion

package/dist/docx/wrapTypes.js

@@ -1,2 +1 @@
-import { isFloatingWrapType, isWrapNone, wrapsAroundText } from "../types/wrap.js";
-export { isFloatingWrapType, isWrapNone, wrapsAroundText };
+export { isFloatingWrapType, isWrapNone, wrapsAroundText } from "../types/wrap.js";

package/dist/docx/xmlEncoding.d.ts

@@ -1,5 +1,4 @@
 //#region src/docx/xmlEncoding.d.ts
 /** Decode the UTF-8 and UTF-16 encodings XML processors must recognize. */
-declare const decodeXmlBytes: (bytes: Uint8Array) => string;
-//#endregion
-export { decodeXmlBytes };
+export declare const decodeXmlBytes: (bytes: Uint8Array) => string;
+//#endregion

package/dist/docx/xmlNamespaceContext.d.ts

@@ -1,9 +1,8 @@
 import { XmlElement, XmlNamespaceScope } from "./xmlParser.js";
 //#region src/docx/xmlNamespaceContext.d.ts
-declare const EMPTY_NAMESPACE_SCOPE: XmlNamespaceScope;
-declare const XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace";
-declare const resolveNamespaceUri: (scope: XmlNamespaceScope | undefined, prefix: string) => string | undefined;
+export declare const EMPTY_NAMESPACE_SCOPE: XmlNamespaceScope;
+export declare const XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace";
+export declare const resolveNamespaceUri: (scope: XmlNamespaceScope | undefined, prefix: string) => string | undefined;
 /** Attach the element's resolved namespace metadata from its in-scope declarations. */
-declare const attachXmlNamespaceContext: (element: XmlElement, inheritedNamespaceScope?: XmlNamespaceScope) => XmlNamespaceScope;
-//#endregion
-export { EMPTY_NAMESPACE_SCOPE, XML_NAMESPACE_URI, attachXmlNamespaceContext, resolveNamespaceUri };
+export declare const attachXmlNamespaceContext: (element: XmlElement, inheritedNamespaceScope?: XmlNamespaceScope) => XmlNamespaceScope;
+//#endregion