@stll/docx-core 0.0.1-placeholder.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,1927 @@
+import JSZip from "jszip";
+import { panic } from "better-result";
+//#region src/serialize/xml.ts
+const ILLEGAL_XML_CHARS_RE = /[^\u0009\u000A\u000D\u0020-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}]/gu;
+const stripIllegalXmlChars = (value) => value.replace(ILLEGAL_XML_CHARS_RE, "");
+const escapeXml = (value) => stripIllegalXmlChars(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+const attr = (name, value) => value === void 0 ? "" : ` ${name}="${escapeXml(String(value))}"`;
+//#endregion
+//#region src/serialize/docx.ts
+const DEFAULT_FOOTER_REL_ID = "rId10";
+const DEFAULT_FOOTER_PART_NAME = "footer1.xml";
+const FOOTER_LABEL_FALLBACK = {
+	page: "Page",
+	of: "of"
+};
+const FOOTER_LABELS = {
+	en: FOOTER_LABEL_FALLBACK,
+	cs: {
+		page: "Strana",
+		of: "z"
+	},
+	sk: {
+		page: "Strana",
+		of: "z"
+	},
+	de: {
+		page: "Seite",
+		of: "von"
+	},
+	fr: {
+		page: "Page",
+		of: "sur"
+	},
+	es: {
+		page: "Página",
+		of: "de"
+	},
+	it: {
+		page: "Pagina",
+		of: "di"
+	},
+	pl: {
+		page: "Strona",
+		of: "z"
+	},
+	pt: {
+		page: "Página",
+		of: "de"
+	},
+	nl: {
+		page: "Pagina",
+		of: "van"
+	},
+	hu: {
+		page: "Oldal",
+		of: "/"
+	}
+};
+const resolveFooterLabels = (language) => {
+	if (!language) return FOOTER_LABEL_FALLBACK;
+	return FOOTER_LABELS[language.toLowerCase().split(/[-_]/u)[0] ?? ""] ?? FOOTER_LABEL_FALLBACK;
+};
+const buildFooterXml = (language) => {
+	const { page, of } = resolveFooterLabels(language);
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:ftr xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:p><w:pPr><w:pStyle w:val="Footer"/><w:jc w:val="center"/></w:pPr><w:r><w:rPr><w:sz w:val="18"/></w:rPr><w:t xml:space="preserve">${escapeXml(page)} </w:t></w:r><w:fldSimple w:instr="PAGE   \\* MERGEFORMAT"><w:r><w:rPr><w:sz w:val="18"/></w:rPr><w:t>1</w:t></w:r></w:fldSimple><w:r><w:rPr><w:sz w:val="18"/></w:rPr><w:t xml:space="preserve"> ${escapeXml(of)} </w:t></w:r><w:fldSimple w:instr="NUMPAGES   \\* MERGEFORMAT"><w:r><w:rPr><w:sz w:val="18"/></w:rPr><w:t>1</w:t></w:r></w:fldSimple></w:p></w:ftr>`;
+};
+const contentTypesXml = (hasNumbering) => [
+	"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+	"<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">",
+	"<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>",
+	"<Default Extension=\"xml\" ContentType=\"application/xml\"/>",
+	"<Override PartName=\"/word/document.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\"/>",
+	"<Override PartName=\"/word/styles.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml\"/>",
+	hasNumbering ? "<Override PartName=\"/word/numbering.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml\"/>" : "",
+	`<Override PartName="/word/${DEFAULT_FOOTER_PART_NAME}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/>`,
+	"<Override PartName=\"/docProps/core.xml\" ContentType=\"application/vnd.openxmlformats-package.core-properties+xml\"/>",
+	"<Override PartName=\"/docProps/app.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.extended-properties+xml\"/>",
+	"</Types>"
+].join("");
+const ROOT_RELS_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\"><Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"word/document.xml\"/><Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties\" Target=\"docProps/core.xml\"/><Relationship Id=\"rId3\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties\" Target=\"docProps/app.xml\"/></Relationships>";
+const documentRelsXml = (hasNumbering) => [
+	"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+	"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">",
+	"<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles\" Target=\"styles.xml\"/>",
+	hasNumbering ? "<Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering\" Target=\"numbering.xml\"/>" : "",
+	`<Relationship Id="${DEFAULT_FOOTER_REL_ID}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer" Target="${DEFAULT_FOOTER_PART_NAME}"/>`,
+	"</Relationships>"
+].join("");
+const APP_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Properties xmlns=\"http://schemas.openxmlformats.org/officeDocument/2006/extended-properties\" xmlns:vt=\"http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes\"><Application>stella</Application></Properties>";
+const serializeDocumentToDocx = async (document, options = {}) => {
+	const zip = new JSZip();
+	const hasNumbering = hasNumberingDefinitions(document.package.numbering);
+	zip.file("[Content_Types].xml", contentTypesXml(hasNumbering));
+	zip.folder("_rels")?.file(".rels", ROOT_RELS_XML);
+	zip.folder("docProps")?.file("app.xml", APP_XML);
+	zip.folder("docProps")?.file("core.xml", serializeCoreProperties(document));
+	const word = zip.folder("word");
+	word?.file("document.xml", serializeDocumentXml(document));
+	word?.file("styles.xml", serializeStyles(document.package.styles));
+	if (hasNumbering) word?.file("numbering.xml", serializeNumbering(document.package.numbering));
+	word?.file(DEFAULT_FOOTER_PART_NAME, buildFooterXml(options.language));
+	word?.folder("_rels")?.file("document.xml.rels", documentRelsXml(hasNumbering));
+	return await zip.generateAsync({
+		type: "arraybuffer",
+		compression: "DEFLATE",
+		compressionOptions: { level: 6 }
+	});
+};
+const hasNumberingDefinitions = (numbering) => (numbering?.abstractNums.length ?? 0) > 0 || (numbering?.nums.length ?? 0) > 0;
+const serializeDocumentXml = (document) => {
+	const body = document.package.document;
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><w:body>${body.content.map(serializeBlock).join("")}${serializeSectionProperties(body.finalSectionProperties ?? {})}</w:body></w:document>`;
+};
+const serializeBlock = (block) => {
+	switch (block.type) {
+		case "paragraph": return serializeParagraph(block);
+		case "table": return serializeTable(block);
+		case "blockSdt": return "";
+		default: return "";
+	}
+};
+const serializeParagraph = (paragraph) => {
+	return `<w:p>${serializeParagraphProperties(paragraph)}${paragraph.content.map(serializeParagraphContent).join("")}</w:p>`;
+};
+const serializeParagraphProperties = (paragraph) => {
+	const formatting = paragraph.formatting;
+	if (!formatting && !paragraph.sectionProperties) return "";
+	const parts = [];
+	if (formatting?.styleId) parts.push(`<w:pStyle w:val="${escapeXml(formatting.styleId)}"/>`);
+	if (formatting?.keepNext) parts.push("<w:keepNext/>");
+	if (formatting?.keepLines) parts.push("<w:keepLines/>");
+	if (formatting?.pageBreakBefore) parts.push("<w:pageBreakBefore/>");
+	if (formatting?.numPr?.numId !== void 0) parts.push(`<w:numPr><w:ilvl w:val="${formatting.numPr.ilvl}"/><w:numId w:val="${formatting.numPr.numId}"/></w:numPr>`);
+	if (formatting?.spaceBefore !== void 0 || formatting?.spaceAfter !== void 0 || formatting?.lineSpacing !== void 0) parts.push(`<w:spacing${attr("w:before", formatting.spaceBefore)}${attr("w:after", formatting.spaceAfter)}${attr("w:line", formatting.lineSpacing)}${attr("w:lineRule", formatting.lineSpacingRule)}/>`);
+	if (formatting?.indentLeft !== void 0 || formatting?.indentRight !== void 0 || formatting?.indentFirstLine !== void 0) parts.push(`<w:ind${attr("w:left", formatting.indentLeft)}${attr("w:right", formatting.indentRight)}${attr(formatting.hangingIndent ? "w:hanging" : "w:firstLine", formatting.indentFirstLine)}/>`);
+	if (formatting?.alignment) parts.push(`<w:jc w:val="${formatting.alignment}"/>`);
+	if (paragraph.sectionProperties) parts.push(serializeSectionProperties(paragraph.sectionProperties));
+	return `<w:pPr>${parts.join("")}</w:pPr>`;
+};
+const serializeParagraphContent = (content) => {
+	switch (content.type) {
+		case "run": return serializeRun(content);
+		case "hyperlink":
+		case "bookmarkStart":
+		case "bookmarkEnd":
+		case "simpleField":
+		case "complexField":
+		case "inlineSdt":
+		case "commentRangeStart":
+		case "commentRangeEnd":
+		case "commentReference":
+		case "insertion":
+		case "deletion":
+		case "moveFrom":
+		case "moveTo":
+		case "moveFromRangeStart":
+		case "moveFromRangeEnd":
+		case "moveToRangeStart":
+		case "moveToRangeEnd":
+		case "mathEquation": return "";
+		default: return "";
+	}
+};
+const serializeRun = (run) => {
+	return `<w:r>${serializeRunProperties(run.formatting)}${run.content.map(serializeRunContent).join("")}</w:r>`;
+};
+const serializeRunProperties = (formatting) => {
+	if (!formatting) return "";
+	const parts = [];
+	if (formatting.styleId) parts.push(`<w:rStyle w:val="${escapeXml(formatting.styleId)}"/>`);
+	if (formatting.bold) parts.push("<w:b/>");
+	if (formatting.italic) parts.push("<w:i/>");
+	if (formatting.allCaps) parts.push("<w:caps/>");
+	if (formatting.smallCaps) parts.push("<w:smallCaps/>");
+	if (formatting.highlight) parts.push(`<w:highlight w:val="${formatting.highlight}"/>`);
+	if (formatting.fontSize !== void 0) parts.push(`<w:sz w:val="${formatting.fontSize}"/>`);
+	if (formatting.fontFamily) parts.push(`<w:rFonts${attr("w:ascii", formatting.fontFamily.ascii)}${attr("w:hAnsi", formatting.fontFamily.hAnsi)}${attr("w:cs", formatting.fontFamily.cs)}/>`);
+	return parts.length > 0 ? `<w:rPr>${parts.join("")}</w:rPr>` : "";
+};
+const serializeRunContent = (content) => {
+	switch (content.type) {
+		case "text": return `<w:t${content.preserveSpace ? " xml:space=\"preserve\"" : ""}>${escapeXml(content.text)}</w:t>`;
+		case "tab": return "<w:tab/>";
+		case "break": return `<w:br${attr("w:type", content.breakType)}/>`;
+		case "symbol": return `<w:sym w:font="${escapeXml(content.font)}" w:char="${escapeXml(content.char)}"/>`;
+		case "footnoteRef": return `<w:footnoteReference w:id="${content.id}"/>`;
+		case "endnoteRef": return `<w:endnoteReference w:id="${content.id}"/>`;
+		case "fieldChar":
+		case "instrText":
+		case "softHyphen":
+		case "noBreakHyphen":
+		case "drawing":
+		case "shape": return "";
+		default: return "";
+	}
+};
+const serializeTable = (table) => {
+	const columnCount = Math.max(0, ...table.rows.map((row) => row.cells.length));
+	const gridWidth = columnCount > 0 ? Math.max(1, Math.floor(9e3 / columnCount)) : 9e3;
+	const grid = columnCount > 0 ? `<w:tblGrid>${Array.from({ length: columnCount }, () => `<w:gridCol w:w="${gridWidth}"/>`).join("")}</w:tblGrid>` : "<w:tblGrid/>";
+	const tableBorderXml = renderTableBorders(table);
+	const cellBorderXml = renderCellBorders(table);
+	return [
+		"<w:tbl>",
+		"<w:tblPr><w:tblW w:w=\"0\" w:type=\"auto\"/><w:tblBorders>",
+		tableBorderXml,
+		"</w:tblBorders></w:tblPr>",
+		grid,
+		table.rows.map((row) => `<w:tr>${row.cells.map((cell) => `<w:tc><w:tcPr><w:tcW w:w="0" w:type="auto"/><w:tcBorders>${cellBorderXml}</w:tcBorders></w:tcPr>${cell.content.map(serializeBlock).join("")}</w:tc>`).join("")}</w:tr>`).join(""),
+		"</w:tbl>"
+	].join("");
+};
+const renderTableBorders = (table) => {
+	const borders = table.formatting?.borders;
+	if (!borders) return defaultBorderXml();
+	return [
+		borderEdgeXml("w:top", borders.top),
+		borderEdgeXml("w:left", borders.left),
+		borderEdgeXml("w:bottom", borders.bottom),
+		borderEdgeXml("w:right", borders.right),
+		borderEdgeXml("w:insideH", borders.insideH),
+		borderEdgeXml("w:insideV", borders.insideV)
+	].join("");
+};
+const renderCellBorders = (table) => {
+	const borders = table.formatting?.borders;
+	if (!borders) return defaultBorderXml();
+	return [
+		borderEdgeXml("w:top", borders.top),
+		borderEdgeXml("w:left", borders.left),
+		borderEdgeXml("w:bottom", borders.bottom),
+		borderEdgeXml("w:right", borders.right)
+	].join("");
+};
+const borderEdgeXml = (tag, spec) => {
+	if (!spec) return `<${tag} w:val="nil"/>`;
+	if (spec.style === "none" || spec.style === "nil") return `<${tag} w:val="nil"/>`;
+	const sz = spec.size ?? 4;
+	const color = spec.color?.rgb ?? "CCCCCC";
+	return `<${tag} w:val="${escapeXml(spec.style)}" w:sz="${sz}" w:space="0" w:color="${escapeXml(color)}"/>`;
+};
+const defaultBorderXml = () => "<w:top w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"CCCCCC\"/><w:left w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"CCCCCC\"/><w:bottom w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"CCCCCC\"/><w:right w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"CCCCCC\"/><w:insideH w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"CCCCCC\"/><w:insideV w:val=\"single\" w:sz=\"4\" w:space=\"0\" w:color=\"CCCCCC\"/>";
+const serializeSectionProperties = (properties) => `<w:sectPr><w:footerReference w:type="default" r:id="${DEFAULT_FOOTER_REL_ID}"/><w:pgSz${attr("w:w", properties.pageWidth)}${attr("w:h", properties.pageHeight)}${attr("w:orient", properties.orientation === "landscape" ? "landscape" : void 0)}/><w:pgMar${attr("w:top", properties.marginTop)}${attr("w:right", properties.marginRight)}${attr("w:bottom", properties.marginBottom)}${attr("w:left", properties.marginLeft)}${attr("w:header", properties.headerDistance)}${attr("w:footer", properties.footerDistance)}${attr("w:gutter", properties.gutter ?? 0)}/></w:sectPr>`;
+const serializeStyles = (styles) => {
+	const styleDefinitions = styles ?? { styles: [] };
+	return [
+		"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+		"<w:styles xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">",
+		serializeDocDefaults(styleDefinitions),
+		styleDefinitions.styles.map(serializeStyle).join(""),
+		"</w:styles>"
+	].join("");
+};
+const serializeDocDefaults = (styles) => {
+	const rPr = serializeRunProperties(styles.docDefaults?.rPr);
+	const pPrParts = [];
+	const pPr = styles.docDefaults?.pPr;
+	if (pPr?.spaceAfter !== void 0 || pPr?.lineSpacing !== void 0) pPrParts.push(`<w:spacing${attr("w:after", pPr.spaceAfter)}${attr("w:line", pPr.lineSpacing)}/>`);
+	return `<w:docDefaults><w:rPrDefault>${rPr}</w:rPrDefault><w:pPrDefault><w:pPr>${pPrParts.join("")}</w:pPr></w:pPrDefault></w:docDefaults>`;
+};
+const serializeStyle = (style) => {
+	const pPr = style.pPr ? serializeParagraphProperties({
+		type: "paragraph",
+		formatting: style.pPr,
+		content: []
+	}).replace(/^<w:pPr>|<\/w:pPr>$/gu, "") : "";
+	const rPr = serializeRunProperties(style.rPr);
+	return [
+		`<w:style w:type="${style.type}" w:styleId="${escapeXml(style.styleId)}"${style.default ? " w:default=\"1\"" : ""}>`,
+		`<w:name w:val="${escapeXml(style.name ?? style.styleId)}"/>`,
+		style.basedOn ? `<w:basedOn w:val="${escapeXml(style.basedOn)}"/>` : "",
+		style.next ? `<w:next w:val="${escapeXml(style.next)}"/>` : "",
+		style.qFormat ? "<w:qFormat/>" : "",
+		pPr ? `<w:pPr>${pPr}</w:pPr>` : "",
+		rPr,
+		"</w:style>"
+	].join("");
+};
+const serializeNumbering = (numbering) => [
+	"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+	"<w:numbering xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">",
+	(numbering?.abstractNums ?? []).map((abstractNum) => [
+		`<w:abstractNum w:abstractNumId="${abstractNum.abstractNumId}">`,
+		`<w:nsid w:val="${abstractNumberingNsid(abstractNum.abstractNumId)}"/>`,
+		abstractNum.multiLevelType ? `<w:multiLevelType w:val="${abstractNum.multiLevelType}"/>` : "",
+		abstractNum.levels.map(serializeNumberingLevel).join(""),
+		"</w:abstractNum>"
+	].join("")).join(""),
+	(numbering?.nums ?? []).map((num) => `<w:num w:numId="${num.numId}"><w:abstractNumId w:val="${num.abstractNumId}"/></w:num>`).join(""),
+	"</w:numbering>"
+].join("");
+const serializeNumberingLevel = (level) => [
+	`<w:lvl w:ilvl="${level.ilvl}">`,
+	`<w:start w:val="${level.start ?? 1}"/>`,
+	`<w:numFmt w:val="${level.numFmt}"/>`,
+	level.isLgl ? "<w:isLgl/>" : "",
+	level.suffix ? `<w:suff w:val="${level.suffix}"/>` : "",
+	`<w:lvlText w:val="${escapeXml(level.lvlText)}"/>`,
+	`<w:lvlJc w:val="${level.lvlJc ?? "left"}"/>`,
+	level.pPr ? serializeParagraphProperties({
+		type: "paragraph",
+		formatting: level.pPr,
+		content: []
+	}) : "",
+	serializeRunProperties(level.rPr),
+	"</w:lvl>"
+].join("");
+const abstractNumberingNsid = (abstractNumId) => abstractNumId.toString(16).toUpperCase().padStart(8, "0").slice(-8);
+const serializeCoreProperties = (document) => {
+	const properties = document.package.properties;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const title = properties?.title ?? "";
+	const creator = properties?.creator ?? "Stella";
+	const created = properties?.created?.toISOString() ?? now;
+	const modified = properties?.modified?.toISOString() ?? now;
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><dc:title>${escapeXml(title)}</dc:title><dc:creator>${escapeXml(creator)}</dc:creator><cp:lastModifiedBy>${escapeXml(creator)}</cp:lastModifiedBy><dcterms:created xsi:type="dcterms:W3CDTF">${created}</dcterms:created><dcterms:modified xsi:type="dcterms:W3CDTF">${modified}</dcterms:modified></cp:coreProperties>`;
+};
+//#endregion
+//#region src/validate/docx.ts
+const validateDocxPackage = async (buffer) => {
+	try {
+		const zip = await JSZip.loadAsync(buffer);
+		for (const requiredPath of [
+			"[Content_Types].xml",
+			"_rels/.rels",
+			"word/document.xml",
+			"word/styles.xml",
+			"word/_rels/document.xml.rels"
+		]) if (!zip.file(requiredPath)) return {
+			valid: false,
+			error: `Generated DOCX is missing required package part: ${requiredPath}`
+		};
+		if (!(await zip.file("word/document.xml")?.async("string"))?.includes("<w:document")) return {
+			valid: false,
+			error: "Generated DOCX has no word/document.xml root document."
+		};
+		if ((await zip.file("word/_rels/document.xml.rels")?.async("string"))?.includes("/relationships/numbering") && !zip.file("word/numbering.xml")) return {
+			valid: false,
+			error: "Generated DOCX references numbering.xml but does not include it."
+		};
+		return { valid: true };
+	} catch (error) {
+		return {
+			valid: false,
+			error: error instanceof Error ? error.message : "Invalid DOCX package."
+		};
+	}
+};
+const validateDocumentModel = (document) => {
+	const ctx = createValidationContext(document);
+	validateBlocks(document.package.document.content, "package.document.content", ctx);
+	validateHeaderFooterMap(document.package.headers, "package.headers", ctx);
+	validateHeaderFooterMap(document.package.footers, "package.footers", ctx);
+	validateComments(document.package.document.comments ?? [], ctx);
+	validateNotes(document, ctx);
+	validateMedia(document, ctx);
+	validateCounterPairs(ctx.commentRangeStarts, ctx.commentRangeEnds, {
+		label: "comment range",
+		startName: "commentRangeStart",
+		endName: "commentRangeEnd",
+		ctx
+	});
+	validateCounterPairs(ctx.bookmarkStarts, ctx.bookmarkEnds, {
+		label: "bookmark",
+		startName: "bookmarkStart",
+		endName: "bookmarkEnd",
+		ctx,
+		severity: "warning"
+	});
+	validateCounterPairs(ctx.moveFromStarts, ctx.moveFromEnds, {
+		label: "move-from range",
+		startName: "moveFromRangeStart",
+		endName: "moveFromRangeEnd",
+		ctx
+	});
+	validateCounterPairs(ctx.moveToStarts, ctx.moveToEnds, {
+		label: "move-to range",
+		startName: "moveToRangeStart",
+		endName: "moveToRangeEnd",
+		ctx
+	});
+	return {
+		valid: !ctx.issues.some((issue) => issue.severity === "error"),
+		issues: ctx.issues
+	};
+};
+const assertValidDocumentModel = (document) => {
+	const result = validateDocumentModel(document);
+	if (result.valid) return;
+	panic(`Invalid DOCX document model:\n${result.issues.filter((issue) => issue.severity === "error").map((issue) => `${issue.path}: ${issue.message}`).join("\n")}`);
+};
+const createValidationContext = (document) => ({
+	issues: [],
+	commentIds: new Set((document.package.document.comments ?? []).map((comment) => comment.id)),
+	referencedCommentIds: /* @__PURE__ */ new Map(),
+	commentRangeStarts: /* @__PURE__ */ new Map(),
+	commentRangeEnds: /* @__PURE__ */ new Map(),
+	bookmarkStarts: /* @__PURE__ */ new Map(),
+	bookmarkEnds: /* @__PURE__ */ new Map(),
+	moveFromStarts: /* @__PURE__ */ new Map(),
+	moveFromEnds: /* @__PURE__ */ new Map(),
+	moveToStarts: /* @__PURE__ */ new Map(),
+	moveToEnds: /* @__PURE__ */ new Map(),
+	noteRefs: {
+		footnote: /* @__PURE__ */ new Map(),
+		endnote: /* @__PURE__ */ new Map()
+	},
+	paraIds: /* @__PURE__ */ new Map(),
+	numberingNums: new Set((document.package.numbering?.nums ?? []).map((num) => num.numId)),
+	headers: document.package.headers,
+	footers: document.package.footers
+});
+const addIssue = (ctx, issue) => {
+	ctx.issues.push(issue);
+};
+const addError = (ctx, path, message) => {
+	addIssue(ctx, {
+		path,
+		message,
+		severity: "error"
+	});
+};
+const addWarning = (ctx, path, message) => {
+	addIssue(ctx, {
+		path,
+		message,
+		severity: "warning"
+	});
+};
+const increment = (map, id) => {
+	map.set(id, (map.get(id) ?? 0) + 1);
+};
+const recordPath = (map, id, path) => {
+	const existing = map.get(id);
+	if (existing) {
+		existing.push(path);
+		return;
+	}
+	map.set(id, [path]);
+};
+const validateBlocks = (blocks, path, ctx) => {
+	for (const [index, block] of blocks.entries()) validateBlock(block, `${path}[${index}]`, ctx);
+};
+const validateBlock = (block, path, ctx) => {
+	if (block.type === "paragraph") {
+		validateParagraph(block, path, ctx);
+		return;
+	}
+	if (block.type === "table") {
+		validateTable(block, path, ctx);
+		return;
+	}
+	if (block.content.length === 0) {
+		addWarning(ctx, `${path}.content`, "Block content control is empty.");
+		return;
+	}
+	validateBlocks(block.content, `${path}.content`, ctx);
+};
+const validateParagraph = (paragraph, path, ctx) => {
+	if (paragraph.paraId) {
+		const existingPath = ctx.paraIds.get(paragraph.paraId);
+		if (existingPath) addWarning(ctx, `${path}.paraId`, `Duplicate paragraph id also appears at ${existingPath}.`);
+		else ctx.paraIds.set(paragraph.paraId, path);
+	}
+	validateNumbering(paragraph, path, ctx);
+	if (paragraph.sectionProperties) validateSectionProperties(paragraph.sectionProperties, `${path}.sectionProperties`, ctx);
+	for (const [index, content] of paragraph.content.entries()) validateParagraphContent(content, `${path}.content[${index}]`, ctx);
+};
+const validateParagraphContent = (content, path, ctx) => {
+	if (content.type === "run") {
+		validateRun(content, path, ctx);
+		return;
+	}
+	if (content.type === "hyperlink") {
+		validateHyperlink(content, path, ctx);
+		return;
+	}
+	if (content.type === "simpleField") {
+		for (const [index, child] of content.content.entries()) validateFieldChild(child, `${path}.content[${index}]`, ctx);
+		return;
+	}
+	if (content.type === "complexField") {
+		validateRuns(content.fieldCode, `${path}.fieldCode`, ctx);
+		validateRuns(content.fieldResult, `${path}.fieldResult`, ctx);
+		return;
+	}
+	if (content.type === "inlineSdt") {
+		for (const [index, child] of content.content.entries()) validateParagraphContent(child, `${path}.content[${index}]`, ctx);
+		return;
+	}
+	if (content.type === "commentRangeStart") {
+		increment(ctx.commentRangeStarts, content.id);
+		recordPath(ctx.referencedCommentIds, content.id, path);
+		return;
+	}
+	if (content.type === "commentRangeEnd") {
+		increment(ctx.commentRangeEnds, content.id);
+		recordPath(ctx.referencedCommentIds, content.id, path);
+		return;
+	}
+	if (content.type === "commentReference") {
+		recordPath(ctx.referencedCommentIds, content.id, path);
+		return;
+	}
+	if (content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo") {
+		validateTrackedRunChange(content, path, ctx);
+		return;
+	}
+	if (content.type === "bookmarkStart") {
+		increment(ctx.bookmarkStarts, content.id);
+		return;
+	}
+	if (content.type === "bookmarkEnd") {
+		increment(ctx.bookmarkEnds, content.id);
+		return;
+	}
+	if (content.type === "moveFromRangeStart") {
+		increment(ctx.moveFromStarts, content.id);
+		return;
+	}
+	if (content.type === "moveFromRangeEnd") {
+		increment(ctx.moveFromEnds, content.id);
+		return;
+	}
+	if (content.type === "moveToRangeStart") {
+		increment(ctx.moveToStarts, content.id);
+		return;
+	}
+	if (content.type === "moveToRangeEnd") {
+		increment(ctx.moveToEnds, content.id);
+		return;
+	}
+	if (content.ommlXml.trim() === "") addError(ctx, `${path}.ommlXml`, "Math equation must preserve OMML XML.");
+};
+const validateFieldChild = (child, path, ctx) => {
+	if (child.type === "run") {
+		validateRun(child, path, ctx);
+		return;
+	}
+	validateHyperlink(child, path, ctx);
+};
+const validateRuns = (runs, path, ctx) => {
+	for (const [index, run] of runs.entries()) validateRun(run, `${path}[${index}]`, ctx);
+};
+const validateRun = (run, path, ctx) => {
+	for (const [index, content] of run.content.entries()) validateRunContent(content, `${path}.content[${index}]`, ctx);
+};
+const validateRunContent = (content, path, ctx) => {
+	if (content.type === "drawing") {
+		validateImage(content.image, `${path}.image`, ctx, { hasPreservedRawDrawing: content.rawXml?.trim() !== "" });
+		return;
+	}
+	if (content.type === "shape") {
+		validateShape(content.shape, `${path}.shape`, ctx);
+		return;
+	}
+	if (content.type === "footnoteRef" || content.type === "endnoteRef") {
+		const noteType = content.type === "footnoteRef" ? "footnote" : "endnote";
+		recordPath(ctx.noteRefs[noteType], content.id, path);
+		return;
+	}
+	if (content.type === "symbol" && content.char.trim() === "") addError(ctx, `${path}.char`, "Symbol content must include a character.");
+};
+const validateHyperlink = (hyperlink, path, ctx) => {
+	if (!hyperlink.rId && !hyperlink.href && !hyperlink.anchor) addWarning(ctx, path, "Hyperlink has no relationship, href, or internal anchor.");
+	for (const [index, child] of hyperlink.children.entries()) validateHyperlinkChild(child, `${path}.children[${index}]`, ctx);
+};
+const validateHyperlinkChild = (child, path, ctx) => {
+	if (child.type === "run") {
+		validateRun(child, path, ctx);
+		return;
+	}
+	if (child.type === "bookmarkStart") {
+		increment(ctx.bookmarkStarts, child.id);
+		return;
+	}
+	increment(ctx.bookmarkEnds, child.id);
+};
+const validateTrackedRunChange = (change, path, ctx) => {
+	if (change.info.author.trim() === "") addError(ctx, `${path}.info.author`, "Tracked change author is empty.");
+	for (const [index, child] of change.content.entries()) validateFieldChild(child, `${path}.content[${index}]`, ctx);
+};
+const validateImage = (image, path, ctx, options = {}) => {
+	if (!image.rId && !image.src?.startsWith("data:") && !options.hasPreservedRawDrawing) addError(ctx, `${path}.rId`, "Image must have a relationship id.");
+	validateNonNegativeSize(image.size.width, `${path}.size.width`, ctx);
+	validateNonNegativeSize(image.size.height, `${path}.size.height`, ctx);
+};
+const validateShape = (shape, path, ctx) => {
+	validateNonNegativeSize(shape.size.width, `${path}.size.width`, ctx);
+	validateNonNegativeSize(shape.size.height, `${path}.size.height`, ctx);
+	if (shape.textBody) validateParagraphs(shape.textBody.content, `${path}.textBody.content`, ctx);
+};
+const validateNonNegativeSize = (value, path, ctx) => {
+	if (value < 0) {
+		addError(ctx, path, "Size must be zero or greater.");
+		return;
+	}
+	if (value === 0) addWarning(ctx, path, "Size is zero; the drawing may be invisible.");
+};
+const validateTable = (table, path, ctx) => {
+	if (table.rows.length === 0) {
+		addError(ctx, `${path}.rows`, "Table must contain at least one row.");
+		return;
+	}
+	for (const [index, row] of table.rows.entries()) validateTableRow(row, `${path}.rows[${index}]`, ctx);
+};
+const validateTableRow = (row, path, ctx) => {
+	if (row.cells.length === 0) {
+		addError(ctx, `${path}.cells`, "Table row must contain at least one cell.");
+		return;
+	}
+	for (const [index, cell] of row.cells.entries()) validateTableCell(cell, `${path}.cells[${index}]`, ctx);
+};
+const validateTableCell = (cell, path, ctx) => {
+	if (cell.content.length === 0) {
+		addError(ctx, `${path}.content`, "Table cell must contain block content.");
+		return;
+	}
+	validateBlocks(cell.content, `${path}.content`, ctx);
+};
+const validateParagraphs = (paragraphs, path, ctx) => {
+	for (const [index, paragraph] of paragraphs.entries()) validateParagraph(paragraph, `${path}[${index}]`, ctx);
+};
+const validateNumbering = (paragraph, path, ctx) => {
+	const numPr = paragraph.formatting?.numPr;
+	if (!numPr) return;
+	const ilvl = numPr.ilvl ?? 0;
+	if (ilvl < 0) addError(ctx, `${path}.formatting.numPr.ilvl`, "List level must be zero or greater.");
+	else if (ilvl > 8) addWarning(ctx, `${path}.formatting.numPr.ilvl`, "List level is outside Word's standard 0-8 range.");
+	if (numPr.numId === void 0 || numPr.numId === 0) return;
+	if (!ctx.numberingNums.has(numPr.numId)) addError(ctx, `${path}.formatting.numPr.numId`, `Numbering definition ${numPr.numId} is missing.`);
+};
+const validateSectionProperties = (section, path, ctx) => {
+	validateHeaderFooterReferences(section.headerReferences ?? [], ctx.headers, `${path}.headerReferences`, "header", ctx);
+	validateHeaderFooterReferences(section.footerReferences ?? [], ctx.footers, `${path}.footerReferences`, "footer", ctx);
+};
+const validateHeaderFooterReferences = (refs, map, path, label, ctx) => {
+	for (const [index, ref] of refs.entries()) if (!map?.has(ref.rId)) addError(ctx, `${path}[${index}].rId`, `Section references missing ${label} ${ref.rId}.`);
+};
+const validateHeaderFooterMap = (map, path, ctx) => {
+	if (!map) return;
+	for (const [rId, headerFooter] of map.entries()) validateBlocks(headerFooter.content, `${path}.${rId}.content`, ctx);
+};
+const validateComments = (comments, ctx) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, comment] of comments.entries()) {
+		const path = `package.document.comments[${index}]`;
+		if (seen.has(comment.id)) addError(ctx, `${path}.id`, `Duplicate comment id ${comment.id}.`);
+		seen.add(comment.id);
+		if (comment.author.trim() === "") addError(ctx, `${path}.author`, "Comment author is empty.");
+		if (comment.parentId !== void 0 && !ctx.commentIds.has(comment.parentId)) addError(ctx, `${path}.parentId`, `Parent comment ${comment.parentId} is missing.`);
+		validateParagraphs(comment.content, `${path}.content`, ctx);
+	}
+	for (const [id, paths] of ctx.referencedCommentIds.entries()) if (!ctx.commentIds.has(id)) addError(ctx, paths.at(0) ?? "package.document", `Comment ${id} is referenced but not present in comments.xml.`);
+};
+const validateNotes = (document, ctx) => {
+	validateNoteCollection({
+		refs: ctx.noteRefs.footnote,
+		notes: document.package.footnotes ?? [],
+		path: "package.footnotes",
+		label: "Footnote",
+		ctx
+	});
+	validateNoteCollection({
+		refs: ctx.noteRefs.endnote,
+		notes: document.package.endnotes ?? [],
+		path: "package.endnotes",
+		label: "Endnote",
+		ctx
+	});
+};
+const validateNoteCollection = ({ refs, notes, path, label, ctx }) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const [index, note] of notes.entries()) {
+		if (ids.has(note.id)) addError(ctx, `${path}[${index}].id`, `Duplicate ${label} id ${note.id}.`);
+		ids.add(note.id);
+		validateBlocks(note.content, `${path}[${index}].content`, ctx);
+	}
+	for (const [id, paths] of refs.entries()) if (!ids.has(id)) addError(ctx, paths.at(0) ?? path, `${label} ${id} is referenced but not present in the package.`);
+};
+const validateMedia = (document, ctx) => {
+	const media = document.package.media;
+	if (!media) return;
+	for (const [path, file] of media.entries()) {
+		const issuePath = `package.media.${path}`;
+		if (file.path.trim() === "") addError(ctx, `${issuePath}.path`, "Media file path is empty.");
+		if (file.mimeType.trim() === "") addError(ctx, `${issuePath}.mimeType`, "Media MIME type is empty.");
+		if (file.data.byteLength === 0) addWarning(ctx, `${issuePath}.data`, "Media file has no binary data.");
+	}
+};
+const validateCounterPairs = (starts, ends, { label, startName, endName, ctx, severity = "error" }) => {
+	const ids = /* @__PURE__ */ new Set([...starts.keys(), ...ends.keys()]);
+	for (const id of ids) {
+		const startCount = starts.get(id) ?? 0;
+		const endCount = ends.get(id) ?? 0;
+		if (startCount === endCount) continue;
+		const message = `Unbalanced ${label} ${id}: ${startName}=${startCount}, ${endName}=${endCount}.`;
+		if (severity === "warning") {
+			addWarning(ctx, "package.document", message);
+			continue;
+		}
+		addError(ctx, "package.document", message);
+	}
+};
+//#endregion
+//#region src/legal-source/parser.ts
+const DEFAULT_KIND = "agreement";
+const DEFAULT_LOCALE = "en-GB";
+const DEFAULT_NUMBERING = "legal";
+const DEFAULT_PAGE_SIZE = "A4";
+const DEFAULT_ORIENTATION = "portrait";
+const DIRECTIVE_ALIASES = {
+	"@annex": "@schedule",
+	"@appendix": "@schedule",
+	"@body": "@paragraph",
+	"@para": "@paragraph",
+	"@preamble": "@paragraph",
+	"@section": "@clause",
+	"@signature": "@signatures",
+	"@subsection": "@subclause"
+};
+const DIRECTIVES = /* @__PURE__ */ new Set([
+	"@doc",
+	"@title",
+	"@recital",
+	"@clause",
+	"@subclause",
+	"@paragraph",
+	"@list",
+	"@table",
+	"@schedule",
+	"@signatures",
+	"@pagebreak"
+]);
+const parseLegalSource = (source, options = {}) => {
+	const fixes = [];
+	const diagnostics = [];
+	const blocks = [];
+	const meta = {
+		kind: DEFAULT_KIND,
+		locale: DEFAULT_LOCALE,
+		numbering: DEFAULT_NUMBERING,
+		page: {
+			size: DEFAULT_PAGE_SIZE,
+			orientation: DEFAULT_ORIENTATION
+		},
+		title: null
+	};
+	let pending = null;
+	const pushPending = () => {
+		if (!pending) return;
+		const block = pendingToBlock(pending, diagnostics, fixes);
+		if (block) {
+			blocks.push(block);
+			if (block.type === "title") meta.title = block.text;
+		}
+		pending = null;
+	};
+	const lines = source.replace(/\r\n?/gu, "\n").split("\n");
+	for (const [index, rawLine] of lines.entries()) {
+		const lineNumber = index + 1;
+		const line = rawLine.trimEnd();
+		const trimmed = line.trim();
+		if (!trimmed) {
+			pending?.lines.push("");
+			continue;
+		}
+		const markdownHeading = parseMarkdownHeading(trimmed);
+		if (markdownHeading) {
+			pushPending();
+			const { depth, heading } = markdownHeading;
+			if (depth === 1) {
+				pending = {
+					type: "title",
+					line: lineNumber,
+					heading,
+					lines: []
+				};
+				pushPending();
+			} else pending = {
+				type: "clause",
+				line: lineNumber,
+				level: Math.min(depth - 1, 6),
+				heading,
+				lines: []
+			};
+			fixes.push({
+				code: "markdown-heading-normalized",
+				message: "Converted a Markdown heading into a legal directive.",
+				line: lineNumber
+			});
+			continue;
+		}
+		if (trimmed.startsWith("@")) {
+			const [rawDirective = "", ...rest] = trimmed.split(/\s+/u);
+			const canonicalDirective = DIRECTIVE_ALIASES[rawDirective.toLowerCase()] ?? rawDirective.toLowerCase();
+			const argument = rest.join(" ").trim();
+			if (!DIRECTIVES.has(canonicalDirective)) {
+				diagnostics.push({
+					code: "unknown-directive",
+					message: `Unknown legal directive "${rawDirective}".`,
+					severity: "error",
+					line: lineNumber
+				});
+				pending?.lines.push(line);
+				continue;
+			}
+			if (canonicalDirective !== rawDirective.toLowerCase()) fixes.push({
+				code: "directive-alias-normalized",
+				message: `Normalized ${rawDirective} to ${canonicalDirective}.`,
+				line: lineNumber
+			});
+			pushPending();
+			switch (canonicalDirective) {
+				case "@doc":
+					parseDocDirective(argument, meta, diagnostics, lineNumber);
+					break;
+				case "@title":
+					pending = {
+						type: "title",
+						line: lineNumber,
+						heading: argument,
+						lines: []
+					};
+					pushPending();
+					break;
+				case "@recital":
+					pending = {
+						type: "recital",
+						line: lineNumber,
+						heading: argument,
+						lines: []
+					};
+					break;
+				case "@clause":
+					pending = {
+						type: "clause",
+						line: lineNumber,
+						level: 1,
+						heading: argument,
+						lines: []
+					};
+					break;
+				case "@subclause":
+					pending = {
+						type: "clause",
+						line: lineNumber,
+						level: 2,
+						heading: argument,
+						lines: []
+					};
+					break;
+				case "@paragraph":
+					pending = {
+						type: "paragraph",
+						line: lineNumber,
+						heading: argument,
+						lines: []
+					};
+					break;
+				case "@list":
+					pending = {
+						type: "list",
+						line: lineNumber,
+						ordered: /\bordered\b/iu.test(argument),
+						heading: argument,
+						lines: []
+					};
+					break;
+				case "@table":
+					pending = {
+						type: "table",
+						line: lineNumber,
+						heading: argument,
+						lines: []
+					};
+					break;
+				case "@schedule":
+					pending = {
+						type: "schedule",
+						line: lineNumber,
+						heading: argument,
+						lines: []
+					};
+					break;
+				case "@signatures":
+					pending = {
+						type: "signatures",
+						line: lineNumber,
+						heading: argument,
+						lines: []
+					};
+					break;
+				case "@pagebreak":
+					blocks.push({ type: "pageBreak" });
+					break;
+				default: break;
+			}
+			continue;
+		}
+		pending ??= {
+			type: "paragraph",
+			line: lineNumber,
+			heading: "",
+			lines: []
+		};
+		pending.lines.push(line);
+	}
+	pushPending();
+	if (!meta.title) {
+		const firstTitle = blocks.find((block) => block.type === "title");
+		meta.title = firstTitle?.type === "title" ? firstTitle.text : options.titleFallback ?? "Untitled document";
+	}
+	return applyDocumentAutofixes({
+		diagnostics,
+		draft: {
+			meta,
+			blocks
+		},
+		fixes
+	});
+};
+const parseDocDirective = (argument, meta, diagnostics, line) => {
+	const attrs = parseAttributes(argument);
+	const kind = attrs.get("kind");
+	if (kind !== void 0 && isLegalKind(kind)) meta.kind = kind;
+	else if (kind !== void 0) diagnostics.push({
+		code: "invalid-doc-attribute",
+		message: `Invalid @doc kind "${kind}".`,
+		severity: "warning",
+		line
+	});
+	const locale = attrs.get("locale");
+	if (locale) meta.locale = locale;
+	const numbering = attrs.get("numbering");
+	if (numbering !== void 0 && isNumberingProfile(numbering)) meta.numbering = numbering;
+	else if (numbering !== void 0) diagnostics.push({
+		code: "invalid-doc-attribute",
+		message: `Invalid @doc numbering "${numbering}".`,
+		severity: "warning",
+		line
+	});
+	const page = attrs.get("page");
+	if (page !== void 0 && isPageSize(page)) meta.page.size = page;
+	else if (page !== void 0) diagnostics.push({
+		code: "invalid-doc-attribute",
+		message: `Invalid @doc page "${page}".`,
+		severity: "warning",
+		line
+	});
+	const orientation = attrs.get("orientation");
+	if (orientation !== void 0 && isPageOrientation(orientation)) meta.page.orientation = orientation;
+	else if (orientation !== void 0) diagnostics.push({
+		code: "invalid-doc-attribute",
+		message: `Invalid @doc orientation "${orientation}".`,
+		severity: "warning",
+		line
+	});
+	const title = attrs.get("title");
+	if (title) meta.title = title;
+	for (const key of attrs.keys()) if (![
+		"kind",
+		"locale",
+		"numbering",
+		"page",
+		"orientation",
+		"title"
+	].includes(key)) diagnostics.push({
+		code: "unknown-doc-attribute",
+		message: `Unknown @doc attribute "${key}".`,
+		severity: "warning",
+		line
+	});
+};
+const parseAttributes = (value) => {
+	const attrs = /* @__PURE__ */ new Map();
+	let index = 0;
+	while (index < value.length) {
+		const attr = readAttribute(value, index);
+		if (!attr) {
+			index = skipMalformedAttribute(value, index);
+			continue;
+		}
+		attrs.set(attr.key, attr.value);
+		index = attr.nextIndex;
+	}
+	return attrs;
+};
+const readAttribute = (value, startIndex) => {
+	const keyStart = skipWhitespace(value, startIndex);
+	const keyEnd = readAttributeKeyEnd(value, keyStart);
+	const key = value.slice(keyStart, keyEnd).toLowerCase();
+	const equalsIndex = skipWhitespace(value, keyEnd);
+	if (!key || value.charAt(equalsIndex) !== "=") return null;
+	const attributeValue = readAttributeValue(value, skipWhitespace(value, equalsIndex + 1));
+	return {
+		key,
+		value: attributeValue.value,
+		nextIndex: attributeValue.nextIndex
+	};
+};
+const skipWhitespace = (value, startIndex) => {
+	let index = startIndex;
+	while (index < value.length && isWhitespace(value.charAt(index))) index++;
+	return index;
+};
+const readAttributeKeyEnd = (value, startIndex) => {
+	let index = startIndex;
+	while (index < value.length && isAttributeKeyChar(value.charAt(index))) index++;
+	return index;
+};
+const readAttributeValue = (value, startIndex) => {
+	const quote = value.charAt(startIndex);
+	if (quote === "\"" || quote === "'") return readQuotedAttributeValue(value, startIndex + 1, quote);
+	let index = startIndex;
+	while (index < value.length && !isWhitespace(value.charAt(index))) index++;
+	return {
+		value: value.slice(startIndex, index),
+		nextIndex: index
+	};
+};
+const readQuotedAttributeValue = (value, startIndex, quote) => {
+	let index = startIndex;
+	while (index < value.length && value.charAt(index) !== quote) index++;
+	return {
+		value: value.slice(startIndex, index),
+		nextIndex: index < value.length ? index + 1 : index
+	};
+};
+const skipMalformedAttribute = (value, startIndex) => {
+	let index = skipWhitespace(value, startIndex);
+	while (index < value.length && !isWhitespace(value.charAt(index))) index++;
+	return index === startIndex ? index + 1 : index;
+};
+const isWhitespace = (char) => char === " " || char === "	" || char === "\r" || char === "\n";
+const isAttributeKeyChar = (char) => isAsciiAlphaNumeric(char) || char === "_" || char === "." || char === "-";
+const isAsciiAlphaNumeric = (char) => {
+	const code = char.codePointAt(0);
+	if (code === void 0) return false;
+	return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+};
+const parseMarkdownHeading = (line) => {
+	let depth = 0;
+	for (const char of line) {
+		if (char !== "#") break;
+		depth++;
+	}
+	if (depth < 1 || depth > 6 || line.at(depth) !== " ") return null;
+	const heading = line.slice(depth + 1).trim();
+	return heading ? {
+		depth,
+		heading
+	} : null;
+};
+const pendingToBlock = (pending, diagnostics, fixes) => {
+	switch (pending.type) {
+		case "title": {
+			const text = pending.heading || paragraphText(pending.lines);
+			if (!text) return null;
+			return {
+				type: "title",
+				text
+			};
+		}
+		case "recital": return {
+			type: "recital",
+			paragraphs: compactParagraphs(pending.lines)
+		};
+		case "clause": {
+			const heading = stripManualNumbering(pending.heading, pending.line, fixes);
+			if (!heading) {
+				fixes.push({
+					code: "headingless-clause-downgraded",
+					message: "Converted a headingless @clause into a paragraph block.",
+					line: pending.line
+				});
+				return {
+					type: "paragraph",
+					paragraphs: compactParagraphs(pending.lines)
+				};
+			}
+			return {
+				type: "clause",
+				level: pending.level,
+				heading,
+				paragraphs: compactParagraphs(pending.lines)
+			};
+		}
+		case "paragraph": return {
+			type: "paragraph",
+			paragraphs: compactParagraphs(pending.lines)
+		};
+		case "list": return {
+			type: "list",
+			ordered: pending.ordered,
+			items: pending.lines.map((line) => stripListMarker(line, pending.ordered)).filter(Boolean)
+		};
+		case "table": return parseTableBlock(pending, diagnostics, fixes);
+		case "schedule": return {
+			type: "schedule",
+			heading: stripManualNumbering(pending.heading, pending.line, fixes),
+			paragraphs: compactParagraphs(pending.lines)
+		};
+		case "signatures": return {
+			type: "signatures",
+			parties: parseSignatureParties(pending.lines, pending.heading)
+		};
+		default: return null;
+	}
+};
+const parseTableBlock = (pending, diagnostics, fixes) => {
+	const rows = pending.lines.map((line) => line.trim()).filter((line) => line.startsWith("|")).map(parsePipeRow).filter((row) => row.length > 0);
+	const header = rows.at(0) ?? [];
+	const normalizedRows = rows.slice(1).filter((row) => !isMarkdownDividerRow(row)).map((row) => {
+		if (row.length === header.length) return row;
+		fixes.push({
+			code: "table-row-width-normalized",
+			message: "Normalized a table row to match the header width.",
+			line: pending.line
+		});
+		return header.map((_, index) => row.at(index) ?? "");
+	});
+	if (header.length === 0) diagnostics.push({
+		code: "missing-table-header",
+		message: "Table directives must include a pipe-table header row.",
+		severity: "error",
+		line: pending.line
+	});
+	return {
+		type: "table",
+		table: {
+			headers: header,
+			rows: normalizedRows
+		}
+	};
+};
+const applyDocumentAutofixes = ({ diagnostics, draft, fixes }) => {
+	const blocks = [];
+	const normalizedTitle = normalizeTitle(draft.meta.title ?? "");
+	let hasSeenSubstantiveBlock = false;
+	for (const block of draft.blocks) {
+		if (!hasSeenSubstantiveBlock && block.type === "clause" && block.level === 1 && normalizedTitle.length > 0 && normalizeTitle(block.heading) === normalizedTitle) {
+			fixes.push({
+				code: "duplicate-title-clause-removed",
+				message: "Removed a first clause that duplicated the document title."
+			});
+			continue;
+		}
+		blocks.push(block);
+		hasSeenSubstantiveBlock ||= isSubstantiveDraftBlock(block);
+	}
+	const signatureIndex = blocks.findIndex((block) => block.type === "signatures");
+	if (signatureIndex !== -1 && signatureIndex !== blocks.length - 1) {
+		const [signatureBlock] = blocks.splice(signatureIndex, 1);
+		if (signatureBlock) {
+			blocks.push(signatureBlock);
+			fixes.push({
+				code: "signatures-moved-to-end",
+				message: "Moved the signatures block to the end of the document."
+			});
+		}
+	}
+	return {
+		draft: {
+			...draft,
+			blocks
+		},
+		diagnostics,
+		fixes
+	};
+};
+const isSubstantiveDraftBlock = (block) => block.type !== "title" && block.type !== "pageBreak";
+const SIGNATURE_KEY_ALIASES = {
+	party: "party",
+	by: "by",
+	name: "name",
+	title: "title",
+	date: "date",
+	strana: "party",
+	podepisuje: "by",
+	podpisuje: "by",
+	jméno: "name",
+	jmeno: "name",
+	meno: "name",
+	funkce: "title",
+	funkcia: "title",
+	datum: "date",
+	partei: "party",
+	unterzeichnet: "by",
+	unterschreibt: "by",
+	funktion: "title",
+	partie: "party",
+	signataire: "by",
+	nom: "name",
+	fonction: "title",
+	parte: "party",
+	firmante: "by",
+	nombre: "name",
+	cargo: "title",
+	fecha: "date",
+	firmatario: "by",
+	nome: "name",
+	carica: "title",
+	data: "date",
+	imie: "name",
+	imię: "name",
+	stanowisko: "title",
+	assinante: "by",
+	ondertekent: "by",
+	naam: "name",
+	functie: "title",
+	fél: "party",
+	fel: "party",
+	aláírja: "by",
+	alairja: "by",
+	név: "name",
+	nev: "name",
+	beosztás: "title",
+	beosztas: "title",
+	dátum: "date"
+};
+const SIGNATURE_FIELD_KEYS = /* @__PURE__ */ new Set([
+	"party",
+	"by",
+	"name",
+	"title",
+	"date"
+]);
+const parseSignatureParties = (lines, heading) => {
+	const parties = [];
+	let current = null;
+	const pushCurrent = () => {
+		if (!current?.name.trim()) {
+			current = null;
+			return;
+		}
+		parties.push({
+			name: current.name.trim(),
+			...current.signatory ? { signatory: current.signatory.trim() } : {},
+			...current.title ? { title: current.title.trim() } : {}
+		});
+		current = null;
+	};
+	const startParty = (name) => {
+		pushCurrent();
+		current = { name };
+	};
+	if (heading.trim()) startParty(heading.trim().replace(/^party:\s*/iu, ""));
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const separatorIndex = trimmed.indexOf(":");
+		if (separatorIndex === -1) {
+			startParty(trimmed);
+			continue;
+		}
+		const canonicalKey = SIGNATURE_KEY_ALIASES[trimmed.slice(0, separatorIndex).toLowerCase()];
+		if (!canonicalKey || !SIGNATURE_FIELD_KEYS.has(canonicalKey)) {
+			startParty(trimmed);
+			continue;
+		}
+		const value = trimmed.slice(separatorIndex + 1).trim();
+		if (canonicalKey === "party") {
+			startParty(value);
+			continue;
+		}
+		current ??= { name: "" };
+		if ((canonicalKey === "by" || canonicalKey === "name") && value) current.signatory = value;
+		if (canonicalKey === "title" && value) current.title = value;
+	}
+	pushCurrent();
+	const seen = /* @__PURE__ */ new Set();
+	return parties.filter((party) => {
+		const key = `${party.name}\u0000${party.signatory ?? ""}\u0000${party.title ?? ""}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+};
+const ORDERED_LIST_MARKER_RE = /^(?:\d+(?:\.\d+)+|\d+[.)])\s+/u;
+const MANUAL_NUMBERING_PREFIX_RE = /^(?:\d+(?:\.\d+)+|\d+[.)]|[A-Za-z][.)]|\([a-zivx]+\))\s+/u;
+const stripListMarker = (line, ordered) => {
+	const trimmed = line.trim();
+	if (ordered) return trimmed.replace(ORDERED_LIST_MARKER_RE, "");
+	return trimmed.replace(/^[-*•]\s+/u, "");
+};
+const parsePipeRow = (line) => line.replace(/^\|/u, "").replace(/\|$/u, "").split("|").map((cell) => cell.trim());
+const isMarkdownDividerRow = (row) => row.every((cell) => /^:?-{3,}:?$/u.test(cell));
+const compactParagraphs = (lines) => {
+	const paragraphs = [];
+	let current = [];
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) {
+			if (current.length > 0) {
+				paragraphs.push(current.join(" "));
+				current = [];
+			}
+			continue;
+		}
+		current.push(trimmed);
+	}
+	if (current.length > 0) paragraphs.push(current.join(" "));
+	return paragraphs;
+};
+const paragraphText = (lines) => compactParagraphs(lines).join(" ");
+const stripManualNumbering = (value, line, fixes) => {
+	const stripped = value.trim().replace(MANUAL_NUMBERING_PREFIX_RE, "");
+	if (stripped !== value.trim()) fixes.push({
+		code: "manual-numbering-stripped",
+		message: "Removed manual numbering from a directive heading.",
+		line
+	});
+	return stripped;
+};
+const normalizeTitle = (value) => value.normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+const isLegalKind = (value) => value === "agreement" || value === "letter" || value === "memo" || value === "checklist" || value === "pleading" || value === "other";
+const isNumberingProfile = (value) => value === "legal" || value === "none" || value === "checklist";
+const isPageSize = (value) => value === "A4" || value === "Letter";
+const isPageOrientation = (value) => value === "portrait" || value === "landscape";
+//#endregion
+//#region src/legal-source/validate.ts
+const validateLegalDraft = (draft) => {
+	const diagnostics = [];
+	if (!draft.meta.title?.trim()) diagnostics.push({
+		code: "missing-title",
+		message: "The draft must have a title.",
+		severity: "error"
+	});
+	let hasTopLevelClause = false;
+	for (const block of draft.blocks) {
+		if (block.type === "clause") {
+			if (block.level === 1) hasTopLevelClause = true;
+			if (block.level > 1 && !hasTopLevelClause) diagnostics.push({
+				code: "subclause-before-clause",
+				message: "A subclause cannot appear before the first top-level clause.",
+				severity: "error"
+			});
+			if (!block.heading.trim()) diagnostics.push({
+				code: "empty-clause-heading",
+				message: "Clause headings cannot be empty.",
+				severity: "error"
+			});
+		}
+		if (block.type === "table") {
+			if (block.table.headers.length === 0) diagnostics.push({
+				code: "empty-table",
+				message: "Tables must include at least one header.",
+				severity: "error"
+			});
+			for (const row of block.table.rows) if (row.length !== block.table.headers.length) diagnostics.push({
+				code: "ragged-table",
+				message: "Every table row must match the header width.",
+				severity: "error"
+			});
+		}
+		if (block.type === "signatures" && block.parties.length === 0) diagnostics.push({
+			code: "empty-signatures",
+			message: "The signatures block must include at least one party.",
+			severity: "warning"
+		});
+	}
+	return diagnostics;
+};
+//#endregion
+//#region src/legal-source/compile.ts
+const LEGAL_NUMBERING_ID = 1;
+const LEGAL_ABSTRACT_NUMBERING_ID = 1;
+const BULLET_NUMBERING_ID = 2;
+const BULLET_ABSTRACT_NUMBERING_ID = 2;
+const CHECKLIST_NUMBERING_ID = 3;
+const CHECKLIST_ABSTRACT_NUMBERING_ID = 3;
+const SIGNATURE_LINE = "_".repeat(28);
+const compileLegalSourceToDocument = (source, options = {}) => {
+	const parsed = parseLegalSource(source, options.titleFallback ? { titleFallback: options.titleFallback } : {});
+	const validationDiagnostics = validateLegalDraft(parsed.draft);
+	const diagnostics = [...parsed.diagnostics, ...validationDiagnostics];
+	const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+	if (errors.length > 0) return {
+		status: "needs_llm_repair",
+		draft: parsed.draft,
+		fixes: parsed.fixes,
+		errors
+	};
+	return {
+		status: "ok",
+		document: draftToDocument(parsed.draft),
+		draft: parsed.draft,
+		fixes: parsed.fixes,
+		warnings: diagnostics.filter((diagnostic) => diagnostic.severity === "warning")
+	};
+};
+const draftToDocument = (draft) => {
+	const content = [];
+	const title = draft.meta.title ?? "Untitled document";
+	const numbering = createNumberingDefinitions(draft.meta.numbering);
+	content.push(paragraph(title, "Title", { bold: true }));
+	for (const block of draft.blocks) appendBlock(content, block, { numberingProfile: draft.meta.numbering });
+	const docxPackage = {
+		document: {
+			content,
+			finalSectionProperties: pageProperties(draft.meta.page.size, draft.meta.page.orientation)
+		},
+		styles: createStyleDefinitions(),
+		properties: {
+			title,
+			creator: "Stella",
+			created: /* @__PURE__ */ new Date(),
+			modified: /* @__PURE__ */ new Date()
+		}
+	};
+	if (numbering) docxPackage.numbering = numbering;
+	return { package: docxPackage };
+};
+const appendBlock = (content, block, options) => {
+	switch (block.type) {
+		case "title": return;
+		case "recital":
+			appendParagraphs(content, block.paragraphs, "Recital");
+			return;
+		case "clause":
+			content.push(paragraph(block.heading, clauseStyle(block.level), { bold: block.level === 1 }, clauseNumbering(block, options.numberingProfile)));
+			appendParagraphs(content, block.paragraphs, "BodyText");
+			return;
+		case "paragraph":
+			appendParagraphs(content, block.paragraphs, "BodyText");
+			return;
+		case "list":
+			for (const item of block.items) content.push(paragraph(item, "ListParagraph", {}, listNumbering(block, options.numberingProfile)));
+			return;
+		case "table":
+			content.push(table(block.table.headers, block.table.rows));
+			return;
+		case "schedule":
+			content.push(paragraph(block.heading, "ScheduleHeading", { bold: true }, void 0, true));
+			appendParagraphs(content, block.paragraphs, "BodyText");
+			return;
+		case "signatures":
+			content.push(signatureTable(block.parties));
+			return;
+		case "pageBreak":
+			content.push({
+				type: "paragraph",
+				content: [{
+					type: "run",
+					content: [{
+						type: "break",
+						breakType: "page"
+					}]
+				}]
+			});
+			return;
+		default:
+	}
+};
+const clauseNumbering = (block, profile) => {
+	if (profile !== "legal") return;
+	return {
+		numId: LEGAL_NUMBERING_ID,
+		ilvl: Math.max(0, block.level - 1)
+	};
+};
+const listNumbering = (block, profile) => {
+	if (profile === "none") return;
+	if (profile === "checklist") return {
+		numId: CHECKLIST_NUMBERING_ID,
+		ilvl: 0
+	};
+	return {
+		numId: block.ordered ? LEGAL_NUMBERING_ID : BULLET_NUMBERING_ID,
+		ilvl: block.ordered ? 2 : 0
+	};
+};
+const appendParagraphs = (content, paragraphs, styleId) => {
+	for (const text of paragraphs) content.push(paragraph(text, styleId));
+};
+const paragraph = (text, styleId, runOptions = {}, numPr, pageBreakBefore = false) => ({
+	type: "paragraph",
+	formatting: {
+		styleId,
+		...numPr ? { numPr } : {},
+		...pageBreakBefore ? { pageBreakBefore: true } : {}
+	},
+	content: textRunsWithPlaceholders(text, runOptions)
+});
+const PLACEHOLDER_PATTERN = /\[\[(?<inner>[^\][]+?)\]\]/gu;
+const textRunsWithPlaceholders = (text, options = {}) => {
+	if (!text.includes("[[")) return [textRun(text, options)];
+	const runs = [];
+	let cursor = 0;
+	for (const match of text.matchAll(PLACEHOLDER_PATTERN)) {
+		const start = match.index;
+		if (start > cursor) runs.push(textRun(text.slice(cursor, start), options));
+		const inner = match.groups?.["inner"] ?? "";
+		runs.push(textRun(inner, options, { highlight: "yellow" }));
+		cursor = start + match[0].length;
+	}
+	if (cursor < text.length) runs.push(textRun(text.slice(cursor), options));
+	return runs.length > 0 ? runs : [textRun(text, options)];
+};
+const textRun = (text, options = {}, extra = {}) => ({
+	type: "run",
+	formatting: {
+		...options.bold ? { bold: true } : {},
+		...options.italic ? { italic: true } : {},
+		...extra.highlight ? { highlight: extra.highlight } : {}
+	},
+	content: [{
+		type: "text",
+		text,
+		preserveSpace: true
+	}]
+});
+const table = (headers, rows) => ({
+	type: "table",
+	rows: [tableRow(headers, true), ...rows.map((row) => tableRow(row, false))]
+});
+const tableRow = (cells, header) => ({
+	type: "tableRow",
+	cells: cells.map((cell) => tableCell(cell, header))
+});
+const tableCell = (text, header) => ({
+	type: "tableCell",
+	content: [paragraph(text, "TableText", { bold: header })]
+});
+const signatureTable = (parties) => {
+	const partyList = parties.length > 0 ? parties : [{
+		name: "",
+		signatory: "",
+		title: ""
+	}];
+	const empty = () => paragraph("", "SignatureSpacer");
+	const buildCell = (party) => {
+		const cellContent = [
+			paragraph(party.name, "SignatureParty", { bold: true }),
+			empty(),
+			empty(),
+			paragraph(SIGNATURE_LINE, "SignatureRule")
+		];
+		if (party.signatory) cellContent.push(paragraph(party.signatory, "SignatureField"));
+		if (party.title) cellContent.push(paragraph(party.title, "SignatureField", { italic: true }));
+		return {
+			type: "tableCell",
+			content: cellContent
+		};
+	};
+	return {
+		type: "table",
+		formatting: { borders: {
+			top: { style: "none" },
+			left: { style: "none" },
+			bottom: { style: "none" },
+			right: { style: "none" },
+			insideH: { style: "none" },
+			insideV: { style: "none" }
+		} },
+		rows: [{
+			type: "tableRow",
+			cells: partyList.map(buildCell)
+		}]
+	};
+};
+const clauseStyle = (level) => {
+	if (level === 1) return "ClauseHeading1";
+	if (level === 2) return "ClauseHeading2";
+	return "ClauseHeading3";
+};
+const pageProperties = (size, orientation) => {
+	const portrait = size === "A4" ? {
+		pageWidth: 11906,
+		pageHeight: 16838
+	} : {
+		pageWidth: 12240,
+		pageHeight: 15840
+	};
+	return {
+		...orientation === "landscape" ? {
+			pageWidth: portrait.pageHeight,
+			pageHeight: portrait.pageWidth
+		} : portrait,
+		orientation,
+		marginTop: 1440,
+		marginBottom: 1440,
+		marginLeft: 1440,
+		marginRight: 1440,
+		headerDistance: 720,
+		footerDistance: 720
+	};
+};
+const createStyleDefinitions = () => ({
+	docDefaults: {
+		rPr: {
+			fontFamily: {
+				ascii: "Calibri",
+				hAnsi: "Calibri",
+				cs: "Calibri"
+			},
+			fontSize: 22
+		},
+		pPr: {
+			lineSpacing: 276,
+			spaceAfter: 160
+		}
+	},
+	styles: [
+		{
+			styleId: "Normal",
+			type: "paragraph",
+			name: "Normal",
+			default: true,
+			rPr: {
+				fontFamily: {
+					ascii: "Calibri",
+					hAnsi: "Calibri",
+					cs: "Calibri"
+				},
+				fontSize: 22
+			}
+		},
+		{
+			styleId: "Title",
+			type: "paragraph",
+			name: "Title",
+			basedOn: "Normal",
+			next: "BodyText",
+			qFormat: true,
+			rPr: {
+				bold: true,
+				fontSize: 36,
+				allCaps: true
+			},
+			pPr: {
+				alignment: "center",
+				spaceBefore: 240,
+				spaceAfter: 480
+			}
+		},
+		{
+			styleId: "BodyText",
+			type: "paragraph",
+			name: "Body Text",
+			basedOn: "Normal",
+			rPr: { fontSize: 22 },
+			pPr: {
+				alignment: "both",
+				spaceAfter: 160
+			}
+		},
+		{
+			styleId: "Recital",
+			type: "paragraph",
+			name: "Recital",
+			basedOn: "BodyText",
+			rPr: { italic: true }
+		},
+		{
+			styleId: "ClauseHeading1",
+			type: "paragraph",
+			name: "Clause Heading 1",
+			basedOn: "BodyText",
+			next: "BodyText",
+			qFormat: true,
+			rPr: {
+				bold: true,
+				fontSize: 24,
+				allCaps: true
+			},
+			pPr: {
+				keepNext: true,
+				spaceBefore: 360,
+				spaceAfter: 160
+			}
+		},
+		{
+			styleId: "ClauseHeading2",
+			type: "paragraph",
+			name: "Clause Heading 2",
+			basedOn: "BodyText",
+			next: "BodyText",
+			qFormat: true,
+			rPr: {
+				bold: true,
+				fontSize: 22
+			},
+			pPr: {
+				keepNext: true,
+				spaceBefore: 240,
+				spaceAfter: 120
+			}
+		},
+		{
+			styleId: "ClauseHeading3",
+			type: "paragraph",
+			name: "Clause Heading 3",
+			basedOn: "BodyText",
+			next: "BodyText",
+			qFormat: true,
+			rPr: { italic: true },
+			pPr: {
+				keepNext: true,
+				spaceBefore: 160,
+				spaceAfter: 120
+			}
+		},
+		{
+			styleId: "ListParagraph",
+			type: "paragraph",
+			name: "List Paragraph",
+			basedOn: "BodyText"
+		},
+		{
+			styleId: "TableText",
+			type: "paragraph",
+			name: "Table Text",
+			basedOn: "Normal",
+			pPr: { spaceAfter: 0 }
+		},
+		{
+			styleId: "ScheduleHeading",
+			type: "paragraph",
+			name: "Schedule Heading",
+			basedOn: "ClauseHeading1",
+			pPr: {
+				pageBreakBefore: true,
+				keepNext: true,
+				spaceAfter: 240
+			}
+		},
+		{
+			styleId: "SignatureParty",
+			type: "paragraph",
+			name: "Signature Party",
+			basedOn: "Normal",
+			rPr: {
+				bold: true,
+				fontSize: 22
+			},
+			pPr: {
+				spaceBefore: 120,
+				spaceAfter: 80
+			}
+		},
+		{
+			styleId: "SignatureRule",
+			type: "paragraph",
+			name: "Signature Rule",
+			basedOn: "Normal",
+			pPr: {
+				spaceBefore: 0,
+				spaceAfter: 0
+			}
+		},
+		{
+			styleId: "SignatureField",
+			type: "paragraph",
+			name: "Signature Field",
+			basedOn: "Normal",
+			rPr: { fontSize: 20 },
+			pPr: { spaceAfter: 60 }
+		},
+		{
+			styleId: "SignatureSpacer",
+			type: "paragraph",
+			name: "Signature Spacer",
+			basedOn: "Normal",
+			pPr: {
+				spaceBefore: 0,
+				spaceAfter: 80
+			}
+		},
+		{
+			styleId: "Footer",
+			type: "paragraph",
+			name: "Footer",
+			basedOn: "Normal",
+			rPr: { fontSize: 18 },
+			pPr: {
+				alignment: "center",
+				spaceAfter: 0
+			}
+		}
+	]
+});
+const createNumberingDefinitions = (profile) => {
+	if (profile === "none") return;
+	if (profile === "checklist") return createChecklistNumberingDefinitions();
+	return createLegalNumberingDefinitions();
+};
+const createLegalNumberingDefinitions = () => ({
+	abstractNums: [{
+		abstractNumId: LEGAL_ABSTRACT_NUMBERING_ID,
+		multiLevelType: "hybridMultilevel",
+		levels: [
+			{
+				ilvl: 0,
+				start: 1,
+				numFmt: "decimal",
+				lvlText: "%1.",
+				suffix: "tab",
+				isLgl: true,
+				pPr: {
+					indentLeft: 720,
+					indentFirstLine: 720,
+					hangingIndent: true
+				},
+				rPr: { bold: true }
+			},
+			{
+				ilvl: 1,
+				start: 1,
+				numFmt: "decimal",
+				lvlText: "%1.%2",
+				suffix: "tab",
+				isLgl: true,
+				pPr: {
+					indentLeft: 720,
+					indentFirstLine: 720,
+					hangingIndent: true
+				}
+			},
+			{
+				ilvl: 2,
+				start: 1,
+				numFmt: "lowerLetter",
+				lvlText: "(%3)",
+				suffix: "tab",
+				pPr: {
+					indentLeft: 1440,
+					indentFirstLine: 720,
+					hangingIndent: true
+				}
+			},
+			{
+				ilvl: 3,
+				start: 1,
+				numFmt: "lowerRoman",
+				lvlText: "(%4)",
+				suffix: "tab",
+				pPr: {
+					indentLeft: 1440,
+					indentFirstLine: 720,
+					hangingIndent: true
+				}
+			},
+			{
+				ilvl: 4,
+				start: 1,
+				numFmt: "upperLetter",
+				lvlText: "(%5)",
+				suffix: "tab",
+				pPr: {
+					indentLeft: 2160,
+					indentFirstLine: 720,
+					hangingIndent: true
+				}
+			}
+		]
+	}, {
+		abstractNumId: BULLET_ABSTRACT_NUMBERING_ID,
+		multiLevelType: "singleLevel",
+		levels: [{
+			ilvl: 0,
+			start: 1,
+			numFmt: "bullet",
+			lvlText: "•",
+			suffix: "tab",
+			pPr: {
+				indentLeft: 720,
+				indentFirstLine: 360,
+				hangingIndent: true
+			}
+		}]
+	}],
+	nums: [{
+		numId: LEGAL_NUMBERING_ID,
+		abstractNumId: LEGAL_ABSTRACT_NUMBERING_ID
+	}, {
+		numId: BULLET_NUMBERING_ID,
+		abstractNumId: BULLET_ABSTRACT_NUMBERING_ID
+	}]
+});
+const createChecklistNumberingDefinitions = () => ({
+	abstractNums: [{
+		abstractNumId: CHECKLIST_ABSTRACT_NUMBERING_ID,
+		multiLevelType: "singleLevel",
+		levels: [{
+			ilvl: 0,
+			start: 1,
+			numFmt: "bullet",
+			lvlText: "☐",
+			suffix: "tab",
+			pPr: {
+				indentLeft: 720,
+				indentFirstLine: 360,
+				hangingIndent: true
+			}
+		}]
+	}],
+	nums: [{
+		numId: CHECKLIST_NUMBERING_ID,
+		abstractNumId: CHECKLIST_ABSTRACT_NUMBERING_ID
+	}]
+});
+//#endregion
+//#region src/legal-source/index.ts
+const compileLegalSourceToDocx = async (source, options = {}) => {
+	const result = compileLegalSourceToDocument(source, options);
+	if (result.status !== "ok") return result;
+	const buffer = Buffer.from(await serializeDocumentToDocx(result.document, { language: result.draft.meta.locale }));
+	const validation = await validateDocxPackage(buffer);
+	if (!validation.valid) return {
+		status: "needs_llm_repair",
+		draft: result.draft,
+		fixes: result.fixes,
+		errors: [{
+			code: "generated-docx-invalid",
+			message: validation.error,
+			severity: "error"
+		}]
+	};
+	return {
+		...result,
+		buffer
+	};
+};
+//#endregion
+export { assertValidDocumentModel, compileLegalSourceToDocument, compileLegalSourceToDocx, parseLegalSource, serializeDocumentToDocx, validateDocumentModel, validateDocxPackage, validateLegalDraft };