@stll/folio-core 0.15.0 → 0.15.2

package/dist/docx/server/inspectDocxPackage.d.ts

@@ -1,5 +1,4 @@
 import { DocxArchiveOptions } from "./boundedArchive.js";
-
 //#region src/docx/server/inspectDocxPackage.d.ts
 declare const FOLIO_DOCX_PACKAGE_INSPECTION_VERSION: 1;
 declare const FOLIO_DOCX_PACKAGE_INSPECTION_DEFAULTS: Readonly<{
@@ -37,7 +36,8 @@ type FolioDocxInspectedXmlPart = {
   readonly path: string;
   readonly contentType: string | null;
   readonly byteLength: number;
-  readonly sha256: string; /** Untrusted document data; callers must not treat this text as instructions. */
+  readonly sha256: string;
+  /** Untrusted document data; callers must not treat this text as instructions. */
   readonly text: string;
 };
 type FolioDocxPackageInspection = {
@@ -54,12 +54,7 @@ type ReadRequestedXmlPartsOptions = {
     maxBytes: number;
   }) => Promise<Uint8Array | null>;
 };
-declare const readRequestedXmlParts: ({
-  paths,
-  partsByPath,
-  limits,
-  readEntryUint8
-}: ReadRequestedXmlPartsOptions) => Promise<FolioDocxInspectedXmlPart[]>;
+declare const readRequestedXmlParts: ({ paths, partsByPath, limits, readEntryUint8 }: ReadRequestedXmlPartsOptions) => Promise<FolioDocxInspectedXmlPart[]>;
 /**
  * Inspect package metadata and only the explicitly requested XML part bodies.
  * This reports archive contents, not package conformance; use the conformance

package/dist/docx/server/validateDocxConformance.d.ts

@@ -1,6 +1,5 @@
 import { document_d_exports } from "../../types/document.js";
 import { DocxArchiveOptions } from "./boundedArchive.js";
-
 //#region src/docx/server/validateDocxConformance.d.ts
 declare const FOLIO_DOCX_CONFORMANCE_REPORT_VERSION: 1;
 declare const FOLIO_DOCX_CONFORMANCE_PROFILE: "folio-supported-v1";

package/dist/docx/settingsParser.d.ts

@@ -1,8 +1,8 @@
 import { document_d_exports } from "../types/document.js";
-
 //#region src/docx/settingsParser.d.ts
 type FolioDocumentSettings = document_d_exports.DocumentSettings & {
-  /** Swap left/right section margins on even physical pages. */mirrorMargins?: boolean;
+  /** Swap left/right section margins on even physical pages. */
+  mirrorMargins?: boolean;
 };
 /** OOXML default per §17.6.13 when `w:defaultTabStop` is absent. */
 declare const DEFAULT_TAB_STOP_TWIPS = 720;

package/dist/docx/shapeParser.d.ts

@@ -1,6 +1,5 @@
 import { document_d_exports } from "../types/document.js";
 import { XmlElement } from "./xmlParser.js";
