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

package/dist/docx/mathToMathml.js

@@ -0,0 +1,357 @@
+import { findChildByLocalName, getLocalName } from "./xmlParser.js";
+//#region src/docx/mathToMathml.ts
+/**
+* OMML → MathML conversion.
+*
+* Office Math Markup Language (OMML, namespace
+* `http://schemas.openxmlformats.org/officeDocument/2006/math`) is what
+* `<m:oMath>` / `<m:oMathPara>` carry inside `.docx`. OMML and MathML cover
+* the same equation primitives, and Microsoft ships an XSLT
+* (`OMML2MML.XSL`) that maps the two for Office's "save as MathML" feature.
+*
+* This module is a focused TypeScript implementation that walks the parsed
+* XML tree produced by folio's parser (`XmlElement` from `./xmlParser`) and
+* emits a MathML XML string suitable for direct injection into the DOM via
+* `innerHTML` on a `<math>` host element. All Tier 1 desktop browsers
+* render MathML Core natively (Firefox, Safari, Chromium ≥ 24 — Igalia's
+* MathML revival shipped in Chrome 109, 2023), so the painter does not need
+* KaTeX or MathJax on top.
+*
+* Coverage targets the OMML elements that appear in legal-doc and
+* expert-report use cases: fractions, sub/superscripts, n-ary operators
+* (Σ ∫ ∏ ⋃), radicals, delimiters, matrices, accents, plus the run/text
+* primitives. Unknown OMML elements degrade to a `<mrow>` of their
+* children rather than dropping content.
+*
+* Structural mapping is informed by Microsoft's public OMML2MML.XSL
+* (BSD-style licence) — we borrow the element correspondence table but
+* implement against folio's own `XmlElement` rather than vendoring the
+* stylesheet.
+*/
+/**
+* Convert an OMML element (`<m:oMath>` or `<m:oMathPara>`) into a MathML
+* XML string.
+*
+* The returned string is the full `<math>...</math>` element including the
+* MathML namespace, ready to set via `Element.innerHTML` or
+* `Range.createContextualFragment`. Returns `null` if `omml` is not an
+* OMML root element or contains no convertible children.
+*/
+function ommlToMathml(omml) {
+	const local = omml.name ? getLocalName(omml.name) : "";
+	if (local !== "oMath" && local !== "oMathPara") return null;
+	const isBlock = local === "oMathPara";
+	let bodyMathml;
+	if (isBlock) {
+		const oMathChildren = (omml.elements ?? []).filter((child) => child.type === "element" && getLocalName(child.name ?? "") === "oMath");
+		if (oMathChildren.length > 0) bodyMathml = oMathChildren.map((child) => renderChildren(child)).join("");
+		else bodyMathml = renderChildren(omml);
+	} else bodyMathml = renderChildren(omml);
+	if (!bodyMathml) return null;
+	return `<math xmlns="http://www.w3.org/1998/Math/MathML"${isBlock ? " display=\"block\"" : ""}>${bodyMathml}</math>`;
+}
+const MATH_OPERATOR_HINT = /* @__PURE__ */ new Set([
+	"+",
+	"-",
+	"=",
+	"<",
+	">",
+	"≤",
+	"≥",
+	"≠",
+	"±",
+	"×",
+	"÷",
+	"·",
+	"∙",
+	"/",
+	"*",
+	"(",
+	")",
+	"[",
+	"]",
+	"{",
+	"}",
+	"|",
+	",",
+	";",
+	":",
+	"→",
+	"←",
+	"↔",
+	"⇒",
+	"⇐",
+	"∈",
+	"∉",
+	"⊂",
+	"⊃",
+	"∪",
+	"∩",
+	"∀",
+	"∃",
+	"∂",
+	"∇",
+	"∞",
+	"…"
+]);
+function renderElement(el) {
+	if (el.type === "text") return escapeXml(textValue(el));
+	if (el.type !== "element") return "";
+	switch (el.name ? getLocalName(el.name) : "") {
+		case "oMath":
+		case "oMathPara": return renderChildren(el);
+		case "r": return renderRun(el);
+		case "t": return escapeXml(extractText(el));
+		case "f": return renderFraction(el);
+		case "num":
+		case "den": return wrapMrow(renderChildren(el));
+		case "sSup": return renderScript(el, "msup");
+		case "sSub": return renderScript(el, "msub");
+		case "sSubSup": return renderSubSup(el);
+		case "sPre": return renderPreScript(el);
+		case "rad": return renderRadical(el);
+		case "deg":
+		case "e":
+		case "sup":
+		case "sub":
+		case "fName":
+		case "lim": return wrapMrow(renderChildren(el));
+		case "nary": return renderNary(el);
+		case "d": return renderDelimiter(el);
+		case "m": return renderMatrix(el);
+		case "mr": return renderMatrixRow(el);
+		case "acc": return renderAccent(el);
+		case "bar": return renderBar(el);
+		case "groupChr": return renderGroupChr(el);
+		case "limLow": return renderLimLow(el);
+		case "limUpp": return renderLimUpp(el);
+		case "func": return renderChildren(el);
+		case "box":
+		case "borderBox":
+		case "eqArr": return wrapMrow(renderChildren(el));
+		case "rPr":
+		case "ctrlPr":
+		case "fPr":
+		case "naryPr":
+		case "dPr":
+		case "rPrChange":
+		case "mPr":
+		case "accPr":
+		case "barPr":
+		case "groupChrPr":
+		case "limLowPr":
+		case "limUppPr":
+		case "sSupPr":
+		case "sSubPr":
+		case "sSubSupPr":
+		case "sPrePr":
+		case "radPr":
+		case "boxPr":
+		case "borderBoxPr":
+		case "eqArrPr":
+		case "oMathParaPr":
+		case "funcPr": return "";
+		default: return renderChildren(el);
+	}
+}
+function renderChildren(el) {
+	if (!el.elements) return "";
+	let out = "";
+	for (const child of el.elements) out += renderElement(child);
+	return out;
+}
+/**
+* Convert an `<m:r>` run into a sequence of `<mi>` / `<mn>` / `<mo>`
+* tokens. OMML stores math text in `<m:t>`; we tokenise on
+* letter/digit/operator transitions to mirror MathML's per-token model.
+*/
+function renderRun(run) {
+	const tElems = (run.elements ?? []).filter((c) => c.type === "element" && getLocalName(c.name ?? "") === "t");
+	if (tElems.length === 0) return "";
+	let out = "";
+	for (const tEl of tElems) out += tokenizeMathText(extractText(tEl));
+	return out;
+}
+function tokenizeMathText(text) {
+	if (!text) return "";
+	let out = "";
+	let buf = "";
+	let bufKind = null;
+	const flush = () => {
+		if (!buf) return;
+		if (bufKind === "digit") out += `<mn>${escapeXml(buf)}</mn>`;
+		else out += `<mi>${escapeXml(buf)}</mi>`;
+		buf = "";
+		bufKind = null;
+	};
+	for (const ch of text) {
+		if (ch === " " || ch === "	" || ch === "\n") {
+			flush();
+			out += "<mspace width=\"0.2em\"/>";
+			continue;
+		}
+		const kind = classifyChar(ch);
+		if (kind === "operator") {
+			flush();
+			out += `<mo>${escapeXml(ch)}</mo>`;
+			continue;
+		}
+		if (kind === "digit") {
+			bufKind = "digit";
+			buf += ch;
+			continue;
+		}
+		flush();
+		out += `<mi>${escapeXml(ch)}</mi>`;
+	}
+	flush();
+	return out;
+}
+function classifyChar(ch) {
+	if (ch >= "0" && ch <= "9") return "digit";
+	if (ch === ".") return "digit";
+	if (MATH_OPERATOR_HINT.has(ch)) return "operator";
+	const code = ch.codePointAt(0) ?? 0;
+	if (code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 913 && code <= 937 || code >= 945 && code <= 969 || code >= 1488 && code <= 1514 || code >= 8448 && code <= 8527 || code >= 119808 && code <= 120831) return "letter";
+	return "operator";
+}
+function renderFraction(el) {
+	const num = findChildByLocalName(el, "num");
+	const den = findChildByLocalName(el, "den");
+	const numMml = num ? wrapMrow(renderChildren(num)) : "<mrow/>";
+	const denMml = den ? wrapMrow(renderChildren(den)) : "<mrow/>";
+	const fPr = findChildByLocalName(el, "fPr");
+	const typeEl = fPr ? findChildByLocalName(fPr, "type") : null;
+	return `<mfrac${(typeEl ? getAttrValue(typeEl, "val") : null) === "noBar" ? " linethickness=\"0\"" : ""}>${numMml}${denMml}</mfrac>`;
+}
+function renderScript(el, tag) {
+	const base = findChildByLocalName(el, "e");
+	const script = findChildByLocalName(el, tag === "msup" ? "sup" : "sub");
+	return `<${tag}>${base ? wrapMrow(renderChildren(base)) : "<mrow/>"}${script ? wrapMrow(renderChildren(script)) : "<mrow/>"}</${tag}>`;
+}
+function renderSubSup(el) {
+	const base = findChildByLocalName(el, "e");
+	const sub = findChildByLocalName(el, "sub");
+	const sup = findChildByLocalName(el, "sup");
+	return `<msubsup>${base ? wrapMrow(renderChildren(base)) : "<mrow/>"}${sub ? wrapMrow(renderChildren(sub)) : "<mrow/>"}${sup ? wrapMrow(renderChildren(sup)) : "<mrow/>"}</msubsup>`;
+}
+function renderPreScript(el) {
+	const base = findChildByLocalName(el, "e");
+	const sub = findChildByLocalName(el, "sub");
+	const sup = findChildByLocalName(el, "sup");
+	return `<mmultiscripts>${base ? wrapMrow(renderChildren(base)) : "<mrow/>"}<mprescripts/>${sub ? wrapMrow(renderChildren(sub)) : "<none/>"}${sup ? wrapMrow(renderChildren(sup)) : "<none/>"}</mmultiscripts>`;
+}
+function renderRadical(el) {
+	const deg = findChildByLocalName(el, "deg");
+	const radicand = findChildByLocalName(el, "e");
+	const radMml = radicand ? wrapMrow(renderChildren(radicand)) : "<mrow/>";
+	const degText = deg ? renderChildren(deg) : "";
+	if (!deg || !degText) return `<msqrt>${radMml}</msqrt>`;
+	return `<mroot>${radMml}${wrapMrow(degText)}</mroot>`;
+}
+function renderNary(el) {
+	const sub = findChildByLocalName(el, "sub");
+	const sup = findChildByLocalName(el, "sup");
+	const body = findChildByLocalName(el, "e");
+	const naryPr = findChildByLocalName(el, "naryPr");
+	const chrEl = naryPr ? findChildByLocalName(naryPr, "chr") : null;
+	const chr = (chrEl ? getAttrValue(chrEl, "val") : null) || "∫";
+	const limLocEl = naryPr ? findChildByLocalName(naryPr, "limLoc") : null;
+	const limLoc = (limLocEl ? getAttrValue(limLocEl, "val") : null) || "subSup";
+	const opMml = `<mo>${escapeXml(chr)}</mo>`;
+	const subMml = sub ? wrapMrow(renderChildren(sub)) : "";
+	const supMml = sup ? wrapMrow(renderChildren(sup)) : "";
+	const bodyMml = body ? wrapMrow(renderChildren(body)) : "<mrow/>";
+	let nary;
+	if (subMml && supMml) nary = limLoc === "undOvr" ? `<munderover>${opMml}${subMml}${supMml}</munderover>` : `<msubsup>${opMml}${subMml}${supMml}</msubsup>`;
+	else if (subMml) nary = limLoc === "undOvr" ? `<munder>${opMml}${subMml}</munder>` : `<msub>${opMml}${subMml}</msub>`;
+	else if (supMml) nary = limLoc === "undOvr" ? `<mover>${opMml}${supMml}</mover>` : `<msup>${opMml}${supMml}</msup>`;
+	else nary = opMml;
+	return `<mrow>${nary}${bodyMml}</mrow>`;
+}
+function renderDelimiter(el) {
+	const dPr = findChildByLocalName(el, "dPr");
+	const begChrEl = dPr ? findChildByLocalName(dPr, "begChr") : null;
+	const endChrEl = dPr ? findChildByLocalName(dPr, "endChr") : null;
+	const sepChrEl = dPr ? findChildByLocalName(dPr, "sepChr") : null;
+	const begChr = begChrEl ? getAttrValue(begChrEl, "val") ?? "(" : "(";
+	const endChr = endChrEl ? getAttrValue(endChrEl, "val") ?? ")" : ")";
+	const sepChr = sepChrEl ? getAttrValue(sepChrEl, "val") ?? "|" : "|";
+	const inner = (el.elements ?? []).filter((c) => c.type === "element" && getLocalName(c.name ?? "") === "e").map((c) => wrapMrow(renderChildren(c))).join(`<mo>${escapeXml(sepChr)}</mo>`);
+	return `<mrow><mo>${escapeXml(begChr)}</mo>${inner}<mo>${escapeXml(endChr)}</mo></mrow>`;
+}
+function renderMatrix(el) {
+	return `<mtable>${(el.elements ?? []).filter((c) => c.type === "element" && getLocalName(c.name ?? "") === "mr").map(renderMatrixRow).join("")}</mtable>`;
+}
+function renderMatrixRow(row) {
+	return `<mtr>${(row.elements ?? []).filter((c) => c.type === "element" && getLocalName(c.name ?? "") === "e").map((c) => `<mtd>${renderChildren(c)}</mtd>`).join("")}</mtr>`;
+}
+function renderAccent(el) {
+	const accPr = findChildByLocalName(el, "accPr");
+	const chrEl = accPr ? findChildByLocalName(accPr, "chr") : null;
+	const chr = chrEl ? getAttrValue(chrEl, "val") ?? "̂" : "̂";
+	const base = findChildByLocalName(el, "e");
+	return `<mover accent="true">${base ? wrapMrow(renderChildren(base)) : "<mrow/>"}<mo>${escapeXml(chr)}</mo></mover>`;
+}
+function renderBar(el) {
+	const barPr = findChildByLocalName(el, "barPr");
+	const posEl = barPr ? findChildByLocalName(barPr, "pos") : null;
+	const pos = posEl ? getAttrValue(posEl, "val") ?? "top" : "top";
+	const base = findChildByLocalName(el, "e");
+	const baseMml = base ? wrapMrow(renderChildren(base)) : "<mrow/>";
+	const bar = "<mo stretchy=\"true\">¯</mo>";
+	return pos === "bot" ? `<munder>${baseMml}${bar}</munder>` : `<mover>${baseMml}${bar}</mover>`;
+}
+function renderGroupChr(el) {
+	const groupChrPr = findChildByLocalName(el, "groupChrPr");
+	const posEl = groupChrPr ? findChildByLocalName(groupChrPr, "pos") : null;
+	const pos = posEl ? getAttrValue(posEl, "val") ?? "bot" : "bot";
+	const chrEl = groupChrPr ? findChildByLocalName(groupChrPr, "chr") : null;
+	const defaultChr = pos === "top" ? "⏞" : "⏟";
+	const chr = chrEl ? getAttrValue(chrEl, "val") ?? defaultChr : defaultChr;
+	const base = findChildByLocalName(el, "e");
+	const baseMml = base ? wrapMrow(renderChildren(base)) : "<mrow/>";
+	const grouper = `<mo stretchy="true">${escapeXml(chr)}</mo>`;
+	return pos === "top" ? `<mover>${baseMml}${grouper}</mover>` : `<munder>${baseMml}${grouper}</munder>`;
+}
+function renderLimLow(el) {
+	const base = findChildByLocalName(el, "e");
+	const lim = findChildByLocalName(el, "lim");
+	return `<munder>${base ? wrapMrow(renderChildren(base)) : "<mrow/>"}${lim ? wrapMrow(renderChildren(lim)) : "<mrow/>"}</munder>`;
+}
+function renderLimUpp(el) {
+	const base = findChildByLocalName(el, "e");
+	const lim = findChildByLocalName(el, "lim");
+	return `<mover>${base ? wrapMrow(renderChildren(base)) : "<mrow/>"}${lim ? wrapMrow(renderChildren(lim)) : "<mrow/>"}</mover>`;
+}
+function wrapMrow(body) {
+	if (!body) return "<mrow/>";
+	return `<mrow>${body}</mrow>`;
+}
+function extractText(el) {
+	if (el.type === "text") return textValue(el);
+	if (!el.elements) return "";
+	let out = "";
+	for (const child of el.elements) if (child.type === "text") out += textValue(child);
+	else out += extractText(child);
+	return out;
+}
+function textValue(el) {
+	const v = el.text;
+	if (typeof v === "string") return v;
+	if (typeof v === "number" || typeof v === "boolean") return String(v);
+	return "";
+}
+function getAttrValue(el, localAttr) {
+	if (!el.attributes) return;
+	for (const [k, v] of Object.entries(el.attributes)) if (k === localAttr || k.endsWith(`:${localAttr}`)) {
+		if (typeof v === "string") return v;
+		if (v === void 0) return;
+		return String(v);
+	}
+}
+function escapeXml(s) {
+	return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+}
+//#endregion
+export { ommlToMathml };

