@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

package/dist/docx/runParser.js

@@ -0,0 +1,661 @@
+import { cloneWithXmlnsDeclarations, elementToXml, findChild, findChildren, getAttribute, getChildElements, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute } from "./xmlParser.js";
+import { EmphasisMarkSchema, FontThemeSchema, HighlightColorSchema, ShadingPatternSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
+import { parseImage } from "./imageParser.js";
+import { parseShapeFromDrawing, shouldPreserveRawShapeDrawing } from "./shapeParser.js";
+import { parseVmlImageContent } from "./vmlImageParser.js";
+import { resolveThemeFontRef } from "./themeParser.js";
+//#region src/docx/runParser.ts
+/**
+* Parse color value from attributes
+*/
+function parseColorValue(rgb, themeColor, themeTint, themeShade) {
+	const color = {};
+	if (rgb && rgb !== "auto") color.rgb = rgb;
+	else if (rgb === "auto") color.auto = true;
+	const validatedThemeColor = narrowEnum(themeColor, ThemeColorSlotSchema);
+	if (validatedThemeColor) color.themeColor = validatedThemeColor;
+	if (themeTint) color.themeTint = themeTint;
+	if (themeShade) color.themeShade = themeShade;
+	return color;
+}
+/**
+* Parse shading properties (w:shd)
+*/
+function parseShadingProperties(shd) {
+	if (!shd) return;
+	const props = {};
+	const color = getAttribute(shd, "w", "color");
+	if (color && color !== "auto") props.color = { rgb: color };
+	const fill = getAttribute(shd, "w", "fill");
+	if (fill && fill !== "auto") props.fill = { rgb: fill };
+	const validatedThemeFill = narrowEnum(getAttribute(shd, "w", "themeFill"), ThemeColorSlotSchema);
+	if (validatedThemeFill) {
+		if (!props.fill) props.fill = {};
+		props.fill.themeColor = validatedThemeFill;
+	}
+	const themeFillTint = getAttribute(shd, "w", "themeFillTint");
+	if (themeFillTint && props.fill) props.fill.themeTint = themeFillTint;
+	const themeFillShade = getAttribute(shd, "w", "themeFillShade");
+	if (themeFillShade && props.fill) props.fill.themeShade = themeFillShade;
+	const pattern = narrowEnum(getAttribute(shd, "w", "val"), ShadingPatternSchema);
+	if (pattern) props.pattern = pattern;
+	return Object.keys(props).length > 0 ? props : void 0;
+}
+function collectFirstRunPropertyChildren(rPr) {
+	const children = {};
+	for (const child of rPr.elements ?? []) {
+		if (child.type !== "element") continue;
+		switch (getLocalName(child.name)) {
+			case "b":
+				children.b ??= child;
+				break;
+			case "bCs":
+				children.bCs ??= child;
+				break;
+			case "caps":
+				children.caps ??= child;
+				break;
+			case "color":
+				children.color ??= child;
+				break;
+			case "cs":
+				children.cs ??= child;
+				break;
+			case "dstrike":
+				children.dstrike ??= child;
+				break;
+			case "effect":
+				children.effect ??= child;
+				break;
+			case "em":
+				children.em ??= child;
+				break;
+			case "emboss":
+				children.emboss ??= child;
+				break;
+			case "highlight":
+				children.highlight ??= child;
+				break;
+			case "i":
+				children.i ??= child;
+				break;
+			case "iCs":
+				children.iCs ??= child;
+				break;
+			case "imprint":
+				children.imprint ??= child;
+				break;
+			case "kern":
+				children.kern ??= child;
+				break;
+			case "outline":
+				children.outline ??= child;
+				break;
+			case "position":
+				children.position ??= child;
+				break;
+			case "rFonts":
+				children.rFonts ??= child;
+				break;
+			case "rtl":
+				children.rtl ??= child;
+				break;
+			case "rStyle":
+				children.rStyle ??= child;
+				break;
+			case "shadow":
+				children.shadow ??= child;
+				break;
+			case "shd":
+				children.shd ??= child;
+				break;
+			case "smallCaps":
+				children.smallCaps ??= child;
+				break;
+			case "spacing":
+				children.spacing ??= child;
+				break;
+			case "strike":
+				children.strike ??= child;
+				break;
+			case "sz":
+				children.sz ??= child;
+				break;
+			case "szCs":
+				children.szCs ??= child;
+				break;
+			case "u":
+				children.u ??= child;
+				break;
+			case "vanish":
+				children.vanish ??= child;
+				break;
+			case "vertAlign":
+				children.vertAlign ??= child;
+				break;
+			case "w":
+				children.w ??= child;
+				break;
+		}
+	}
+	return children;
+}
+/**
+* Parse run formatting properties (w:rPr)
+*
+* Handles ALL rPr properties:
+* - w:b (bold), w:i (italic), w:u (underline with style)
+* - w:strike (strikethrough), w:dstrike (double strike)
+* - w:vertAlign (superscript/subscript)
+* - w:smallCaps, w:caps (capitalization)
+* - w:highlight (text highlight color)
+* - w:shd (character shading)
+* - w:color (text color with theme resolution)
+* - w:sz (font size in half-points)
+* - w:rFonts (font family with theme resolution)
+* - w:spacing (character spacing)
+* - w:effect (text effects)
+* - And more...
+*/
+function parseRunProperties(rPr, theme, _styles) {
+	if (!rPr) return;
+	const formatting = {};
+	const propertyChildren = collectFirstRunPropertyChildren(rPr);
+	const b = propertyChildren.b;
+	if (b) formatting.bold = parseBooleanElement(b);
+	const bCs = propertyChildren.bCs;
+	if (bCs) formatting.boldCs = parseBooleanElement(bCs);
+	const i = propertyChildren.i;
+	if (i) formatting.italic = parseBooleanElement(i);
+	const iCs = propertyChildren.iCs;
+	if (iCs) formatting.italicCs = parseBooleanElement(iCs);
+	const u = propertyChildren.u;
+	if (u) {
+		const style = narrowEnum(getAttribute(u, "w", "val"), UnderlineStyleSchema);
+		if (style) {
+			formatting.underline = { style };
+			const colorVal = getAttribute(u, "w", "color");
+			const themeColor = getAttribute(u, "w", "themeColor");
+			if (colorVal || themeColor) formatting.underline.color = parseColorValue(colorVal, themeColor, getAttribute(u, "w", "themeTint"), getAttribute(u, "w", "themeShade"));
+		}
+	}
+	const strike = propertyChildren.strike;
+	if (strike) formatting.strike = parseBooleanElement(strike);
+	const dstrike = propertyChildren.dstrike;
+	if (dstrike) formatting.doubleStrike = parseBooleanElement(dstrike);
+	const vertAlign = propertyChildren.vertAlign;
+	if (vertAlign) {
+		const val = getAttribute(vertAlign, "w", "val");
+		if (val === "superscript" || val === "subscript" || val === "baseline") formatting.vertAlign = val;
+	}
+	const smallCaps = propertyChildren.smallCaps;
+	if (smallCaps) formatting.smallCaps = parseBooleanElement(smallCaps);
+	const caps = propertyChildren.caps;
+	if (caps) formatting.allCaps = parseBooleanElement(caps);
+	const vanish = propertyChildren.vanish;
+	if (vanish) formatting.hidden = parseBooleanElement(vanish);
+	const color = propertyChildren.color;
+	if (color) formatting.color = parseColorValue(getAttribute(color, "w", "val"), getAttribute(color, "w", "themeColor"), getAttribute(color, "w", "themeTint"), getAttribute(color, "w", "themeShade"));
+	const highlight = propertyChildren.highlight;
+	if (highlight) {
+		const val = narrowEnum(getAttribute(highlight, "w", "val"), HighlightColorSchema);
+		if (val) formatting.highlight = val;
+	}
+	const shd = propertyChildren.shd;
+	if (shd) {
+		const shadingResult = parseShadingProperties(shd);
+		if (shadingResult) formatting.shading = shadingResult;
+	}
+	const sz = propertyChildren.sz;
+	if (sz) {
+		const val = parseNumericAttribute(sz, "w", "val");
+		if (val !== void 0) formatting.fontSize = val;
+	}
+	const szCs = propertyChildren.szCs;
+	if (szCs) {
+		const val = parseNumericAttribute(szCs, "w", "val");
+		if (val !== void 0) formatting.fontSizeCs = val;
+	}
+	const rFonts = propertyChildren.rFonts;
+	if (rFonts) {
+		const fontFamily = {};
+		const ascii = getAttribute(rFonts, "w", "ascii");
+		if (ascii) fontFamily.ascii = ascii;
+		const hAnsi = getAttribute(rFonts, "w", "hAnsi");
+		if (hAnsi) fontFamily.hAnsi = hAnsi;
+		const eastAsia = getAttribute(rFonts, "w", "eastAsia");
+		if (eastAsia) fontFamily.eastAsia = eastAsia;
+		const csFont = getAttribute(rFonts, "w", "cs");
+		if (csFont) fontFamily.cs = csFont;
+		const asciiTheme = narrowEnum(getAttribute(rFonts, "w", "asciiTheme"), FontThemeSchema);
+		if (asciiTheme) {
+			fontFamily.asciiTheme = asciiTheme;
+			if (theme && !fontFamily.ascii) {
+				const resolved = resolveThemeFontRef(theme, asciiTheme);
+				if (resolved) fontFamily.ascii = resolved;
+			}
+		}
+		const hAnsiTheme = getAttribute(rFonts, "w", "hAnsiTheme");
+		if (hAnsiTheme) {
+			fontFamily.hAnsiTheme = hAnsiTheme;
+			if (theme && !fontFamily.hAnsi) {
+				const resolved = resolveThemeFontRef(theme, hAnsiTheme);
+				if (resolved) fontFamily.hAnsi = resolved;
+			}
+		}
+		const eastAsiaTheme = getAttribute(rFonts, "w", "eastAsiaTheme");
+		if (eastAsiaTheme) {
+			fontFamily.eastAsiaTheme = eastAsiaTheme;
+			if (theme && !fontFamily.eastAsia) {
+				const resolved = resolveThemeFontRef(theme, eastAsiaTheme);
+				if (resolved) fontFamily.eastAsia = resolved;
+			}
+		}
+		const csTheme = getAttribute(rFonts, "w", "cstheme");
+		if (csTheme) {
+			fontFamily.csTheme = csTheme;
+			if (theme && !fontFamily.cs) {
+				const resolved = resolveThemeFontRef(theme, csTheme);
+				if (resolved) fontFamily.cs = resolved;
+			}
+		}
+		formatting.fontFamily = fontFamily;
+	}
+	const spacing = propertyChildren.spacing;
+	if (spacing) {
+		const val = parseNumericAttribute(spacing, "w", "val");
+		if (val !== void 0) formatting.spacing = val;
+	}
+	const position = propertyChildren.position;
+	if (position) {
+		const val = parseNumericAttribute(position, "w", "val");
+		if (val !== void 0) formatting.position = val;
+	}
+	const w = propertyChildren.w;
+	if (w) {
+		const val = parseNumericAttribute(w, "w", "val");
+		if (val !== void 0) formatting.scale = val;
+	}
+	const kern = propertyChildren.kern;
+	if (kern) {
+		const val = parseNumericAttribute(kern, "w", "val");
+		if (val !== void 0) formatting.kerning = val;
+	}
+	const effect = propertyChildren.effect;
+	if (effect) {
+		const val = narrowEnum(getAttribute(effect, "w", "val"), TextEffectSchema);
+		if (val) formatting.effect = val;
+	}
+	const em = propertyChildren.em;
+	if (em) {
+		const val = narrowEnum(getAttribute(em, "w", "val"), EmphasisMarkSchema);
+		if (val) formatting.emphasisMark = val;
+	}
+	const emboss = propertyChildren.emboss;
+	if (emboss) formatting.emboss = parseBooleanElement(emboss);
+	const imprint = propertyChildren.imprint;
+	if (imprint) formatting.imprint = parseBooleanElement(imprint);
+	const outline = propertyChildren.outline;
+	if (outline) formatting.outline = parseBooleanElement(outline);
+	const shadow = propertyChildren.shadow;
+	if (shadow) formatting.shadow = parseBooleanElement(shadow);
+	const rtl = propertyChildren.rtl;
+	if (rtl) formatting.rtl = parseBooleanElement(rtl);
+	const cs = propertyChildren.cs;
+	if (cs) formatting.cs = parseBooleanElement(cs);
+	const rStyle = propertyChildren.rStyle;
+	if (rStyle) {
+		const val = getAttribute(rStyle, "w", "val");
+		if (val) formatting.styleId = val;
+	}
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
+function parsePropertyChangeInfo(changeElement) {
+	const rawId = getAttribute(changeElement, "w", "id");
+	const parsedId = rawId ? Number.parseInt(rawId, 10) : 0;
+	const author = (getAttribute(changeElement, "w", "author") ?? "").trim();
+	const date = (getAttribute(changeElement, "w", "date") ?? "").trim();
+	const rsid = (getAttribute(changeElement, "w", "rsid") ?? "").trim();
+	const info = {
+		id: Number.isInteger(parsedId) && parsedId >= 0 ? parsedId : 0,
+		author: author.length > 0 ? author : "Unknown"
+	};
+	if (date.length > 0) info.date = date;
+	if (rsid.length > 0) info.rsid = rsid;
+	return info;
+}
+function parseRunPropertyChanges(rPr, theme, styles, currentFormatting) {
+	if (!rPr) return;
+	const changes = findChildren(rPr, "w", "rPrChange").map((changeElement) => {
+		const previousRPr = findChild(changeElement, "w", "rPr");
+		const change = {
+			type: "runPropertyChange",
+			info: parsePropertyChangeInfo(changeElement)
+		};
+		const previousFormatting = parseRunProperties(previousRPr, theme, styles ?? void 0);
+		if (previousFormatting) change.previousFormatting = previousFormatting;
+		if (currentFormatting) change.currentFormatting = currentFormatting;
+		return change;
+	}).filter((change) => change.previousFormatting || change.currentFormatting);
+	return changes.length > 0 ? changes : void 0;
+}
+/**
+* Parse text content (w:t)
+*/
+function parseTextContent(element) {
+	const text = getTextContent(element);
+	const preserveSpace = getAttribute(element, "xml", "space") === "preserve";
+	const content = {
+		type: "text",
+		text
+	};
+	if (preserveSpace) content.preserveSpace = true;
+	return content;
+}
+/**
+* Parse tab element (w:tab)
+*/
+function parseTabContent() {
+	return { type: "tab" };
+}
+/**
+* Parse break element (w:br)
+*/
+function parseBreakContent(element) {
+	const breakType = getAttribute(element, "w", "type");
+	const clear = getAttribute(element, "w", "clear");
+	const content = { type: "break" };
+	if (breakType === "page" || breakType === "column" || breakType === "textWrapping") content.breakType = breakType;
+	if (clear === "none" || clear === "left" || clear === "right" || clear === "all") content.clear = clear;
+	return content;
+}
+/**
+* Parse symbol element (w:sym)
+*/
+function parseSymbolContent(element) {
+	return {
+		type: "symbol",
+		font: getAttribute(element, "w", "font") ?? "",
+		char: getAttribute(element, "w", "char") ?? ""
+	};
+}
+/**
+* Parse footnote reference (w:footnoteReference)
+*/
+function parseFootnoteReference(element) {
+	return {
+		type: "footnoteRef",
+		id: parseNumericAttribute(element, "w", "id") ?? 0
+	};
+}
+/**
+* Parse endnote reference (w:endnoteReference)
+*/
+function parseEndnoteReference(element) {
+	return {
+		type: "endnoteRef",
+		id: parseNumericAttribute(element, "w", "id") ?? 0
+	};
+}
+/**
+* Parse field character (w:fldChar)
+*/
+function parseFieldChar(element) {
+	const fldCharType = getAttribute(element, "w", "fldCharType");
+	const fldLock = getAttribute(element, "w", "fldLock") === "true" || getAttribute(element, "w", "fldLock") === "1";
+	const dirty = getAttribute(element, "w", "dirty") === "true" || getAttribute(element, "w", "dirty") === "1";
+	let charType = "begin";
+	if (fldCharType === "separate") charType = "separate";
+	else if (fldCharType === "end") charType = "end";
+	const content = {
+		type: "fieldChar",
+		charType
+	};
+	if (fldLock) content.fldLock = true;
+	if (dirty) content.dirty = true;
+	const numberingChange = findChild(element, "w", "numberingChange");
+	if (numberingChange) {
+		const original = getAttribute(numberingChange, "w", "original");
+		if (original !== null) content.originalValue = original;
+	}
+	return content;
+}
+/**
+* Parse instruction text (w:instrText)
+*/
+function parseInstrText(element) {
+	return {
+		type: "instrText",
+		text: getTextContent(element)
+	};
+}
+/**
+* Parse drawing content (w:drawing).
+*
+* Dispatches by graphicData payload:
+* - `pic:pic` → image (handled by imageParser).
+* - `wps:wsp` with `<wps:txbx>` → text-box; returns null so
+*   `blockContentParser.enrichParagraphTextBoxes` can rebuild the shape
+*   with its inner paragraph content (it needs the style/numbering/theme
+*   context that is only available at the block parser level).
+* - `wps:wsp` without text body → generic shape; parsed via
+*   `shapeParser.parseShapeFromDrawing` into a `ShapeContent`.
+*/
+function parseDrawingContent(element, rels, media) {
+	if (shouldPreserveRawShapeDrawing(element)) return {
+		type: "drawing",
+		image: {
+			type: "image",
+			rId: "",
+			size: {
+				width: 0,
+				height: 0
+			},
+			wrap: { type: "inline" }
+		},
+		rawXml: elementToXml(element)
+	};
+	const shape = parseShapeFromDrawing(element);
+	if (shape) return {
+		type: "shape",
+		shape
+	};
+	const image = parseImage(element, rels ?? void 0, media ?? void 0);
+	if (!image) return null;
+	const drawing = {
+		type: "drawing",
+		image
+	};
+	if (!image.src) drawing.rawXml = elementToXml(element);
+	return drawing;
+}
+/**
+* Get the local name of an element (without namespace prefix)
+*/
+function getLocalName(name) {
+	if (!name) return "";
+	const colonIndex = name.indexOf(":");
+	return colonIndex !== -1 ? name.slice(colonIndex + 1) : name;
+}
+/**
+* Parse all content within a run element
+*/
+function parseRunContents(runElement, rels, media, rootXmlns = {}) {
+	const contents = [];
+	const children = getChildElements(runElement);
+	for (const child of children) switch (getLocalName(child.name)) {
+		case "t":
+			contents.push(parseTextContent(child));
+			break;
+		case "tab":
+			contents.push(parseTabContent());
+			break;
+		case "br":
+			contents.push(parseBreakContent(child));
+			break;
+		case "sym":
+			contents.push(parseSymbolContent(child));
+			break;
+		case "footnoteReference":
+			contents.push(parseFootnoteReference(child));
+			break;
+		case "endnoteReference":
+			contents.push(parseEndnoteReference(child));
+			break;
+		case "fldChar":
+			contents.push(parseFieldChar(child));
+			break;
+		case "instrText":
+			contents.push(parseInstrText(child));
+			break;
+		case "softHyphen":
+			contents.push({ type: "softHyphen" });
+			break;
+		case "noBreakHyphen":
+			contents.push({ type: "noBreakHyphen" });
+			break;
+		case "drawing": {
+			const drawing = parseDrawingContent(child, rels, media);
+			if (drawing) contents.push(drawing);
+			break;
+		}
+		case "pict": {
+			const vmlDrawing = parseVmlImageContent(child, rels, media, rootXmlns);
+			if (vmlDrawing) contents.push(vmlDrawing);
+			break;
+		}
+		case "object": break;
+		case "rPr": break;
+		case "lastRenderedPageBreak": break;
+		case "cr":
+			contents.push({
+				type: "break",
+				breakType: "textWrapping"
+			});
+			break;
+		case "AlternateContent": {
+			const alternateChildren = getChildElements(child);
+			const choiceEl = alternateChildren.find((el) => getLocalName(el.name) === "Choice");
+			const fallbackEl = alternateChildren.find((el) => getLocalName(el.name) === "Fallback");
+			const fallbackPict = fallbackEl ? getChildElements(fallbackEl).find((el) => getLocalName(el.name) === "pict") : void 0;
+			const fallbackVml = fallbackPict ? parseVmlImageContent(fallbackPict, rels, media, rootXmlns) : null;
+			if (fallbackVml?.image.src) {
+				fallbackVml.rawXml = elementToXml(cloneWithXmlnsDeclarations(child, rootXmlns));
+				contents.push(fallbackVml);
+				break;
+			}
+			const targetEl = choiceEl ?? fallbackEl;
+			if (targetEl) for (const innerChild of getChildElements(targetEl)) {
+				const innerName = getLocalName(innerChild.name);
+				if (innerName === "drawing") {
+					const innerDrawing = parseDrawingContent(innerChild, rels, media);
+					if (innerDrawing) {
+						if (innerDrawing.type === "drawing" && !innerDrawing.image.src) innerDrawing.rawXml = elementToXml(child);
+						contents.push(innerDrawing);
+					}
+				} else if (innerName === "pict") {
+					const innerVml = parseVmlImageContent(innerChild, rels, media, rootXmlns);
+					if (innerVml) {
+						innerVml.rawXml = elementToXml(cloneWithXmlnsDeclarations(child, rootXmlns));
+						contents.push(innerVml);
+					}
+				}
+			}
+			break;
+		}
+		case "footnoteRef":
+		case "endnoteRef": break;
+		case "separator":
+		case "continuationSeparator": break;
+		default: break;
+	}
+	return contents;
+}
+/**
+* Parse a run element (w:r)
+*
+* @param node - The w:r XML element
+* @param styles - Style map for resolving style references
+* @param theme - Theme for resolving theme colors/fonts
+* @param rels - Relationship map for resolving image references
+* @param media - Media files map for image data
+* @returns Parsed Run object
+*/
+function parseRun(node, styles, theme, rels = null, media = null, rootXmlns = {}) {
+	const run = {
+		type: "run",
+		content: []
+	};
+	const rPr = findChild(node, "w", "rPr");
+	if (rPr) {
+		const formattingResult = parseRunProperties(rPr, theme, styles ?? void 0);
+		if (formattingResult) run.formatting = formattingResult;
+		const propertyChangesResult = parseRunPropertyChanges(rPr, theme, styles, run.formatting);
+		if (propertyChangesResult) run.propertyChanges = propertyChangesResult;
+	}
+	run.content = parseRunContents(node, rels, media, mergeXmlnsDeclarations(rootXmlns, node));
+	return run;
+}
+/**
+* Get plain text from a run
+*
+* @param run - Parsed Run object
+* @returns Concatenated text content
+*/
+function getRunText(run) {
+	let text = "";
+	for (const content of run.content) if (content.type === "text") text += content.text;
+	else if (content.type === "tab") text += "	";
+	else if (content.type === "break") if (content.breakType === "page") text += "\f";
+	else text += "\n";
+	else if (content.type === "softHyphen") text += "­";
+	else if (content.type === "noBreakHyphen") text += "‑";
+	return text;
+}
+/**
+* Check if a run contains any actual content
+*
+* @param run - Parsed Run object
+* @returns true if run has visible content
+*/
+function hasContent(run) {
+	return run.content.length > 0;
+}
+/**
+* Check if a run contains a drawing/image
+*
+* @param run - Parsed Run object
+* @returns true if run contains an image
+*/
+function hasImage(run) {
+	return run.content.some((c) => c.type === "drawing");
+}
+/**
+* Get all images from a run
+*
+* @param run - Parsed Run object
+* @returns Array of Image objects
+*/
+function getImages(run) {
+	return run.content.filter((c) => c.type === "drawing").map((c) => c.image);
+}
+/**
+* Check if a run is part of a complex field
+*
+* @param run - Parsed Run object
+* @returns true if run contains field characters
+*/
+function hasFieldChar(run) {
+	return run.content.some((c) => c.type === "fieldChar");
+}
+/**
+* Get field character type if present
+*
+* @param run - Parsed Run object
+* @returns Field character type or null
+*/
+function getFieldCharType(run) {
+	return run.content.find((c) => c.type === "fieldChar")?.charType ?? null;
+}
+//#endregion
+export { getFieldCharType, getImages, getRunText, hasContent, hasFieldChar, hasImage, parseRun, parseRunProperties };

package/dist/docx/sdtProperties.d.ts

@@ -0,0 +1,15 @@
+import { document_d_exports } from "../types/document.js";
+import { XmlElement } from "./xmlParser.js";
+
+//#region src/docx/sdtProperties.d.ts
+/**
+ * Parse `<w:sdtPr>` (and optional `<w:sdtEndPr>`) into {@link SdtProperties}.
+ *
+ * Modeled fields drive addressing / template tooling; `rawPropertiesXml`
+ * and `rawEndPropertiesXml` carry the original bytes for the serializer to
+ * replay unchanged, so the projection only needs to handle what we
+ * actually consume — unmodeled markers are not silently dropped.
+ */
+declare function parseSdtProperties(sdtPr: XmlElement | null | undefined, sdtEndPr?: XmlElement | null | undefined): document_d_exports.SdtProperties;
+//#endregion
+export { parseSdtProperties };