-
 //#region src/docx/shapeParser.d.ts
 /**
  * Parse a `<wps:wsp>` element into a Shape model. Does NOT pick up the

package/dist/docx/shapeParser.js

@@ -1,6 +1,6 @@
-import { ShapeOutlineStyleSchema, ShapeTypeSchema, narrowEnum } from "./parserEnums.js";
-import { findAllDeep, findChildByLocalName, findChildrenByLocalName, getAttribute, parseNumericAttribute } from "./xmlParser.js";
-import { parseAnchorPosition, parseAnchorWrap, parseColorElement, parseFill } from "./drawingUtils.js";
+import { ShapeTypeSchema, narrowEnum } from "./parserEnums.js";
+import { findAllDeep, findChildByLocalName, getAttribute, parseNumericAttribute } from "./xmlParser.js";
+import { parseAnchorPosition, parseAnchorWrap, parseFill, parseOutline } from "./drawingUtils.js";
 //#region src/docx/shapeParser.ts
 /** Convert OOXML rotation (1/60000ths of a degree) to degrees. */
 function rotToDegrees(rot) {
@@ -13,115 +13,7 @@ function rotToDegrees(rot) {
 * Falls through to `drawingUtils.parseFill` for solid / none cases.
 */
 function parseShapeFill(spPr) {
-	const base = parseFill(spPr);
-	if (base?.type !== "gradient" || !spPr) return base;
-	const gradFill = findChildByLocalName(spPr, "gradFill");
-	if (!gradFill) return base;
-	return parseGradientFill(gradFill);
-}
-function parseGradientFill(gradFill) {
-	let gradientType = "linear";
-	let angle;
-	const lin = findChildByLocalName(gradFill, "lin");
-	if (lin) {
-		gradientType = "linear";
-		const ang = getAttribute(lin, null, "ang");
-		if (ang) {
-			const parsed = Number.parseInt(ang, 10);
-			angle = Number.isNaN(parsed) ? void 0 : parsed / 6e4;
-		}
-	}
-	const path = findChildByLocalName(gradFill, "path");
-	if (path) {
-		const pathType = getAttribute(path, null, "path");
-		if (pathType === "circle") gradientType = "radial";
-		else if (pathType === "rect") gradientType = "rectangular";
-		else gradientType = "path";
-	}
-	const stops = [];
-	const gsLst = findChildByLocalName(gradFill, "gsLst");
-	if (gsLst) for (const gs of findChildrenByLocalName(gsLst, "gs")) {
-		const pos = getAttribute(gs, null, "pos");
-		const position = pos ? Number.parseInt(pos, 10) : 0;
-		const color = parseColorElement(gs);
-		if (color) stops.push({
-			position: Number.isNaN(position) ? 0 : position,
-			color
-		});
-	}
-	return {
-		type: "gradient",
-		gradient: {
-			type: gradientType,
-			...angle !== void 0 ? { angle } : {},
-			stops
-		}
-	};
-}
-const LINE_END_TYPES = /* @__PURE__ */ new Set([
-	"none",
-	"triangle",
-	"stealth",
-	"diamond",
-	"oval",
-	"arrow"
-]);
-function narrowLineEndType(value) {
-	if (value === null || value === void 0) return "none";
-	for (const allowed of LINE_END_TYPES) if (allowed === value) return allowed;
-	return "none";
-}
-function narrowLineEndSize(value) {
-	if (value === "sm" || value === "med" || value === "lg") return value;
-}
-function parseLineEnd(element) {
-	const type = narrowLineEndType(getAttribute(element, null, "type"));
-	const width = narrowLineEndSize(getAttribute(element, null, "w"));
-	const length = narrowLineEndSize(getAttribute(element, null, "len"));
-	return {
-		type,
-		...width !== void 0 ? { width } : {},
-		...length !== void 0 ? { length } : {}
-	};
-}
-/**
-* Parse a shape outline with cap, join, and arrow end fidelity. Returns
-* `undefined` when the spPr has no `<a:ln>`, an explicit `<a:noFill/>`,
-* or no usable attributes.
-*/
-function parseShapeOutline(spPr) {
-	const ln = findChildByLocalName(spPr, "ln");
-	if (!ln) return;
-	if (findChildByLocalName(ln, "noFill")) return;
-	const outline = {};
-	const w = getAttribute(ln, null, "w");
-	if (w) {
-		const parsed = Number.parseInt(w, 10);
-		if (!Number.isNaN(parsed)) outline.width = parsed;
-	}
-	const cap = getAttribute(ln, null, "cap");
-	if (cap === "flat") outline.cap = "flat";
-	else if (cap === "rnd") outline.cap = "round";
-	else if (cap === "sq") outline.cap = "square";
-	if (findChildByLocalName(ln, "bevel")) outline.join = "bevel";
-	else if (findChildByLocalName(ln, "round")) outline.join = "round";
-	else if (findChildByLocalName(ln, "miter")) outline.join = "miter";
-	const solidFill = findChildByLocalName(ln, "solidFill");
-	if (solidFill) {
-		const color = parseColorElement(solidFill);
-		if (color) outline.color = color;
-	}
-	const prstDash = findChildByLocalName(ln, "prstDash");
-	if (prstDash) {
-		const narrowed = narrowEnum(getAttribute(prstDash, null, "val"), ShapeOutlineStyleSchema);
-		if (narrowed !== void 0) outline.style = narrowed;
-	}
-	const headEnd = findChildByLocalName(ln, "headEnd");
-	if (headEnd) outline.headEnd = parseLineEnd(headEnd);
-	const tailEnd = findChildByLocalName(ln, "tailEnd");
-	if (tailEnd) outline.tailEnd = parseLineEnd(tailEnd);
-	if (outline.width === void 0 && outline.color === void 0 && outline.cap === void 0 && outline.join === void 0 && outline.style === void 0 && outline.headEnd === void 0 && outline.tailEnd === void 0) return;
-	return outline;
+	return parseFill(spPr);
 }
 function parseTransform(xfrm) {
 	if (!xfrm) return { size: {
@@ -179,13 +71,10 @@ function colorNeedsRawPreservation(color) {
 }
 function fillNeedsRawPreservation(fill) {
 	if (!fill) return false;
-	if (fill.type === "solid") return colorNeedsRawPreservation(fill.color);
+	if (fill.type === "solid") return false;
 	if (fill.type === "gradient") return fill.gradient?.stops.some((stop) => colorNeedsRawPreservation(stop.color)) ?? false;
 	return false;
 }
-function outlineNeedsRawPreservation(outline) {
-	return colorNeedsRawPreservation(outline?.color);
-}
 /**
 * Parse a `<wps:wsp>` element into a Shape model. Does NOT pick up the
 * extent / position / wrap fields — those live on the wrapping
@@ -197,7 +86,7 @@ function parseShape(node) {
 	const shapeType = parseShapeType(spPr);
 	const { size, transform } = parseTransform(findChildByLocalName(spPr, "xfrm"));
 	const fill = parseShapeFill(spPr);
-	const outline = parseShapeOutline(spPr);
+	const outline = parseOutline(spPr);
 	const id = cNvPr ? getAttribute(cNvPr, null, "id") ?? void 0 : void 0;
 	const name = cNvPr ? getAttribute(cNvPr, null, "name") ?? void 0 : void 0;
 	const shape = {
@@ -231,13 +120,17 @@ function parseShapeFromDrawing(drawingEl) {
 	if (!wsp) return null;
 	if (findChildByLocalName(wsp, "txbx") !== null) return null;
 	const spPr = findChildByLocalName(wsp, "spPr");
-	if (hasUnsupportedGeometry(spPr) || hasUnsupportedRgbColorModifiers(spPr) || hasUnmodeledFill(spPr) || fillNeedsRawPreservation(parseShapeFill(spPr)) || outlineNeedsRawPreservation(parseShapeOutline(spPr))) return null;
+	if (hasUnsupportedGeometry(spPr) || hasUnsupportedRgbColorModifiers(spPr) || hasUnmodeledFill(spPr) || fillNeedsRawPreservation(parseShapeFill(spPr))) return null;
 	const shape = parseShape(wsp);
 	const extent = findChildByLocalName(container, "extent");
-	if (extent) shape.size = {
-		width: parseNumericAttribute(extent, null, "cx") ?? shape.size.width,
-		height: parseNumericAttribute(extent, null, "cy") ?? shape.size.height
-	};
+	if (extent) {
+		const outerWidth = parseNumericAttribute(extent, null, "cx");
+		const outerHeight = parseNumericAttribute(extent, null, "cy");
+		shape.size = {
+			width: outerWidth !== void 0 && (outerWidth > 0 || shape.size.width === 0) ? outerWidth : shape.size.width,
+			height: outerHeight !== void 0 && (outerHeight > 0 || shape.size.height === 0) ? outerHeight : shape.size.height
+		};
+	}
 	if (container === anchor) {
 		const position = parseAnchorPosition(container);
 		if (position) shape.position = position;
@@ -266,7 +159,7 @@ function shouldPreserveRawShapeDrawing(drawingEl) {
 	if (hasUnsupportedGeometry(spPr)) return true;
 	if (hasUnsupportedRgbColorModifiers(spPr)) return true;
 	if (hasUnmodeledFill(spPr)) return true;
-	return fillNeedsRawPreservation(parseShapeFill(spPr)) || outlineNeedsRawPreservation(parseShapeOutline(spPr));
+	return fillNeedsRawPreservation(parseShapeFill(spPr));
 }
 //#endregion
 export { parseShape, parseShapeFromDrawing, shouldPreserveRawShapeDrawing };

package/dist/docx/streamingXmlParser.d.ts

@@ -0,0 +1,16 @@
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/streamingXmlParser.d.ts
+type ParseXmlResult = {
+  status: "parsed";
+  value: XmlElement;
+} | {
+  status: "unsupported";
+};
+/**
+ * Parse ordinary OOXML into Folio's existing element representation in one
+ * pass. Unsupported or malformed constructs return a sentinel so callers can
+ * retain the general-purpose parser as a compatibility fallback.
+ */
+declare const parseStreamingXml: (xml: string) => ParseXmlResult;
+//#endregion
+export { parseStreamingXml };

package/dist/docx/streamingXmlParser.js

@@ -0,0 +1,248 @@
+//#region src/docx/streamingXmlParser.ts
+const BUILT_IN_ENTITIES = {
+	amp: "&",
+	apos: "'",
+	gt: ">",
+	lt: "<",
+	quot: "\""
+};
+/**
+* Parse ordinary OOXML into Folio's existing element representation in one
+* pass. Unsupported or malformed constructs return a sentinel so callers can
+* retain the general-purpose parser as a compatibility fallback.
+*/
+const parseStreamingXml = (xml) => {
+	const root = { elements: [] };
+	const stack = [];
+	let cursor = 0;
+	let mergeAdjacentText = false;
+	while (cursor < xml.length) {
+		const open = xml.indexOf("<", cursor);
+		if (open === -1) {
+			if (!appendText(xml.slice(cursor), stack, mergeAdjacentText)) return { status: "unsupported" };
+			break;
+		}
+		if (open > cursor && !appendText(xml.slice(cursor, open), stack, mergeAdjacentText)) return { status: "unsupported" };
+		if (open > cursor) mergeAdjacentText = true;
+		if (xml.startsWith("<!--", open)) {
+			const close = xml.indexOf("-->", open + 4);
+			if (close === -1) return { status: "unsupported" };
+			cursor = close + 3;
+			continue;
+		}
+		if (xml.startsWith("<![CDATA[", open)) {
+			const close = xml.indexOf("]]>", open + 9);
+			if (close === -1 || !appendRawText(normalizeLineEndings(xml.slice(open + 9, close)), stack)) return { status: "unsupported" };
+			cursor = close + 3;
+			mergeAdjacentText = false;
+			continue;
+		}
+		if (xml.startsWith("<?", open)) {
+			const close = xml.indexOf("?>", open + 2);
+			if (close === -1) return { status: "unsupported" };
+			cursor = close + 2;
+			continue;
+		}
+		if (xml.startsWith("<!", open)) return { status: "unsupported" };
+		const close = findTagClose(xml, open + 1);
+		if (close === -1) return { status: "unsupported" };
+		if (xml.charCodeAt(open + 1) === 47) {
+			const name = xml.slice(open + 2, close).trim();
+			const frame = stack.pop();
+			if (!frame || frame.name !== name) return { status: "unsupported" };
+			cursor = close + 1;
+			mergeAdjacentText = false;
+			continue;
+		}
+		const parsedTag = parseOpenTag(xml, open + 1, close);
+		if (parsedTag.status === "unsupported") return parsedTag;
+		const parent = stack.at(-1)?.element ?? root;
+		appendElement(parent, parsedTag.element);
+		if (!parsedTag.selfClosing) {
+			if (stack.length >= 100) return { status: "unsupported" };
+			stack.push({
+				element: parsedTag.element,
+				name: parsedTag.name
+			});
+		}
+		cursor = close + 1;
+		mergeAdjacentText = false;
+	}
+	if (stack.length > 0) return { status: "unsupported" };
+	return {
+		status: "parsed",
+		value: root
+	};
+};
+const parseOpenTag = (xml, start, close) => {
+	let cursor = skipWhitespace(xml, start, close);
+	const nameStart = cursor;
+	cursor = scanName(xml, cursor, close);
+	if (cursor === nameStart) return { status: "unsupported" };
+	const name = xml.slice(nameStart, cursor);
+	if (isUnsafePropertyName(name)) return { status: "unsupported" };
+	let attributes;
+	let selfClosing = false;
+	while (cursor < close) {
+		cursor = skipWhitespace(xml, cursor, close);
+		if (cursor >= close) break;
+		if (xml.charCodeAt(cursor) === 47) {
+			selfClosing = true;
+			cursor = skipWhitespace(xml, cursor + 1, close);
+			if (cursor !== close) return { status: "unsupported" };
+			break;
+		}
+		const attributeNameStart = cursor;
+		cursor = scanName(xml, cursor, close);
+		if (cursor === attributeNameStart) return { status: "unsupported" };
+		const attributeName = xml.slice(attributeNameStart, cursor);
+		if (isUnsafePropertyName(attributeName)) return { status: "unsupported" };
+		cursor = skipWhitespace(xml, cursor, close);
+		if (xml.charCodeAt(cursor) !== 61) return { status: "unsupported" };
+		cursor = skipWhitespace(xml, cursor + 1, close);
+		const quote = xml.charCodeAt(cursor);
+		if (quote !== 34 && quote !== 39) return { status: "unsupported" };
+		const valueStart = cursor + 1;
+		cursor = xml.indexOf(quote === 34 ? "\"" : "'", valueStart);
+		if (cursor === -1 || cursor > close) return { status: "unsupported" };
+		const decoded = decodeXmlEntities(normalizeLineEndings(xml.slice(valueStart, cursor)));
+		if (decoded === null) return { status: "unsupported" };
+		attributes ??= {};
+		attributes[attributeName] = decoded;
+		cursor += 1;
+	}
+	const element = {
+		type: "element",
+		name
+	};
+	if (attributes) element.attributes = attributes;
+	return {
+		status: "parsed",
+		element,
+		name,
+		selfClosing
+	};
+};
+const appendElement = (parent, child) => {
+	parent.elements ??= [];
+	parent.elements.push(child);
+};
+const appendText = (text, stack, mergeAdjacentText) => {
+	if (text.length === 0) return true;
+	const decoded = decodeXmlEntities(normalizeLineEndings(text));
+	if (decoded === null) return false;
+	const parent = stack.at(-1)?.element;
+	const previous = mergeAdjacentText ? parent?.elements?.at(-1) : void 0;
+	if (previous?.type === "text" && typeof previous.text === "string") {
+		previous.text += decoded;
+		return true;
+	}
+	return appendRawText(decoded, stack);
+};
+const appendRawText = (text, stack) => {
+	const parent = stack.at(-1)?.element;
+	if (!parent) return text.trim().length === 0;
+	appendElement(parent, {
+		type: "text",
+		text
+	});
+	return true;
+};
+const findTagClose = (xml, start) => {
+	let quote = 0;
+	for (let cursor = start; cursor < xml.length; cursor += 1) {
+		const code = xml.charCodeAt(cursor);
+		if (quote !== 0) {
+			if (code === quote) quote = 0;
+			continue;
+		}
+		if (code === 34 || code === 39) {
+			quote = code;
+			continue;
+		}
+		if (code === 62) return cursor;
+	}
+	return -1;
+};
+const skipWhitespace = (xml, start, limit) => {
+	let cursor = start;
+	while (cursor < limit) {
+		const code = xml.charCodeAt(cursor);
+		if (code !== 9 && code !== 10 && code !== 13 && code !== 32) break;
+		cursor += 1;
+	}
+	return cursor;
+};
+const scanName = (xml, start, limit) => {
+	let cursor = start;
+	while (cursor < limit) {
+		const code = xml.charCodeAt(cursor);
+		if (code === 9 || code === 10 || code === 13 || code === 32 || code === 47 || code === 61 || code === 62) break;
+		cursor += 1;
+	}
+	return cursor;
+};
+const decodeXmlEntities = (value) => {
+	const firstEntity = value.indexOf("&");
+	if (firstEntity === -1) return value;
+	const parts = [];
+	let cursor = 0;
+	let entityStart = firstEntity;
+	while (entityStart !== -1) {
+		parts.push(value.slice(cursor, entityStart));
+		const entityEnd = value.indexOf(";", entityStart + 1);
+		if (entityEnd === -1) return null;
+		const entity = value.slice(entityStart + 1, entityEnd);
+		const decoded = decodeXmlEntity(entity);
+		if (decoded === null) return null;
+		parts.push(decoded);
+		cursor = entityEnd + 1;
+		entityStart = value.indexOf("&", cursor);
+	}
+	parts.push(value.slice(cursor));
+	return parts.join("");
+};
+const normalizeLineEndings = (value) => {
+	if (!value.includes("\r")) return value;
+	return value.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+};
+const decodeXmlEntity = (entity) => {
+	switch (entity) {
+		case "amp": return BUILT_IN_ENTITIES.amp;
+		case "apos": return BUILT_IN_ENTITIES.apos;
+		case "gt": return BUILT_IN_ENTITIES.gt;
+		case "lt": return BUILT_IN_ENTITIES.lt;
+		case "quot": return BUILT_IN_ENTITIES.quot;
+	}
+	if (entity.charCodeAt(0) !== 35) return null;
+	const hexadecimal = entity.charCodeAt(1) === 120 || entity.charCodeAt(1) === 88;
+	const digits = entity.slice(hexadecimal ? 2 : 1);
+	if (digits.length === 0 || !hasOnlyDigits(digits, hexadecimal)) return null;
+	const codePoint = Number.parseInt(digits, hexadecimal ? 16 : 10);
+	if (!Number.isInteger(codePoint) || codePoint <= 0 || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343) return null;
+	return String.fromCodePoint(codePoint);
+};
+const hasOnlyDigits = (value, hexadecimal) => {
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (!(code >= 48 && code <= 57) && !(hexadecimal && code >= 97 && code <= 102) && !(hexadecimal && code >= 65 && code <= 70)) return false;
+	}
+	return true;
+};
+const isUnsafePropertyName = (name) => {
+	switch (name) {
+		case "__defineGetter__":
+		case "__defineSetter__":
+		case "__lookupGetter__":
+		case "__lookupSetter__":
+		case "__proto__":
+		case "constructor":
+		case "hasOwnProperty":
+		case "prototype":
+		case "toString":
+		case "valueOf": return true;
+		default: return false;
+	}
+};
+//#endregion
+export { parseStreamingXml };

package/dist/docx/styleParser.d.ts

@@ -1,5 +1,4 @@
 import { document_d_exports } from "../types/document.js";
-
 //#region src/docx/styleParser.d.ts
 /**
  * Style map keyed by styleId

package/dist/docx/styleParser.js

@@ -1,5 +1,5 @@
-import { BorderStyleSchema, ConditionalStyleTypeSchema, EmphasisMarkSchema, FontThemeSchema, HighlightColorSchema, LineSpacingRuleSchema, ParagraphAlignmentSchema, ShadingPatternSchema, StyleTypeSchema, TabLeaderSchema, TabStopAlignmentSchema, TableCellTextDirectionSchema, TableRowHeightRuleSchema, TableWidthTypeSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
-import { findChild, findChildren, getAttribute, getLocalName, parseBooleanElement, parseNumericAttribute, parseTableMeasurementValue, parseXmlDocument } from "./xmlParser.js";
+import { BorderStyleSchema, ConditionalStyleTypeSchema, EmphasisMarkSchema, FontHintSchema, FontThemeSchema, HighlightColorSchema, LineSpacingRuleSchema, ParagraphAlignmentSchema, ShadingPatternSchema, StyleTypeSchema, TabLeaderSchema, TabStopAlignmentSchema, TableCellTextDirectionSchema, TableRowHeightRuleSchema, TableWidthTypeSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
+import { findChild, findChildren, getAttribute, getLocalName, parseBooleanElement, parseNumberingLevelAttribute, parseNumericAttribute, parseTableMeasurementValue, parseXmlDocument } from "./xmlParser.js";
 import { mergeTextFormatting } from "../utils/textFormattingMerge.js";
 import { mergeParagraphFormatting } from "../utils/paragraphFormattingMerge.js";
 import { resolveThemeFontRef } from "./themeParser.js";
@@ -76,6 +76,8 @@ function parseRunProperties(rPr, theme) {
 		if (eastAsia) fontFamily.eastAsia = eastAsia;
 		const csFont = getAttribute(rFonts, "w", "cs");
 		if (csFont) fontFamily.cs = csFont;
+		const hint = narrowEnum(getAttribute(rFonts, "w", "hint"), FontHintSchema);
+		if (hint) fontFamily.hint = hint;
 		const asciiTheme = narrowEnum(getAttribute(rFonts, "w", "asciiTheme"), FontThemeSchema);
 		if (asciiTheme) {
 			fontFamily.asciiTheme = asciiTheme;
@@ -244,7 +246,7 @@ function parseTabStops(tabs) {
 				alignment
 			};
 			const leader = narrowEnum(getAttribute(tab, "w", "leader"), TabLeaderSchema);
-			if (leader) tabStop.leader = leader;
+			if (leader && leader !== "none") tabStop.leader = leader;
 			result.push(tabStop);
 		}
 	}
@@ -342,7 +344,7 @@ function parseParagraphProperties(pPr, theme) {
 				if (val !== void 0) formatting.numPr.numId = val;
 			}
 			if (ilvl) {
-				const val = parseNumericAttribute(ilvl, "w", "val");
+				const val = parseNumberingLevelAttribute(ilvl);
 				if (val !== void 0) formatting.numPr.ilvl = val;
 			}
 		}

package/dist/docx/tableParser.d.ts

@@ -2,7 +2,6 @@ import { document_d_exports } from "../types/document.js";
 import { NumberingMap } from "./numberingParser.js";
 import { StyleMap } from "./styleParser.js";
 import { XmlElement } from "./xmlParser.js";
-
 //#region src/docx/tableParser.d.ts
 /**
  * Sanity cap on `w:gridSpan` (and the derived table column count). Word's
@@ -139,7 +138,7 @@ declare function parseTableGrid(tblGridElement: XmlElement | null): number[] | u
 declare function parseTable(tblElement: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null, options?: {
   inHeaderFooter?: boolean;
   rootXmlns?: Record<string, string>;
-}): document_d_exports.Table;
+}): document_d_exports.Table | undefined;
 /**
  * Get the number of columns in a table
  *

package/dist/docx/tableParser.js

@@ -1,5 +1,5 @@
 import { BorderStyleSchema, FloatingTableXSpecSchema, FloatingTableYSpecSchema, ShadingPatternSchema, TableCellTextDirectionSchema, ThemeColorSlotSchema, narrowEnum } from "./parserEnums.js";
-import { findChild, findChildByLocalName, findChildren, getAttribute, getChildElements, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, parseTableMeasurementValue } from "./xmlParser.js";
+import { findChild, findChildByLocalName, findChildren, getAttribute, getChildElements, getLocalName, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, parseTableMeasurementValue } from "./xmlParser.js";
 import { parseBookmarkEnd, parseBookmarkStart } from "./bookmarkParser.js";
 import { parseParagraph } from "./paragraphParser.js";
 import { appendBookmarkMarkerToLastParagraphInBlocks, appendBookmarkMarkerToLastParagraphInCells, prependBookmarkMarkersToFirstParagraphInBlocks, prependBookmarkMarkersToFirstParagraphInCell } from "./bookmarkPlacement.js";
@@ -394,12 +394,14 @@ function parseTableRowProperties(trPrElement) {
 	const heightElement = findChild(trPrElement, "w", "trHeight");
 	if (heightElement) {
 		const heightVal = parseNumericAttribute(heightElement, "w", "val");
-		if (heightVal !== void 0 && heightVal > 0) formatting.height = {
-			value: heightVal,
-			type: "dxa"
-		};
-		const hRule = getAttribute(heightElement, "w", "hRule");
-		if (hRule === "auto" || hRule === "atLeast" || hRule === "exact") formatting.heightRule = hRule;
+		if (heightVal !== void 0 && heightVal > 0) {
+			formatting.height = {
+				value: heightVal,
+				type: "dxa"
+			};
+			const hRule = getAttribute(heightElement, "w", "hRule");
+			if (hRule === "auto" || hRule === "atLeast" || hRule === "exact") formatting.heightRule = hRule;
+		}
 	}
 	if (parseBooleanElement(findChild(trPrElement, "w", "tblHeader"))) formatting.header = true;
 	if (parseBooleanElement(findChild(trPrElement, "w", "cantSplit"))) formatting.cantSplit = true;
@@ -536,6 +538,7 @@ function parseCellContent(tcElement, styles, theme, numbering, rels, media, opti
 		}
 		if (localName === "tbl") {
 			const table = parseTable(child, styles, theme, numbering, rels, media, options);
+			if (!table) return;
 			if (prependBookmarkMarkersToFirstParagraphInBlocks([table], pendingBookmarkMarkers)) pendingBookmarkMarkers.length = 0;
 			content.push(table);
 			return;
@@ -635,11 +638,6 @@ function parseTableRow(trElement, styles, theme, numbering, rels, media, options
 	if (pendingBookmarkMarkers.length > 0) appendBookmarkMarkersToLastCell(row, pendingBookmarkMarkers);
 	return row;
 }
-function getLocalName(name) {
-	if (!name) return "";
-	const colonIndex = name.indexOf(":");
-	return colonIndex === -1 ? name : name.slice(colonIndex + 1);
-}
 function parseBookmarkMarker(child, localName) {
 	if (localName === "bookmarkStart") return parseBookmarkStart(child);
 	return parseBookmarkEnd(child);
@@ -751,6 +749,7 @@ function parseTable(tblElement, styles, theme, numbering, rels, media, options)
 		for (const sdtChild of getChildElements(sdtContent)) parseTableChild(sdtChild);
 	};
 	for (const child of getChildElements(tblElement)) parseTableChild(child);
+	if (table.rows.length === 0) return;
 	inferImplicitSingleCellRowSpans(table, rowsWithGridOffsets);
 	return table;
 }

package/dist/docx/textBoxParser.d.ts

@@ -2,7 +2,6 @@ import { document_d_exports } from "../types/document.js";
 import { NumberingMap } from "./numberingParser.js";
 import { StyleMap } from "./styleParser.js";
 import { XmlElement } from "./xmlParser.js";
-
 //#region src/docx/textBoxParser.d.ts
 /**
  * Extract raw paragraph elements from w:txbxContent
@@ -19,7 +18,7 @@ type ParagraphParserFn = (node: XmlElement, styles: StyleMap | null, theme: docu
 /**
  * Type for the table parser function to avoid circular imports
  */
-type TableParserFn = (node: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null) => document_d_exports.Table;
+type TableParserFn = (node: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null) => document_d_exports.Table | undefined;
 /**
  * Parse text box content with provided parser functions
  * This avoids circular dependencies by accepting parser functions as parameters

package/dist/docx/textBoxParser.js

@@ -55,7 +55,10 @@ function parseTextBoxContent(txbxContent, parseParagraph, parseTable, styles, th
 		if (localName === "p") {
 			const paragraph = parseParagraph(child, styles, theme, numbering, rels, media);
 			blocks.push(paragraph);
-		} else if (localName === "tbl" && parseTable) blocks.push(parseTable(child, styles, theme, numbering, rels, media));
+		} else if (localName === "tbl" && parseTable) {
+			const table = parseTable(child, styles, theme, numbering, rels, media);
+			if (table) blocks.push(table);
+		}
 	}
 	return blocks;
 }
@@ -130,7 +133,7 @@ function parseTextBox(drawingEl) {
 		if (position) textBox.position = position;
 		const wrap = parseAnchorWrap(container);
 		if (wrap) textBox.wrap = wrap;
-	}
+	} else textBox.wrap = { type: "inline" };
 	return textBox;
 }
 /**

package/dist/docx/textWhitespace.d.ts

@@ -0,0 +1,4 @@
+//#region src/docx/textWhitespace.d.ts
+declare const requiresXmlSpacePreserve: (text: string) => boolean;
+//#endregion
+export { requiresXmlSpacePreserve };

package/dist/docx/textWhitespace.js

@@ -0,0 +1,4 @@
+//#region src/docx/textWhitespace.ts
+const requiresXmlSpacePreserve = (text) => text.startsWith(" ") || text.endsWith(" ") || text.includes("  ");
+//#endregion
+export { requiresXmlSpacePreserve };