package/dist/docx/modelValidation.d.ts

@@ -0,0 +1,13 @@
+import { document_d_exports } from "../types/document.js";
+import { ValidateDocumentModelIssue, ValidateDocumentModelResult } from "@stll/docx-core";
+
+//#region src/docx/modelValidation.d.ts
+declare class DocxModelValidationError extends Error {
+  readonly issues: ValidateDocumentModelIssue[];
+  constructor(context: string, issues: ValidateDocumentModelIssue[]);
+}
+declare const validateFolioDocumentModel: (document: document_d_exports.Document) => ValidateDocumentModelResult;
+declare const assertValidFolioDocumentModel: (document: document_d_exports.Document, context: string) => void;
+declare const formatDocumentModelIssues: (issues: ValidateDocumentModelIssue[]) => string[];
+//#endregion
+export { DocxModelValidationError, assertValidFolioDocumentModel, formatDocumentModelIssues, validateFolioDocumentModel };

package/dist/docx/modelValidation.js

@@ -0,0 +1,21 @@
+import { validateDocumentModel } from "@stll/docx-core";
+//#region src/docx/modelValidation.ts
+var DocxModelValidationError = class extends Error {
+	issues;
+	constructor(context, issues) {
+		super(`${context}:\n${formatDocumentModelIssues(issues).join("\n")}`);
+		this.name = "DocxModelValidationError";
+		this.issues = issues;
+	}
+};
+const validateFolioDocumentModel = (document) => validateDocumentModel(document);
+const assertValidFolioDocumentModel = (document, context) => {
+	const validation = validateFolioDocumentModel(document);
+	if (validation.valid) return;
+	throw new DocxModelValidationError(context, validation.issues);
+};
+const formatDocumentModelIssues = (issues) => issues.map((issue) => {
+	return `${issue.severity === "warning" ? "DOCX model warning" : "DOCX model error"} at ${issue.path}: ${issue.message}`;
+});
+//#endregion
+export { DocxModelValidationError, assertValidFolioDocumentModel, formatDocumentModelIssues, validateFolioDocumentModel };

