@a3s-lab/office 0.10.0 → 0.11.0

package/dist/{0~4705.js → 0~5093.js}

@@ -1,6 +1,6 @@
 import { descendants, directChildren as work_ooxml_package_directChildren, xmlNamespacePrefix, directChild, attribute as work_ooxml_package_attribute, childPath } from "./5184.js";
-import { xmlAttributeLocalName, docxThemeFont, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, docxThemeColor, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, xmlAttributeNamespace } from "./0~2805.js";
-import { DOCUMENT_PARAGRAPH_BORDER_STYLES, normalizeDocumentParagraphBorders as work_document_paragraph_borders_normalizeDocumentParagraphBorders, DOCUMENT_PARAGRAPH_BORDER_EDGES, normalizeDocumentPageBorders, normalizeDocumentParagraphBorder, normalizeDocumentEquation, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, serializeDocxThemeReference, documentParagraphShadingDomAttributes, importedDocumentCharacterFormatting, documentParagraphBordersDomAttributes, createDocumentEquationElement, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, documentEquationText, normalizeDocumentPaperSource, documentWordLineHeightFactor } from "./8928.js";
+import { xmlAttributeLocalName, docxThemeFont, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, xmlAttributeNamespace } from "./0~2805.js";
+import { DOCUMENT_PARAGRAPH_BORDER_STYLES, normalizeDocumentParagraphBorders as work_document_paragraph_borders_normalizeDocumentParagraphBorders, DOCUMENT_PARAGRAPH_BORDER_EDGES, normalizeDocumentPageBorders, normalizeDocumentParagraphBorder, normalizeDocumentParagraphIndent, serializeDocumentParagraphFormatting, normalizeDocumentEquation, DOCUMENT_PAGE_BORDER_EDGES, normalizeDocumentTabStops, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, documentWordLineHeightFactor, documentAutoLineHeight, renderDocumentAutoLineHeight, serializeDocxThemeReference, documentParagraphShadingDomAttributes, importedDocumentCharacterFormatting, documentParagraphBordersDomAttributes, createDocumentEquationElement, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, documentEquationText, normalizeDocumentPaperSource, serializeDocumentTabStops } from "./8928.js";
 function docxFieldInstructions(root) {
     return docxFieldOccurrences(root).map((field)=>field.instruction);
 }
@@ -4495,6 +4495,14 @@ function resolveDocxParagraphBordersForParagraph(paragraph, styleSource, themeSo
         spoofedCount: resolved.spoofedCount
     };
 }