package/dist/docx/normalizeBaseDirection.d.ts

@@ -0,0 +1,12 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/docx/normalizeBaseDirection.d.ts
+/**
+ * Return a copy of `doc` with `bidi` filled in for undecided RTL-led body
+ * paragraphs (including those nested in tables and block content controls).
+ * A paragraph whose direction is set directly OR via its style / doc defaults
+ * is left untouched.
+ */
+declare const normalizeBaseDirection: (doc: document_d_exports.Document) => document_d_exports.Document;
+//#endregion
+export { normalizeBaseDirection };

package/dist/docx/normalizeBaseDirection.js

@@ -0,0 +1,81 @@
+import { detectBaseDirection } from "../utils/baseDirection.js";
+import { createStyleResolver } from "../prosemirror/styles/styleResolver.js";
+//#region src/docx/normalizeBaseDirection.ts
+const runText = (run) => {
+	let text = "";
+	for (const piece of run.content) if (piece.type === "text") text += piece.text;
+	return text;
+};
+const hyperlinkText = (link) => {
+	let text = "";
+	for (const child of link.children) if (child.type === "run") text += runText(child);
+	return text;
+};
+function paragraphContentText(items) {
+	let text = "";
+	for (const item of items) text += singleItemText(item);
+	return text;
+}
+function singleItemText(item) {
+	switch (item.type) {
+		case "run": return runText(item);
+		case "hyperlink": return hyperlinkText(item);
+		case "simpleField":
+		case "insertion":
+		case "moveTo": return paragraphContentText(item.content);
+		case "complexField": return paragraphContentText(item.fieldResult);
+		case "inlineSdt": return paragraphContentText(item.content);
+		default: return "";
+	}
+}
+const paragraphText = (paragraph) => paragraphContentText(paragraph.content);
+const normalizeParagraph = (paragraph, styles) => {
+	if ((paragraph.formatting?.bidi ?? styles.resolveParagraphStyle(paragraph.formatting?.styleId).paragraphFormatting?.bidi) != null) return paragraph;
+	if (detectBaseDirection(paragraphText(paragraph)) !== "rtl") return paragraph;
+	return {
+		...paragraph,
+		formatting: {
+			...paragraph.formatting,
+			bidi: true
+		}
+	};
+};
+const normalizeTable = (table, styles) => ({
+	...table,
+	rows: table.rows.map((row) => ({
+		...row,
+		cells: row.cells.map((cell) => ({
+			...cell,
+			content: cell.content.map((block) => block.type === "paragraph" ? normalizeParagraph(block, styles) : normalizeTable(block, styles))
+		}))
+	}))
+});
+const normalizeBlocks = (blocks, styles) => blocks.map((block) => {
+	if (block.type === "paragraph") return normalizeParagraph(block, styles);
+	if (block.type === "table") return normalizeTable(block, styles);
+	return {
+		...block,
+		content: normalizeBlocks(block.content, styles)
+	};
+});
+/**
+* Return a copy of `doc` with `bidi` filled in for undecided RTL-led body
+* paragraphs (including those nested in tables and block content controls).
+* A paragraph whose direction is set directly OR via its style / doc defaults
+* is left untouched.
+*/
+const normalizeBaseDirection = (doc) => {
+	const styles = createStyleResolver(doc.package.styles);
+	return {
+		...doc,
+		package: {
+			...doc.package,
+			document: {
+				...doc.package.document,
+				content: normalizeBlocks(doc.package.document.content, styles)
+			}
+		}
+	};
+};
+//#endregion
+export { normalizeBaseDirection };

package/dist/docx/notePropertiesParser.d.ts

@@ -0,0 +1,16 @@
+import { document_d_exports } from "../types/document.js";
+import { XmlElement } from "./xmlParser.js";
+
+//#region src/docx/notePropertiesParser.d.ts
+/**
+ * Parse footnote properties from w:footnotePr element
+ * (Can appear in w:sectPr or w:settings)
+ */
+declare function parseFootnoteProperties(element: XmlElement | null): document_d_exports.FootnoteProperties;
+/**
+ * Parse endnote properties from w:endnotePr element
+ * (Can appear in w:sectPr or w:settings)
+ */
+declare function parseEndnoteProperties(element: XmlElement | null): document_d_exports.EndnoteProperties;
+//#endregion
+export { parseEndnoteProperties, parseFootnoteProperties };

package/dist/docx/notePropertiesParser.js

@@ -0,0 +1,99 @@
+import { findChild, getAttribute, parseNumericAttribute } from "./xmlParser.js";
+import { NumberFormatSchema, narrowEnum } from "./parserEnums.js";
+//#region src/docx/notePropertiesParser.ts
+function parseNumberFormat(numFmtAttr) {
+	return narrowEnum(numFmtAttr, NumberFormatSchema);
+}
+/**
+* Parse footnote position
+*/
+function parseFootnotePosition(posAttr) {
+	switch (posAttr) {
+		case "pageBottom": return "pageBottom";
+		case "beneathText": return "beneathText";
+		case "sectEnd": return "sectEnd";
+		case "docEnd": return "docEnd";
+		default: return;
+	}
+}
+/**
+* Parse endnote position
+*/
+function parseEndnotePosition(posAttr) {
+	switch (posAttr) {
+		case "sectEnd": return "sectEnd";
+		case "docEnd": return "docEnd";
+		default: return;
+	}
+}
+/**
+* Parse number restart type
+*/
+function parseNumberRestart(restartAttr) {
+	switch (restartAttr) {
+		case "continuous": return "continuous";
+		case "eachSect": return "eachSect";
+		case "eachPage": return "eachPage";
+		default: return;
+	}
+}
+/**
+* Parse footnote properties from w:footnotePr element
+* (Can appear in w:sectPr or w:settings)
+*/
+function parseFootnoteProperties(element) {
+	const props = {};
+	if (!element) return props;
+	const posEl = findChild(element, "w", "pos");
+	if (posEl) {
+		const position = parseFootnotePosition(getAttribute(posEl, "w", "val"));
+		if (position !== void 0) props.position = position;
+	}
+	const numFmtEl = findChild(element, "w", "numFmt");
+	if (numFmtEl) {
+		const numFmt = parseNumberFormat(getAttribute(numFmtEl, "w", "val"));
+		if (numFmt !== void 0) props.numFmt = numFmt;
+	}
+	const numStartEl = findChild(element, "w", "numStart");
+	if (numStartEl) {
+		const numStart = parseNumericAttribute(numStartEl, "w", "val");
+		if (numStart != null) props.numStart = numStart;
+	}
+	const numRestartEl = findChild(element, "w", "numRestart");
+	if (numRestartEl) {
+		const numRestart = parseNumberRestart(getAttribute(numRestartEl, "w", "val"));
+		if (numRestart !== void 0) props.numRestart = numRestart;
+	}
+	return props;
+}
+/**
+* Parse endnote properties from w:endnotePr element
+* (Can appear in w:sectPr or w:settings)
+*/
+function parseEndnoteProperties(element) {
+	const props = {};
+	if (!element) return props;
+	const posEl = findChild(element, "w", "pos");
+	if (posEl) {
+		const position = parseEndnotePosition(getAttribute(posEl, "w", "val"));
+		if (position !== void 0) props.position = position;
+	}
+	const numFmtEl = findChild(element, "w", "numFmt");
+	if (numFmtEl) {
+		const numFmt = parseNumberFormat(getAttribute(numFmtEl, "w", "val"));
+		if (numFmt !== void 0) props.numFmt = numFmt;
+	}
+	const numStartEl = findChild(element, "w", "numStart");
+	if (numStartEl) {
+		const numStart = parseNumericAttribute(numStartEl, "w", "val");
+		if (numStart != null) props.numStart = numStart;
+	}
+	const numRestartEl = findChild(element, "w", "numRestart");
+	if (numRestartEl) {
+		const numRestart = parseNumberRestart(getAttribute(numRestartEl, "w", "val"));
+		if (numRestart !== void 0) props.numRestart = numRestart;
+	}
+	return props;
+}
+//#endregion
+export { parseEndnoteProperties, parseFootnoteProperties };