+function resolveDocxParagraphBordersFromSources(propertySources, themeSource) {
+    const resolved = resolveParagraphBorderSources(propertySources, work_docx_theme_resolveDocxThemeResolver(themeSource));
+    return {
+        borders: work_document_paragraph_borders_normalizeDocumentParagraphBorders(resolved.borders),
+        invalidCount: resolved.invalidCount,
+        spoofedCount: resolved.spoofedCount
+    };
+}
 function applyImportedDocxParagraphBorderMarkers(document, markers) {
     const bordersByMarker = new Map(markers.paragraphs.map(({ marker, borders })=>[
             marker,
@@ -5476,6 +5484,9 @@ function parseDirectDocxParagraphShading(properties, themeSource) {
     const candidate = candidates[0];
     return candidate ? parseDocxParagraphShadingElement(candidate, themeSource) : void 0;
 }
+function resolveDocxParagraphShadingFromSources(propertySources, themeSource) {
+    return resolveParagraphShading(propertySources, work_docx_theme_resolveDocxThemeResolver(themeSource)).shading;
+}
 function resolveParagraphShading(propertySources, theme) {
     let shading = null;
     let specified = false;
@@ -5650,6 +5661,944 @@ function work_docx_paragraph_shading_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
+const work_docx_paragraph_alignment_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_paragraph_alignment_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const PARAGRAPH_ALIGNMENT_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_ALIGNMENT_\d+__/g;
+function markDocxParagraphAlignments(document, styleSource, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
+        const alignment = resolveDocxParagraphAlignment(sources);
+        if (!alignment) continue;
+        properties ??= work_docx_paragraph_alignment_import_insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_ALIGNMENT_${paragraphs.length + 1}__`;
+        work_docx_paragraph_alignment_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            alignment
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+function applyImportedDocxParagraphAlignmentMarkers(document, markers) {
+    const alignmentByMarker = new Map(markers.paragraphs.map(({ marker, alignment })=>[
+            marker,
+            alignment
+        ]));
+    for (const node of work_docx_paragraph_alignment_import_textNodes(document.body))if (node.data.includes('__A3S_WORK_PARAGRAPH_ALIGNMENT_')) node.data = node.data.replace(PARAGRAPH_ALIGNMENT_MARKER_PATTERN, (marker)=>{
+        const alignment = alignmentByMarker.get(marker);
+        const block = alignment ? work_docx_paragraph_alignment_import_closestParagraphBlock(node.parentElement, node) : null;
+        if (block && alignment) block.style.textAlign = alignment;
+        return '';
+    });
+    document.body.normalize();
+}
+function hasImportedDocxParagraphAlignmentMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function resolveDocxParagraphAlignment(propertySources) {
+    let direction = 'ltr';
+    let justification = null;
+    let hasJustification = false;
+    for (const properties of propertySources){
+        const bidi = directChild(properties, 'bidi');
+        if (bidi) direction = work_docx_paragraph_alignment_import_onOffValue(bidi) ? 'rtl' : 'ltr';
+        const source = directChild(properties, 'jc');
+        if (source) {
+            hasJustification = true;
+            justification = work_docx_paragraph_alignment_import_wordAttribute(source, 'val')?.trim() ?? null;
+        }
+    }
+    if (!hasJustification || !justification) return null;
+    if ('center' === justification) return 'center';
+    if ('left' === justification) return 'left';
+    if ('right' === justification) return 'right';
+    if ('start' === justification) return 'rtl' === direction ? 'right' : 'left';
+    if ('end' === justification) return 'rtl' === direction ? 'left' : 'right';
+    if ('both' === justification || 'distribute' === justification || 'highKashida' === justification || 'lowKashida' === justification || 'mediumKashida' === justification || 'thaiDistribute' === justification) return 'justify';
+    return null;
+}
+function work_docx_paragraph_alignment_import_onOffValue(element) {
+    const value = work_docx_paragraph_alignment_import_wordAttribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function work_docx_paragraph_alignment_import_wordAttribute(element, name) {
+    return work_ooxml_package_attribute(element, name) ?? work_ooxml_package_attribute(element, `w:${name}`);
+}
+function work_docx_paragraph_alignment_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_paragraph_alignment_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_paragraph_alignment_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_paragraph_alignment_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_paragraph_alignment_import_insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_paragraph_alignment_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_paragraph_alignment_import_closestParagraphBlock(element, markerNode) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote, li');
+    if (!(block instanceof HTMLElement)) return null;
+    return 'li' === block.tagName.toLowerCase() ? work_docx_paragraph_alignment_import_wrapListItemParagraph(block, markerNode) : block;
+}
+function work_docx_paragraph_alignment_import_wrapListItemParagraph(item, markerNode) {
+    let anchor = markerNode;
+    while(anchor.parentNode && anchor.parentNode !== item)anchor = anchor.parentNode;
+    const children = Array.from(item.childNodes);
+    const anchorIndex = children.indexOf(anchor);
+    if (anchorIndex < 0) return item;
+    let start = anchorIndex;
+    let end = anchorIndex;
+    while(start > 0 && !work_docx_paragraph_alignment_import_isListItemBlock(children[start - 1]))start -= 1;
+    while(end + 1 < children.length && !work_docx_paragraph_alignment_import_isListItemBlock(children[end + 1]))end += 1;
+    const paragraph = item.ownerDocument.createElement('p');
+    const grouped = children.slice(start, end + 1);
+    item.insertBefore(paragraph, grouped[0] ?? null);
+    paragraph.append(...grouped);
+    return paragraph;
+}
+function work_docx_paragraph_alignment_import_isListItemBlock(node) {
+    if (!(node instanceof HTMLElement)) return false;
+    return [
+        'blockquote',
+        'div',
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6',
+        'hr',
+        'ol',
+        'p',
+        'pre',
+        'table',
+        'ul'
+    ].includes(node.tagName.toLowerCase());
+}
+function work_docx_paragraph_alignment_import_textNodes(root) {
+    const document = root.ownerDocument;
+    const walker = document?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    if (!walker) return nodes;
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    return nodes;
+}
+const work_docx_paragraph_direction_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_paragraph_direction_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const PARAGRAPH_DIRECTION_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_DIRECTION_\d+__/g;
+function markDocxParagraphDirections(document, styleSource, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
+        const direction = resolveDocxParagraphDirection(sources);
+        if (!direction) continue;
+        properties ??= work_docx_paragraph_direction_import_insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_DIRECTION_${paragraphs.length + 1}__`;
+        work_docx_paragraph_direction_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            direction
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+function applyImportedDocxParagraphDirectionMarkers(document, markers) {
+    const directionByMarker = new Map(markers.paragraphs.map(({ marker, direction })=>[
+            marker,
+            direction
+        ]));
+    for (const node of work_docx_paragraph_direction_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_PARAGRAPH_DIRECTION_')) continue;
+        const block = work_docx_paragraph_direction_import_closestParagraphBlock(node.parentElement);
+        node.data = node.data.replace(PARAGRAPH_DIRECTION_MARKER_PATTERN, (marker)=>{
+            const direction = directionByMarker.get(marker);
+            if (block && direction) block.setAttribute('dir', direction);
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxParagraphDirectionMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function resolveDocxParagraphDirection(propertySources) {
+    let direction = null;
+    for (const properties of propertySources){
+        const bidi = directChild(properties, 'bidi');
+        if (bidi) direction = work_docx_paragraph_direction_import_onOffValue(bidi) ? 'rtl' : 'ltr';
+    }
+    return direction;
+}
+function work_docx_paragraph_direction_import_onOffValue(element) {
+    const value = (work_ooxml_package_attribute(element, 'val') ?? work_ooxml_package_attribute(element, 'w:val'))?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function work_docx_paragraph_direction_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_paragraph_direction_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_paragraph_direction_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_paragraph_direction_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_paragraph_direction_import_insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_paragraph_direction_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_paragraph_direction_import_closestParagraphBlock(element) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote, li');
+    return block instanceof HTMLElement ? block : null;
+}
+function work_docx_paragraph_direction_import_textNodes(root) {
+    const document = root.ownerDocument;
+    const walker = document?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    if (!walker) return nodes;
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    return nodes;
+}
+const work_docx_paragraph_indent_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_paragraph_indent_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const TWIPS_PER_CSS_PIXEL = 15;
+const PARAGRAPH_INDENT_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_INDENT_\d+__/g;
+function markDocxParagraphIndents(document, styleSource, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
+        if (sources.some((source)=>directChild(source, 'numPr'))) continue;
+        const indent = resolveDocxParagraphIndent(sources);
+        if (!indent.left && !indent.right && !indent.firstLine) continue;
+        properties ??= work_docx_paragraph_indent_import_insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_INDENT_${paragraphs.length + 1}__`;
+        work_docx_paragraph_indent_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            indent
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+function applyImportedDocxParagraphIndentMarkers(document, markers) {
+    const indentByMarker = new Map(markers.paragraphs.map(({ marker, indent })=>[
+            marker,
+            indent
+        ]));
+    for (const node of work_docx_paragraph_indent_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_PARAGRAPH_INDENT_')) continue;
+        const block = work_docx_paragraph_indent_import_closestParagraphBlock(node.parentElement);
+        node.data = node.data.replace(PARAGRAPH_INDENT_MARKER_PATTERN, (marker)=>{
+            const indent = indentByMarker.get(marker);
+            if (block && indent) applyParagraphIndent(block, indent);
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxParagraphIndentMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function resolveDocxParagraphIndent(propertySources) {
+    let left;
+    let right;
+    let firstLine;
+    for (const properties of propertySources){
+        const indent = directChild(properties, 'ind');
+        if (!indent) continue;
+        const sourceLeft = numericAttribute(indent, 'start') ?? numericAttribute(indent, 'left');
+        const sourceRight = numericAttribute(indent, 'end') ?? numericAttribute(indent, 'right');
+        const sourceFirstLine = numericAttribute(indent, 'firstLine');
+        const sourceHanging = numericAttribute(indent, 'hanging');
+        if (void 0 !== sourceLeft) left = sourceLeft;
+        if (void 0 !== sourceRight) right = sourceRight;
+        if (void 0 !== sourceFirstLine) firstLine = sourceFirstLine;
+        else if (void 0 !== sourceHanging) firstLine = -sourceHanging;
+    }
+    return normalizeDocumentParagraphIndent({
+        left: twipsToPixels(left),
+        right: twipsToPixels(right),
+        firstLine: twipsToPixels(firstLine)
+    });
+}
+function work_docx_paragraph_indent_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_paragraph_indent_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_paragraph_indent_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_paragraph_indent_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_paragraph_indent_import_insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_paragraph_indent_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_paragraph_indent_import_closestParagraphBlock(element) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote');
+    return block instanceof HTMLElement ? block : null;
+}
+function applyParagraphIndent(element, value) {
+    const indent = normalizeDocumentParagraphIndent(value);
+    if (indent.left) {
+        element.dataset.officeIndentLevel = formatNumber(indent.left / 24);
+        element.style.marginLeft = `${formatNumber(indent.left)}px`;
+    }
+    if (indent.right) {
+        element.dataset.officeIndentRight = formatNumber(indent.right);
+        element.style.marginRight = `${formatNumber(indent.right)}px`;
+    }
+    if (indent.firstLine) {
+        element.dataset.officeIndentFirstLine = formatNumber(indent.firstLine);
+        element.style.textIndent = `${formatNumber(indent.firstLine)}px`;
+    }
+}
+function numericAttribute(element, name) {
+    const raw = work_ooxml_package_attribute(element, name) ?? work_ooxml_package_attribute(element, `w:${name}`);
+    if (null === raw || !raw.trim()) return;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : void 0;
+}
+function twipsToPixels(value) {
+    if (void 0 === value) return 0;
+    return Math.round(value / TWIPS_PER_CSS_PIXEL);
+}
+function formatNumber(value) {
+    return Number(value.toFixed(2)).toString();
+}
+function work_docx_paragraph_indent_import_textNodes(root) {
+    const document = root.ownerDocument;
+    const walker = document?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    if (!walker) return nodes;
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    return nodes;
+}
+const work_docx_paragraph_pagination_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_paragraph_pagination_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const PARAGRAPH_PAGINATION_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_PAGINATION_\d+__/g;
+function markDocxParagraphPagination(document, styleSource, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        if (properties && directChild(properties, 'numPr')) continue;
+        const pagination = resolveDocxParagraphPagination(docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles)));
+        if (!Object.keys(pagination).length) continue;
+        properties ??= work_docx_paragraph_pagination_import_insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_PAGINATION_${paragraphs.length + 1}__`;
+        work_docx_paragraph_pagination_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            pagination
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+function applyImportedDocxParagraphPaginationMarkers(document, markers) {
+    const paginationByMarker = new Map(markers.paragraphs.map(({ marker, pagination })=>[
+            marker,
+            pagination
+        ]));
+    for (const node of work_docx_paragraph_pagination_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_PARAGRAPH_PAGINATION_')) continue;
+        const block = work_docx_paragraph_pagination_import_closestParagraphBlock(node.parentElement);
+        node.data = node.data.replace(PARAGRAPH_PAGINATION_MARKER_PATTERN, (marker)=>{
+            const pagination = paginationByMarker.get(marker);
+            if (block && pagination) applyParagraphPagination(block, pagination);
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxParagraphPaginationMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function resolveDocxParagraphPagination(sources) {
+    const pagination = {};
+    for (const properties of sources){
+        const keepLines = directChild(properties, 'keepLines');
+        const keepWithNext = directChild(properties, 'keepNext');
+        const pageBreakBefore = directChild(properties, 'pageBreakBefore');
+        const widowControl = directChild(properties, 'widowControl');
+        const contextualSpacing = directChild(properties, 'contextualSpacing');
+        const outlineLevel = directChild(properties, 'outlineLvl');
+        const defaultCollapsed = parseDocxParagraphDefaultCollapsed(properties);
+        if (keepLines) pagination.keepLines = work_docx_paragraph_pagination_import_onOffValue(keepLines);
+        if (keepWithNext) pagination.keepWithNext = work_docx_paragraph_pagination_import_onOffValue(keepWithNext);
+        if (pageBreakBefore) pagination.pageBreakBefore = work_docx_paragraph_pagination_import_onOffValue(pageBreakBefore);
+        if (widowControl) pagination.widowControl = work_docx_paragraph_pagination_import_onOffValue(widowControl);
+        if (contextualSpacing) pagination.contextualSpacing = work_docx_paragraph_pagination_import_onOffValue(contextualSpacing);
+        const outline = integerValue(outlineLevel);
+        if (null !== outline && outline <= 9) pagination.outlineLevel = outline;
+        if ('valid' === defaultCollapsed.status) pagination.defaultCollapsed = defaultCollapsed.value;
+        else if ('invalid' === defaultCollapsed.status) delete pagination.defaultCollapsed;
+    }
+    return pagination;
+}
+function work_docx_paragraph_pagination_import_onOffValue(element) {
+    const value = (work_ooxml_package_attribute(element, 'val') ?? work_ooxml_package_attribute(element, 'w:val'))?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function work_docx_paragraph_pagination_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_paragraph_pagination_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_paragraph_pagination_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_paragraph_pagination_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_paragraph_pagination_import_insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_paragraph_pagination_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_paragraph_pagination_import_closestParagraphBlock(element) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote');
+    return block instanceof HTMLElement ? block : null;
+}
+function applyParagraphPagination(element, pagination) {
+    setBooleanAttribute(element, 'data-office-keep-lines', pagination.keepLines);
+    setBooleanAttribute(element, 'data-office-keep-with-next', pagination.keepWithNext);
+    setBooleanAttribute(element, 'data-office-page-break-before', pagination.pageBreakBefore);
+    setBooleanAttribute(element, 'data-office-widow-control', pagination.widowControl);
+    setBooleanAttribute(element, 'data-office-contextual-spacing', pagination.contextualSpacing);
+    setBooleanAttribute(element, 'data-office-default-collapsed', pagination.defaultCollapsed);
+    if (void 0 !== pagination.outlineLevel) element.dataset.officeOutlineLevel = String(pagination.outlineLevel);
+}
+function integerValue(element) {
+    if (!element) return null;
+    const value = Number(work_ooxml_package_attribute(element, 'val') ?? work_ooxml_package_attribute(element, 'w:val'));
+    return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function setBooleanAttribute(element, name, value) {
+    if (void 0 !== value) element.setAttribute(name, String(value));
+}
+function work_docx_paragraph_pagination_import_textNodes(root) {
+    const document = root.ownerDocument;
+    const walker = document?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    if (!walker) return nodes;
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    return nodes;
+}
+const work_docx_paragraph_spacing_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_paragraph_spacing_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const PARAGRAPH_SPACING_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_SPACING_\d+__/g;
+function markDocxParagraphSpacing(document, styleSource, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const sources = docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
+        if (sources.some((source)=>directChild(source, 'numPr'))) continue;
+        const spacing = resolveDocxParagraphSpacing(sources);
+        if (!Object.keys(spacing).length) continue;
+        properties ??= work_docx_paragraph_spacing_import_insertParagraphProperties(document, paragraph);
+        const marker = `__A3S_WORK_PARAGRAPH_SPACING_${paragraphs.length + 1}__`;
+        work_docx_paragraph_spacing_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            spacing
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+function applyImportedDocxParagraphSpacingMarkers(document, markers) {
+    const spacingByMarker = new Map(markers.paragraphs.map(({ marker, spacing })=>[
+            marker,
+            spacing
+        ]));
+    for (const node of work_docx_paragraph_spacing_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_PARAGRAPH_SPACING_')) continue;
+        const block = work_docx_paragraph_spacing_import_closestParagraphBlock(node.parentElement);
+        node.data = node.data.replace(PARAGRAPH_SPACING_MARKER_PATTERN, (marker)=>{
+            const spacing = spacingByMarker.get(marker);
+            if (block && spacing) applyParagraphSpacing(block, spacing);
+            return '';
+        });
+    }
+    document.body.normalize();
+}
+function hasImportedDocxParagraphSpacingMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function resolveDocxParagraphSpacing(propertySources) {
+    let before;
+    let after;
+    let line;
+    let lineRule;
+    for (const properties of propertySources){
+        const spacing = directChild(properties, 'spacing');
+        if (!spacing) continue;
+        const sourceBefore = work_docx_paragraph_spacing_import_numericAttribute(spacing, 'before');
+        const sourceAfter = work_docx_paragraph_spacing_import_numericAttribute(spacing, 'after');
+        const sourceLine = work_docx_paragraph_spacing_import_numericAttribute(spacing, 'line');
+        const sourceLineRule = normalizedLineRule(work_docx_paragraph_spacing_import_wordAttribute(spacing, 'lineRule'));
+        if (void 0 !== sourceBefore) before = sourceBefore;
+        if (void 0 !== sourceAfter) after = sourceAfter;
+        if (void 0 !== sourceLine) {
+            line = sourceLine;
+            lineRule = sourceLineRule ?? 'auto';
+        } else if (sourceLineRule) lineRule = sourceLineRule;
+    }
+    const result = {};
+    if (void 0 !== before) result.before = twipsToPoints(before);
+    if (void 0 !== after) result.after = twipsToPoints(after);
+    if (void 0 !== line) {
+        const rule = lineRule ?? 'auto';
+        result.lineHeight = 'auto' === rule ? work_docx_paragraph_spacing_import_formatNumber(line / 240) : `${work_docx_paragraph_spacing_import_formatNumber(line / 20)}pt`;
+        result.lineRule = rule;
+    }
+    return result;
+}
+function applyParagraphSpacing(element, spacing) {
+    if (void 0 !== spacing.before && null !== spacing.before) {
+        const value = work_docx_paragraph_spacing_import_formatNumber(spacing.before);
+        element.dataset.officeSpaceBefore = value;
+        element.style.marginTop = `${value}pt`;
+    }
+    if (void 0 !== spacing.after && null !== spacing.after) {
+        const value = work_docx_paragraph_spacing_import_formatNumber(spacing.after);
+        element.dataset.officeSpaceAfter = value;
+        element.style.marginBottom = `${value}pt`;
+    }
+    if (spacing.lineHeight) element.style.lineHeight = spacing.lineHeight;
+    if (spacing.lineRule) element.dataset.officeLineRule = spacing.lineRule;
+    if ('auto' === spacing.lineRule) {
+        const autoLineHeight = documentAutoLineHeight(spacing.lineHeight);
+        for (const [name, value] of Object.entries(renderDocumentAutoLineHeight(spacing.lineHeight, autoLineHeight)))if ('style' === name) for (const declaration of value.split(';')){
+            const separator = declaration.indexOf(':');
+            if (!(separator < 0)) element.style.setProperty(declaration.slice(0, separator).trim(), declaration.slice(separator + 1).trim());
+        }
+        else element.setAttribute(name, value);
+    }
+}
+function work_docx_paragraph_spacing_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_paragraph_spacing_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_paragraph_spacing_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_paragraph_spacing_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_paragraph_spacing_import_insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_paragraph_spacing_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_paragraph_spacing_import_closestParagraphBlock(element) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote');
+    return block instanceof HTMLElement ? block : null;
+}
+function work_docx_paragraph_spacing_import_numericAttribute(element, name) {
+    const raw = work_docx_paragraph_spacing_import_wordAttribute(element, name);
+    if (null === raw || !raw.trim()) return;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : void 0;
+}
+function work_docx_paragraph_spacing_import_wordAttribute(element, name) {
+    return work_ooxml_package_attribute(element, name) ?? work_ooxml_package_attribute(element, `w:${name}`);
+}
+function normalizedLineRule(value) {
+    if ('auto' === value || 'atLeast' === value) return value;
+    if ('exact' === value || 'exactly' === value) return 'exact';
+}
+function twipsToPoints(value) {
+    return Number((value / 20).toFixed(2));
+}
+function work_docx_paragraph_spacing_import_formatNumber(value) {
+    return Number(value.toFixed(3)).toString();
+}
+function work_docx_paragraph_spacing_import_textNodes(root) {
+    const document = root.ownerDocument;
+    const walker = document?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    if (!walker) return nodes;
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    return nodes;
+}
+const work_docx_tab_stop_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_tab_stop_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const work_docx_tab_stop_import_TWIPS_PER_CSS_PIXEL = 15;
+const PARAGRAPH_TAB_STOP_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_TAB_STOPS_\d+__/g;
+const INLINE_TAB_MARKER_PATTERN = /__A3S_WORK_INLINE_TAB_\d+__/g;
+function markDocxParagraphTabStops(document, styleSource, tableStyleSource) {
+    const paragraphs = [];
+    const inlineTabs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        let properties = directChild(paragraph, 'pPr');
+        const tabStops = resolveDocxParagraphTabStops(docxParagraphPropertySources(properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles)));
+        if (tabStops.length) {
+            properties ??= work_docx_tab_stop_import_insertParagraphProperties(document, paragraph);
+            const marker = `__A3S_WORK_PARAGRAPH_TAB_STOPS_${paragraphs.length + 1}__`;
+            work_docx_tab_stop_import_insertParagraphMarker(document, paragraph, properties, marker);
+            paragraphs.push({
+                marker,
+                tabStops
+            });
+        }
+        for (const tab of inlineRunTabs(paragraph)){
+            const marker = `__A3S_WORK_INLINE_TAB_${inlineTabs.length + 1}__`;
+            const text = document.createElementNS(work_docx_tab_stop_import_WORD_NAMESPACE, 'w:t');
+            text.setAttributeNS(work_docx_tab_stop_import_XML_NAMESPACE, 'xml:space', 'preserve');
+            text.textContent = marker;
+            tab.replaceWith(text);
+            inlineTabs.push(marker);
+        }
+    }
+    return {
+        paragraphs,
+        inlineTabs
+    };
+}
+function applyImportedDocxParagraphTabStopMarkers(document, markers) {
+    const tabStopsByMarker = new Map(markers.paragraphs.map(({ marker, tabStops })=>[
+            marker,
+            tabStops
+        ]));
+    for (const node of work_docx_tab_stop_import_textNodes(document.body)){
+        if (!node.data.includes('__A3S_WORK_PARAGRAPH_TAB_STOPS_')) continue;
+        const block = work_docx_tab_stop_import_closestParagraphBlock(node.parentElement);
+        node.data = node.data.replace(PARAGRAPH_TAB_STOP_MARKER_PATTERN, (marker)=>{
+            const tabStops = tabStopsByMarker.get(marker);
+            if (block && tabStops?.length) block.dataset.officeTabStops = serializeDocumentTabStops(tabStops);
+            return '';
+        });
+    }
+    const inlineMarkers = new Set(markers.inlineTabs);
+    for (const node of work_docx_tab_stop_import_textNodes(document.body))if (node.data.includes('__A3S_WORK_INLINE_TAB_')) replaceInlineTabMarkers(node, inlineMarkers);
+    document.body.normalize();
+}
+function hasImportedDocxParagraphTabStopMarkers(markers) {
+    return markers.paragraphs.length > 0 || markers.inlineTabs.length > 0;
+}
+function resolveDocxParagraphTabStops(sources) {
+    const byPosition = new Map();
+    for (const properties of sources){
+        const tabs = directChild(properties, 'tabs');
+        if (tabs) for (const tab of work_ooxml_package_directChildren(tabs, 'tab')){
+            const positionTwips = work_docx_tab_stop_import_numericAttribute(tab, 'pos');
+            if (void 0 === positionTwips || positionTwips <= 0) continue;
+            const position = positionTwips / work_docx_tab_stop_import_TWIPS_PER_CSS_PIXEL;
+            const value = work_docx_tab_stop_import_wordAttribute(tab, 'val')?.trim();
+            if ('clear' === value || 'bar' === value) {
+                byPosition.delete(position);
+                continue;
+            }
+            byPosition.set(position, {
+                position,
+                alignment: docxTabAlignment(value),
+                leader: docxTabLeader(work_docx_tab_stop_import_wordAttribute(tab, 'leader'))
+            });
+        }
+    }
+    return normalizeDocumentTabStops(Array.from(byPosition.values()));
+}
+function inlineRunTabs(paragraph) {
+    return descendants(paragraph, 'tab').filter((tab)=>{
+        let parent = tab.parentElement;
+        while(parent && parent !== paragraph){
+            if ('tabs' === parent.localName) return false;
+            parent = parent.parentElement;
+        }
+        return parent === paragraph;
+    });
+}
+function replaceInlineTabMarkers(node, markers) {
+    const matches = Array.from(node.data.matchAll(INLINE_TAB_MARKER_PATTERN));
+    if (!matches.length) return;
+    const fragment = node.ownerDocument.createDocumentFragment();
+    let offset = 0;
+    for (const match of matches){
+        const marker = match[0];
+        const index = match.index ?? 0;
+        if (index > offset) fragment.append(node.data.slice(offset, index));
+        if (markers.has(marker)) {
+            const tab = node.ownerDocument.createElement('span');
+            tab.dataset.documentTab = 'true';
+            tab.className = 'work-document-tab';
+            tab.setAttribute('role', 'separator');
+            tab.setAttribute('aria-label', '制表符');
+            fragment.append(tab);
+        } else fragment.append(marker);
+        offset = index + marker.length;
+    }
+    if (offset < node.data.length) fragment.append(node.data.slice(offset));
+    node.replaceWith(fragment);
+}
+function work_docx_tab_stop_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const run = document.createElementNS(work_docx_tab_stop_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_tab_stop_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_tab_stop_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_tab_stop_import_insertParagraphProperties(document, paragraph) {
+    const properties = document.createElementNS(work_docx_tab_stop_import_WORD_NAMESPACE, 'w:pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_tab_stop_import_closestParagraphBlock(element) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote');
+    return block instanceof HTMLElement ? block : null;
+}
+function docxTabAlignment(value) {
+    if ('center' === value) return 'center';
+    if ('right' === value || 'end' === value) return 'right';
+    if ('decimal' === value || 'num' === value) return 'decimal';
+    return 'left';
+}
+function docxTabLeader(value) {
+    if ('dot' === value) return 'dot';
+    if ('hyphen' === value) return 'hyphen';
+    if ('underscore' === value || 'heavy' === value) return 'underscore';
+    if ('middleDot' === value) return 'middleDot';
+    return 'none';
+}
+function work_docx_tab_stop_import_numericAttribute(element, name) {
+    const raw = work_docx_tab_stop_import_wordAttribute(element, name);
+    if (null === raw || !raw.trim()) return;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : void 0;
+}
+function work_docx_tab_stop_import_wordAttribute(element, name) {
+    return work_ooxml_package_attribute(element, name) ?? work_ooxml_package_attribute(element, `w:${name}`);
+}
+function work_docx_tab_stop_import_textNodes(root) {
+    const document = root.ownerDocument;
+    const walker = document?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    if (!walker) return nodes;
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    return nodes;
+}
+const work_docx_paragraph_format_change_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const WORD_2012_NAMESPACE = 'http://schemas.microsoft.com/office/word/2012/wordml';
+const work_docx_paragraph_format_change_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const MAX_PARAGRAPH_FORMATTING_CHANGES = 65536;
+const PARAGRAPH_FORMATTING_CHANGE_MARKER_PATTERN = /__A3S_WORK_PARAGRAPH_FORMAT_CHANGE_\d+__/g;
+const SUPPORTED_PARAGRAPH_PROPERTY_CHANGE_CHILDREN = new Set([
+    'jc',
+    'bidi',
+    'ind',
+    'spacing',
+    'keepLines',
+    'keepNext',
+    'pageBreakBefore',
+    'widowControl',
+    'contextualSpacing',
+    'outlineLvl',
+    'tabs',
+    'pBdr',
+    'shd'
+]);
+function markDocxParagraphFormattingChanges(document, styleSource, themeSource, tableStyleSource) {
+    const paragraphs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const theme = work_docx_theme_resolveDocxThemeResolver(themeSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const paragraph of descendants(document, 'p')){
+        if (!work_docx_paragraph_format_change_import_isWordElement(paragraph)) continue;
+        const propertyNodes = work_ooxml_package_directChildren(paragraph, 'pPr').filter((element)=>element.namespaceURI === paragraph.namespaceURI);
+        if (1 !== propertyNodes.length) continue;
+        const properties = propertyNodes[0];
+        if (!properties) continue;
+        const change = supportedParagraphFormattingChange(properties);
+        if (!change) continue;
+        if (paragraphs.length >= MAX_PARAGRAPH_FORMATTING_CHANGES) continue;
+        const sources = docxParagraphPropertySources(change.properties, styles, docxTableParagraphPropertySources(paragraph, tableStyles));
+        const borders = resolveDocxParagraphBordersFromSources(sources, theme);
+        if (borders.invalidCount || borders.spoofedCount) continue;
+        const indent = resolveDocxParagraphIndent(sources);
+        const spacing = resolveDocxParagraphSpacing(sources);
+        const pagination = resolveDocxParagraphPagination(sources);
+        const tabStops = resolveDocxParagraphTabStops(sources);
+        const before = serializeDocumentParagraphFormatting({
+            textAlign: resolveDocxParagraphAlignment(sources),
+            paragraphDirection: resolveDocxParagraphDirection(sources),
+            indentLevel: indent.left / 24,
+            rightIndent: indent.right,
+            firstLineIndent: indent.firstLine,
+            spaceBefore: spacing.before ?? null,
+            spaceAfter: spacing.after ?? null,
+            lineHeight: spacing.lineHeight ?? null,
+            lineRule: spacing.lineRule ?? null,
+            autoLineHeight: 'auto' === spacing.lineRule ? documentAutoLineHeight(spacing.lineHeight) : null,
+            keepLines: pagination.keepLines ?? null,
+            keepWithNext: pagination.keepWithNext ?? null,
+            pageBreakBefore: pagination.pageBreakBefore ?? null,
+            widowControl: pagination.widowControl ?? null,
+            contextualSpacing: pagination.contextualSpacing ?? null,
+            outlineLevel: pagination.outlineLevel ?? null,
+            tabStops: tabStops.length ? tabStops : null,
+            paragraphBorders: borders.borders,
+            paragraphShading: resolveDocxParagraphShadingFromSources(sources, theme),
+            defaultCollapsed: pagination.defaultCollapsed ?? null
+        });
+        const marker = `__A3S_WORK_PARAGRAPH_FORMAT_CHANGE_${paragraphs.length + 1}__`;
+        work_docx_paragraph_format_change_import_insertParagraphMarker(document, paragraph, properties, marker);
+        paragraphs.push({
+            marker,
+            id: `docx-paragraph-format-change-${change.id}`,
+            author: change.author,
+            date: normalizeRevisionDate(change.date),
+            before
+        });
+    }
+    return {
+        paragraphs
+    };
+}
+function applyImportedDocxParagraphFormattingChangeMarkers(document, markers) {
+    const changes = new Map(markers.paragraphs.map((change)=>[
+            change.marker,
+            change
+        ]));
+    for (const node of work_docx_paragraph_format_change_import_textNodes(document.body))if (node.data.includes('__A3S_WORK_PARAGRAPH_FORMAT_CHANGE_')) node.data = node.data.replace(PARAGRAPH_FORMATTING_CHANGE_MARKER_PATTERN, (marker)=>{
+        const change = changes.get(marker);
+        const block = change ? work_docx_paragraph_format_change_import_closestParagraphBlock(node.parentElement, node) : null;
+        if (block && change) applyParagraphChange(block, change);
+        return '';
+    });
+    document.body.normalize();
+}
+function hasImportedDocxParagraphFormattingChangeMarkers(markers) {
+    return markers.paragraphs.length > 0;
+}
+function isSupportedDocxParagraphFormattingChange(change) {
+    const parent = change.parentElement;
+    const paragraph = parent?.parentElement;
+    return Boolean(parent?.localName === 'pPr' && DOCX_WORDPROCESSING_NAMESPACES.has(parent.namespaceURI ?? '') && paragraph?.localName === 'p' && DOCX_WORDPROCESSING_NAMESPACES.has(paragraph.namespaceURI ?? '') && 1 === Array.from(parent.children).filter((child)=>'pPrChange' === child.localName).length && supportedParagraphFormattingChangeElement(change));
+}
+function supportedParagraphFormattingChange(properties) {
+    const changes = Array.from(properties.children).filter((child)=>'pPrChange' === child.localName);
+    return 1 === changes.length ? supportedParagraphFormattingChangeElement(changes[0]) : null;
+}
+function supportedParagraphFormattingChangeElement(change) {
+    if ('pPrChange' !== change.localName || !DOCX_WORDPROCESSING_NAMESPACES.has(change.namespaceURI ?? '')) return null;
+    const propertyNodes = Array.from(change.children).filter((child)=>'pPr' === child.localName && DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? ''));
+    if (1 !== propertyNodes.length || 1 !== change.children.length) return null;
+    const properties = propertyNodes[0];
+    if (!properties) return null;
+    const names = new Set();
+    for (const child of Array.from(properties.children)){
+        const supportedWordChild = DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? '') && SUPPORTED_PARAGRAPH_PROPERTY_CHANGE_CHILDREN.has(child.localName);
+        const supportedCollapsed = 'collapsed' === child.localName && child.namespaceURI === WORD_2012_NAMESPACE;
+        if (!supportedWordChild && !supportedCollapsed || names.has(child.localName)) return null;
+        names.add(child.localName);
+    }
+    const id = work_ooxml_package_attribute(change, 'id')?.trim() ?? '';
+    const author = work_ooxml_package_attribute(change, 'author')?.trim() ?? '';
+    const date = work_ooxml_package_attribute(change, 'date');
+    if (!/^\+?\d{1,10}$/.test(id) || !author || author.length > 255) return null;
+    if (date && !Number.isFinite(Date.parse(date))) return null;
+    return {
+        id,
+        author,
+        date,
+        properties
+    };
+}
+function applyParagraphChange(element, change) {
+    element.dataset.documentChange = 'true';
+    element.dataset.changeKind = 'paragraph-formatting';
+    element.dataset.changeId = change.id;
+    element.dataset.changeAuthor = change.author;
+    element.dataset.changeDate = change.date;
+    element.dataset.changeBefore = change.before;
+}
+function work_docx_paragraph_format_change_import_insertParagraphMarker(document, paragraph, properties, marker) {
+    const namespace = paragraph.namespaceURI ?? work_docx_paragraph_format_change_import_WORD_NAMESPACE;
+    const prefix = paragraph.prefix || 'w';
+    const run = document.createElementNS(namespace, `${prefix}:r`);
+    const text = document.createElementNS(namespace, `${prefix}:t`);
+    text.setAttributeNS(work_docx_paragraph_format_change_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    run.append(text);
+    paragraph.insertBefore(run, properties.nextSibling);
+}
+function work_docx_paragraph_format_change_import_closestParagraphBlock(element, markerNode) {
+    const block = element?.closest('p, h1, h2, h3, h4, h5, h6, blockquote, li');
+    if (!(block instanceof HTMLElement)) return null;
+    return 'li' === block.tagName.toLowerCase() ? work_docx_paragraph_format_change_import_wrapListItemParagraph(block, markerNode) : block;
+}
+function work_docx_paragraph_format_change_import_wrapListItemParagraph(item, markerNode) {
+    let anchor = markerNode;
+    while(anchor.parentNode && anchor.parentNode !== item)anchor = anchor.parentNode;
+    const children = Array.from(item.childNodes);
+    const anchorIndex = children.indexOf(anchor);
+    if (anchorIndex < 0) return item;
+    let start = anchorIndex;
+    let end = anchorIndex;
+    while(start > 0 && !work_docx_paragraph_format_change_import_isListItemBlock(children[start - 1]))start -= 1;
+    while(end + 1 < children.length && !work_docx_paragraph_format_change_import_isListItemBlock(children[end + 1]))end += 1;
+    const paragraph = item.ownerDocument.createElement('p');
+    const grouped = children.slice(start, end + 1);
+    item.insertBefore(paragraph, grouped[0] ?? null);
+    paragraph.append(...grouped);
+    return paragraph;
+}
+function work_docx_paragraph_format_change_import_isListItemBlock(node) {
+    return node instanceof HTMLElement && [
+        'blockquote',
+        'div',
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6',
+        'hr',
+        'ol',
+        'p',
+        'pre',
+        'table',
+        'ul'
+    ].includes(node.tagName.toLowerCase());
+}
+function normalizeRevisionDate(value) {
+    if (!value) return '';
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? new Date(time).toISOString() : '';
+}
+function work_docx_paragraph_format_change_import_isWordElement(element) {
+    return DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '');
+}
+function work_docx_paragraph_format_change_import_textNodes(root) {
+    const document = root.ownerDocument;
+    const walker = document?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    if (!walker) return nodes;
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    return nodes;
+}
 const work_docx_run_formatting_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_run_formatting_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const RUN_FORMATTING_MARKER_PATTERN = /__A3S_WORK_RUN_(?:START|END)_\d+__/g;
@@ -5769,9 +6718,9 @@ function resolvedRunFormatting(propertySources, theme, runText) {
             assignFont(fonts, 'eastAsia', resolvedFont(runFonts, 'eastAsia', 'eastAsiaTheme', theme));
             assignFont(fonts, 'complex', resolvedFont(runFonts, 'cs', 'cstheme', theme));
         }
-        const size = numericAttribute(directChild(properties, 'sz'), 'val');
+        const size = work_docx_run_formatting_import_numericAttribute(directChild(properties, 'sz'), 'val');
         if (void 0 !== size && size > 0) fontSize = Math.min(512, size / 2);
-        const complexSize = numericAttribute(directChild(properties, 'szCs'), 'val');
+        const complexSize = work_docx_run_formatting_import_numericAttribute(directChild(properties, 'szCs'), 'val');
         if (void 0 !== complexSize && complexSize > 0) complexFontSize = Math.min(512, complexSize / 2);
         const colorElement = directChild(properties, 'color');
         if (colorElement) {
@@ -5891,7 +6840,7 @@ function formattingMarkup(document, formatting) {
         span.style.setProperty('--work-document-word-line-height-factor', factor);
     }
     if (void 0 !== formatting.wordSnapToGrid) span.dataset.officeWordSnapToGrid = String(formatting.wordSnapToGrid);
-    if (void 0 !== formatting.fontSize) span.style.fontSize = `${formatNumber(formatting.fontSize)}pt`;
+    if (void 0 !== formatting.fontSize) span.style.fontSize = `${work_docx_run_formatting_import_formatNumber(formatting.fontSize)}pt`;
     if (formatting.color) span.style.color = formatting.color;
     const themeColor = serializeDocxThemeReference(formatting.themeColor ?? null);
     if (themeColor) span.dataset.officeThemeColor = themeColor;
@@ -5933,7 +6882,7 @@ function importedRunFormattingChange(runProperties, paragraphProperties, styles,
     return {
         id: `docx-format-change-${parsed.id}`,
         author: parsed.author,
-        date: normalizeRevisionDate(parsed.date),
+        date: work_docx_run_formatting_import_normalizeRevisionDate(parsed.date),
         before: importedDocumentCharacterFormatting({
             ...beforeFormatting,
             themeColor: serializeDocxThemeReference(beforeFormatting.themeColor ?? null),
@@ -5985,7 +6934,7 @@ function formattingChangeMarkup(document, change) {
         end: '</span>'
     };
 }
-function normalizeRevisionDate(value) {
+function work_docx_run_formatting_import_normalizeRevisionDate(value) {
     if (!value) return '';
     const time = Date.parse(value);
     return Number.isFinite(time) ? new Date(time).toISOString() : '';
@@ -6109,7 +7058,7 @@ function uniqueFonts(values) {
 function cssFontFamily(value) {
     return /[\s"',]/.test(value) ? `"${value.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"` : value;
 }
-function numericAttribute(element, name) {
+function work_docx_run_formatting_import_numericAttribute(element, name) {
     if (!element) return;
     const raw = work_docx_run_formatting_import_wordAttribute(element, name);
     if (null === raw || !raw.trim()) return;
@@ -6141,10 +7090,10 @@ function wordHighlightColor(value) {
     };
     return colors[value] ?? 'transparent';
 }
-function formatNumber(value) {
+function work_docx_run_formatting_import_formatNumber(value) {
     return Number(value.toFixed(2)).toString();
 }
 function formatLineHeightFactor(value) {
     return Number(value.toFixed(4)).toString();
 }
-export { applyImportedDocxEquationMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphShadingMarkers, applyImportedDocxRunFormattingMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxParagraphPropertySources, docxTableCellStyleLayers, docxTableParagraphPropertySources, docxTablePropertySources, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphShadingMarkers, hasImportedDocxRunFormattingMarkers, hasInvalidDocxFieldStructure, inspectDocxEquation, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, isSupportedDocxRunFormattingChange, markDocxPackageEquations, markDocxParagraphBorders, markDocxParagraphShading, markDocxRunFormatting, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxParagraphBordersForParagraph, resolveDocxParagraphStyleResolver, resolveDocxTableStyleResolver };
+export { applyImportedDocxEquationMarkers, applyImportedDocxParagraphAlignmentMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphDirectionMarkers, applyImportedDocxParagraphFormattingChangeMarkers, applyImportedDocxParagraphIndentMarkers, applyImportedDocxParagraphPaginationMarkers, applyImportedDocxParagraphShadingMarkers, applyImportedDocxParagraphSpacingMarkers, applyImportedDocxParagraphTabStopMarkers, applyImportedDocxRunFormattingMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxTableCellStyleLayers, docxTablePropertySources, hasImportedDocxParagraphAlignmentMarkers, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxParagraphIndentMarkers, hasImportedDocxParagraphPaginationMarkers, hasImportedDocxParagraphShadingMarkers, hasImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphTabStopMarkers, hasImportedDocxRunFormattingMarkers, hasInvalidDocxFieldStructure, inspectDocxEquation, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, isSupportedDocxParagraphFormattingChange, isSupportedDocxRunFormattingChange, markDocxPackageEquations, markDocxParagraphAlignments, markDocxParagraphBorders, markDocxParagraphDirections, markDocxParagraphFormattingChanges, markDocxParagraphIndents, markDocxParagraphPagination, markDocxParagraphShading, markDocxParagraphSpacing, markDocxParagraphTabStops, markDocxRunFormatting, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxParagraphBordersForParagraph, resolveDocxTableStyleResolver };