@a3s-lab/office 0.47.0 → 0.48.0

package/README.md

@@ -309,6 +309,23 @@ and [CLI reference](./docs/latest/en/cli-reference.md).
 
 ## Current release
 
+Version `0.48.0` adds bounded native Writer content controls without
+introducing a second document model or a remote service:
+
+- The Insert ribbon and responsive dialog author inline plain-text or rich-text
+  controls with aliases, program tags, multiline text, border/tag/hidden
+  appearance, and an optional theme color. Each accepted change is one typed
+  update and one Undo step, and the control exposes an accessible textbox name.
+- Content and shell locks are enforced at the transaction boundary, including
+  direct editor transactions. Locked content cannot be changed accidentally;
+  typed unlock/delete commands remain explicit and auditable.
+- Direct paragraph DOCX `w:sdt` controls round-trip through strict and
+  transitional WordprocessingML with collision-free native IDs, rich run
+  formatting, lock/multiline metadata, and Word 2012 appearance/color. Active
+  bindings, placeholders, repeating regions, form controls, nested or
+  relationship-bound structures remain safe editable text with compatibility
+  diagnostics instead of an inexact editable promise.
+
 Version `0.47.0` adds a bounded common-field workflow for Writer without
 introducing a second document model or a remote service:
 

package/dist/{0~2133.js → 0~3320.js}

@@ -1,6 +1,6 @@
 import { documentRunBorderDomAttributes, normalizeDocumentRunBorder, normalizeDocumentParagraphBorder, serializeDocumentRunBorder, serializeDocumentRunShading, documentIndexEntryHtml, attribute as work_ooxml_package_attribute, documentScriptFontFallbackSlots, documentScriptFontsDomAttributes, documentHighlightFromDocxValue, serializeDocxThemeReference, directChildren as work_ooxml_package_directChildren, documentParagraphShadingDomAttributes, documentTableOfContentsHtml, documentParagraphBordersDomAttributes, normalizeDocumentScriptFontHint, normalizeDocumentScriptFonts, DOCUMENT_PARAGRAPH_BORDER_STYLES, normalizeDocumentParagraphBorders as work_document_paragraph_borders_normalizeDocumentParagraphBorders, DOCUMENT_PARAGRAPH_BORDER_EDGES, documentScriptFontFamily, normalizeDocumentThemeFont, normalizeDocumentParagraphId, documentHighlightDomAttributes, descendants, documentIndexHtml, documentHighlightCssColor, xmlNamespacePrefix, normalizeDocumentFontName, documentProofingDomAttributes, work_document_paragraph_shading_DOCUMENT_PARAGRAPH_SHADING_PATTERNS, directChild, documentScriptFontSegments, childPath, parseDocumentTableOfContentsInstruction, documentRunShadingDomAttributes } from "./6968.js";
-import { docxThemeFont, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, parseDocumentIndexEntryInstruction, resolveDocxProofing, parseDocumentIndexInstruction, DOCX_WORD_2010_NAMESPACE, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, STRICT_WORDPROCESSING_NAMESPACE, docxCharacterSpacingTwipsFromProperties, parseBoundedDocxInteger, xmlAttributeLocalName, resolveDocxOpenTypeFeatures, docxCharacterScalePercentFromProperties, resolveDocxEmphasisMark, docxCharacterPositionHalfPointsFromProperties, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxKerningThresholdHalfPoints, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace, parseDocxTwipsMeasure } from "./0~4042.js";
-import { normalizeDocumentEmphasisMark, normalizeDocumentPageBorders, textBoxCss, documentCharacterPositionDomAttributes, DOCUMENT_PAGE_BORDER_EDGES, normalizeDocumentTabStops, documentTextCaseFromWordFlags, documentStrikeDomAttributes, serializeDocumentNumberingChange, numberingTypeFromFormat, normalizeDocumentUnderlineColor, documentAutoLineHeight, documentKerningDomAttributes, documentCharacterScaleDomAttributes, textBoxDomAttributes, serializeDocumentParagraphFormatting, normalizeDocumentPaperSource, documentEquationText, documentLegacyTextEffectsDomAttributes, documentLegacyTextEffectsConflict, documentCharacterSpacingDomAttributes, normalizeDocumentParagraphIndent, normalizeDocumentEquation, documentOpenTypeDomAttributes, normalizeDocumentTextBoxProperties, renderDocumentAutoLineHeight, documentUnderlineDomAttributes, MAX_DOCUMENT_NUMBERING_START, normalizeDocumentUnderlineStyle, applyDocumentTextCaseStyle, documentHiddenTextDomAttributes, importedDocumentCharacterFormatting, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, createDocumentEquationElement, normalizeDocumentPageGeometry, serializeDocumentTabStops, documentWordLineHeightFactor, documentEmphasisMarkDomAttributes, normalizeDocumentPageMargins } from "./4174.js";
+import { normalizeDocumentEmphasisMark, normalizeDocumentPageBorders, textBoxCss, documentCharacterPositionDomAttributes, DOCUMENT_PAGE_BORDER_EDGES, normalizeDocumentTabStops, documentTextCaseFromWordFlags, documentStrikeDomAttributes, serializeDocumentNumberingChange, numberingTypeFromFormat, normalizeDocumentUnderlineColor, documentAutoLineHeight, documentKerningDomAttributes, documentCharacterScaleDomAttributes, textBoxDomAttributes, serializeDocumentParagraphFormatting, normalizeDocumentContentControlProperties, documentEquationText, normalizeDocumentPaperSource, documentLegacyTextEffectsDomAttributes, documentLegacyTextEffectsConflict, documentCharacterSpacingDomAttributes, normalizeDocumentParagraphIndent, normalizeDocumentEquation, documentOpenTypeDomAttributes, normalizeDocumentTextBoxProperties, renderDocumentAutoLineHeight, contentControlDomAttributes, documentUnderlineDomAttributes, MAX_DOCUMENT_NUMBERING_START, normalizeDocumentUnderlineStyle, applyDocumentTextCaseStyle, documentHiddenTextDomAttributes, importedDocumentCharacterFormatting, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, normalizeDocumentPageGeometry, createDocumentEquationElement, serializeDocumentTabStops, documentEmphasisMarkDomAttributes, normalizeDocumentPageMargins, documentWordLineHeightFactor } from "./4174.js";
+import { hasUnsupportedContentControlSemanticChild, docxThemeFont, hasContentControlRelationshipReference, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, parseDocumentIndexEntryInstruction, resolveDocxProofing, parseDocumentIndexInstruction, CONTENT_CONTROL_WORD_2012_NAMESPACE, DOCX_WORD_2010_NAMESPACE, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, STRICT_WORDPROCESSING_NAMESPACE, docxCharacterSpacingTwipsFromProperties, parseBoundedDocxInteger, isDocxWordElement, xmlAttributeLocalName, resolveDocxOpenTypeFeatures, resolveDocxEmphasisMark, docxCharacterScalePercentFromProperties, docxCharacterPositionHalfPointsFromProperties, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxKerningThresholdHalfPoints, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace, parseDocxTwipsMeasure } from "./0~3534.js";
 function docxCaptionSequenceKind(instruction) {
     const identifier = /^\s*SEQ\s+([^\s\\]+)/i.exec(instruction)?.[1]?.toLowerCase();
     if (!identifier) return null;
@@ -158,6 +158,428 @@ function fieldRange(field, indexes) {
 function containsRange(outer, inner) {
     return outer.start >= 0 && inner.start >= 0 && outer.start < inner.start && outer.end >= inner.end;
 }
+const WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const STRICT_WORD_NAMESPACE = 'http://purl.oclc.org/ooxml/wordprocessingml/main';
+const WORD_NAMESPACES = new Set([
+    WORD_NAMESPACE,
+    STRICT_WORD_NAMESPACE
+]);
+const MARKUP_COMPATIBILITY_NAMESPACE = 'http://schemas.openxmlformats.org/markup-compatibility/2006';
+const MAX_IMPORTED_CONTENT_CONTROLS = 4096;
+const MAX_CONTENT_CONTROL_TEXT = 1000000;
+const RUN_CONTENT_NAMES = new Set([
+    'br',
+    'cr',
+    'noBreakHyphen',
+    'softHyphen',
+    'tab',
+    't'
+]);
+const PROPERTY_NAMES = new Set([
+    'alias',
+    'id',
+    'lock',
+    'richText',
+    'tag',
+    'text'
+]);
+const LOCK_VALUES = new Set([
+    'contentLocked',
+    'sdtContentLocked',
+    'sdtLocked',
+    'unlocked'
+]);
+const APPEARANCE_VALUES = new Set([
+    'boundingBox',
+    'hidden',
+    'tags'
+]);
+function inspectDocxContentControls(document) {
+    let supported = 0;
+    let unsupported = 0;
+    for (const control of descendants(document, 'sdt'))if (!hasContentControlAncestor(control)) {
+        if (!isStructuralContentControl(control)) if (isDirectParagraphControl(control) && readContentControl(control, 0)) supported += 1;
+        else unsupported += 1;
+    }
+    return {
+        supported,
+        unsupported
+    };
+}
+function markDocxContentControls(document) {
+    const controls = [];
+    let unsupported = 0;
+    const candidates = descendants(document, 'sdt').filter((control)=>!hasContentControlAncestor(control) && !isStructuralContentControl(control));
+    for (const [index, control] of candidates.entries()){
+        if (!isDirectParagraphControl(control)) {
+            unsupported += 1;
+            continue;
+        }
+        const properties = readContentControl(control, index + 1);
+        if (!properties) {
+            unsupported += 1;
+            continue;
+        }
+        if (controls.length >= MAX_IMPORTED_CONTENT_CONTROLS) throw new Error('Imported DOCX exceeds the content-control limit.');
+        const [start, end] = contentControlMarkers(document, controls.length + 1);
+        if (!replaceControlWithMarkers(document, control, start, end)) {
+            unsupported += 1;
+            continue;
+        }
+        controls.push({
+            start,
+            end,
+            properties
+        });
+    }
+    return {
+        controls,
+        unsupported
+    };
+}
+function contentControlMarkers(document, initialIndex) {
+    const occupiedText = document.documentElement.textContent ?? '';
+    let index = initialIndex;
+    for(let attempts = 0; attempts < 1000000; attempts += 1){
+        const start = `__A3S_WORK_CONTENT_CONTROL_START_${index}__`;
+        const end = `__A3S_WORK_CONTENT_CONTROL_END_${index}__`;
+        if (!occupiedText.includes(start) && !occupiedText.includes(end)) return [
+            start,
+            end
+        ];
+        index += 1;
+    }
+    throw new Error('Imported DOCX content-control marker space is exhausted.');
+}
+function applyImportedDocxContentControlMarkers(document, markers) {
+    if (!markers.controls.length) return;
+    for (const marker of markers.controls){
+        const wrapper = document.createElement('span');
+        for (const [name, value] of Object.entries(contentControlDomAttributes(marker.properties)))if (void 0 !== value) wrapper.setAttribute(name, value);
+        wrapper.className = 'work-document-content-control';
+        wrapper.setAttribute('role', 'textbox');
+        wrapper.setAttribute('aria-label', marker.properties.alias || marker.properties.tag || '内容控件');
+        if ('contentLocked' === marker.properties.lock || 'sdtContentLocked' === marker.properties.lock) wrapper.setAttribute('contenteditable', 'false');
+        replaceMarkerRange(document.body, marker.start, marker.end, wrapper);
+    }
+    document.body.normalize();
+}
+function hasImportedDocxContentControlMarkers(markers) {
+    return markers.controls.length > 0;
+}
+function readContentControl(control, sequence) {
+    const definition = readDefinition(control);
+    if (!definition) return null;
+    const metadata = readProperties(definition.properties);
+    if (!metadata) return null;
+    const runs = Array.from(definition.content.children);
+    if (!runs.length || runs.some((run)=>!isDocxWordElement(run) || 'r' !== run.localName) || hasUnsupportedContentControlSemanticChild(definition.content) || runs.some((run)=>!validRun(run))) {
+        if (runs.length) return null;
+    }
+    const text = runs.map(work_docx_content_control_import_runText).join('');
+    if (text.length > MAX_CONTENT_CONTROL_TEXT) throw new Error('Imported DOCX content control text is too large.');
+    if ('text' === metadata.type && !metadata.multiLine && text.includes('\n')) return null;
+    const nativeId = metadata.nativeId;
+    return normalizeDocumentContentControlProperties({
+        id: `docx-content-control-${sequence}`,
+        nativeId,
+        type: metadata.type,
+        alias: metadata.alias,
+        tag: metadata.tag,
+        lock: metadata.lock,
+        multiLine: metadata.multiLine,
+        appearance: metadata.appearance,
+        color: metadata.color
+    });
+}
+function readDefinition(control) {
+    if (!isDocxWordElement(control) || 'sdt' !== control.localName || !isDirectParagraphControl(control) || hasContentControlRelationshipReference(control) || hasUnsupportedContentControlSemanticChild(control) || !validControlAttributes(control)) return null;
+    const children = Array.from(control.children);
+    const properties = children.filter((child)=>isDocxWordElement(child) && 'sdtPr' === child.localName);
+    const content = children.filter((child)=>isDocxWordElement(child) && 'sdtContent' === child.localName);
+    const endProperties = children.filter((child)=>isDocxWordElement(child) && 'sdtEndPr' === child.localName);
+    if (1 !== properties.length || 1 !== content.length || endProperties.length > 1 || children.some((child)=>!isDocxWordElement(child) || 'sdtPr' !== child.localName && 'sdtContent' !== child.localName && 'sdtEndPr' !== child.localName)) return null;
+    if ([
+        control,
+        properties[0],
+        content[0],
+        endProperties[0]
+    ].some((element)=>element && hasNonWhitespaceText(element))) return null;
+    if (endProperties[0] && (endProperties[0].children.length > 0 || !validContainerAttributes(endProperties[0]))) return null;
+    if (!validContainerAttributes(properties[0]) || !validContainerAttributes(content[0])) return null;
+    return {
+        control,
+        content: content[0],
+        properties: properties[0]
+    };
+}
+function readProperties(properties) {
+    if (hasContentControlRelationshipReference(properties)) return null;
+    const children = Array.from(properties.children);
+    const groups = new Map();
+    let appearance = 'boundingBox';
+    let color = null;
+    for (const child of children){
+        const namespace = child.namespaceURI ?? '';
+        if (isDocxWordElement(child)) {
+            if (!PROPERTY_NAMES.has(child.localName)) return null;
+            const matches = groups.get(child.localName) ?? [];
+            matches.push(child);
+            groups.set(child.localName, matches);
+            continue;
+        }
+        if (namespace === CONTENT_CONTROL_WORD_2012_NAMESPACE) {
+            if ('appearance' !== child.localName && 'color' !== child.localName) return null;
+            const matches = groups.get(`w15:${child.localName}`) ?? [];
+            matches.push(child);
+            groups.set(`w15:${child.localName}`, matches);
+            continue;
+        }
+        if (namespace !== MARKUP_COMPATIBILITY_NAMESPACE) return null;
+    }
+    if (Array.from(groups.values()).some((items)=>items.length > 1)) return null;
+    const id = groups.get('id')?.[0];
+    if (id && !validLeaf(id, new Set([
+        'val'
+    ]))) return null;
+    const nativeId = id ? parseNativeId(wordAttribute(id, 'val')) : null;
+    if (id && null === nativeId) return null;
+    const alias = readStringProperty(groups.get('alias')?.[0]);
+    const tag = readStringProperty(groups.get('tag')?.[0]);
+    if (null === alias || null === tag) return null;
+    const lockElement = groups.get('lock')?.[0];
+    if (lockElement && !validLeaf(lockElement, new Set([
+        'val'
+    ]))) return null;
+    const lockValue = lockElement ? wordAttribute(lockElement, 'val') : null;
+    const lock = lockValue ?? 'unlocked';
+    if (!LOCK_VALUES.has(lock)) return null;
+    const textElement = groups.get('text')?.[0];
+    const richTextElement = groups.get('richText')?.[0];
+    if (textElement && richTextElement) return null;
+    if (textElement && !validLeaf(textElement, new Set([
+        'multiLine'
+    ]))) return null;
+    if (richTextElement && !validLeaf(richTextElement, new Set())) return null;
+    const multilineValue = textElement ? wordAttribute(textElement, 'multiLine') : null;
+    if (null !== multilineValue && ![
+        '0',
+        '1',
+        'false',
+        'off',
+        'on',
+        'true'
+    ].includes(multilineValue)) return null;
+    const appearanceElement = groups.get('w15:appearance')?.[0];
+    if (appearanceElement) {
+        if (!validNamespacedLeaf(appearanceElement, new Set([
+            'val'
+        ]), CONTENT_CONTROL_WORD_2012_NAMESPACE)) return null;
+        const value = namespacedAttribute(appearanceElement, 'val', CONTENT_CONTROL_WORD_2012_NAMESPACE);
+        if (!value || !APPEARANCE_VALUES.has(value)) return null;
+        appearance = value;
+    }
+    const colorElement = groups.get('w15:color')?.[0];
+    if (colorElement) {
+        if (!validNamespacedLeaf(colorElement, new Set([
+            'val'
+        ]), CONTENT_CONTROL_WORD_2012_NAMESPACE)) return null;
+        const value = namespacedAttribute(colorElement, 'val', CONTENT_CONTROL_WORD_2012_NAMESPACE);
+        if (!value || !/^[0-9a-f]{6}$/i.test(value)) return null;
+        color = `#${value.toLowerCase()}`;
+    }
+    return {
+        alias: alias ?? '',
+        appearance,
+        color,
+        lock: lock,
+        multiLine: null !== multilineValue && [
+            '1',
+            'on',
+            'true'
+        ].includes(multilineValue),
+        nativeId,
+        tag: tag ?? '',
+        type: textElement ? 'text' : 'richText'
+    };
+}
+function replaceControlWithMarkers(document, control, start, end) {
+    const paragraph = control.parentElement;
+    const content = Array.from(control.children).find((child)=>isDocxWordElement(child) && 'sdtContent' === child.localName);
+    if (!paragraph || !content) return false;
+    const startRun = work_docx_content_control_import_markerRun(document, paragraph, start);
+    const endRun = work_docx_content_control_import_markerRun(document, paragraph, end);
+    paragraph.insertBefore(startRun, control);
+    const runs = Array.from(content.children);
+    for (const run of runs)paragraph.insertBefore(run, control);
+    paragraph.insertBefore(endRun, control);
+    control.remove();
+    return true;
+}
+function work_docx_content_control_import_markerRun(document, context, value) {
+    const namespace = context.namespaceURI ?? WORD_NAMESPACE;
+    const prefix = xmlNamespacePrefix(context, namespace) ?? 'w';
+    const run = document.createElementNS(namespace, `${prefix}:r`);
+    const text = document.createElementNS(namespace, `${prefix}:t`);
+    text.setAttributeNS(work_docx_settings_xml_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = value;
+    run.append(text);
+    return run;
+}
+function replaceMarkerRange(root, start, end, replacement) {
+    const startElement = replaceMarkerWithBoundary(root, start, 'start');
+    const endElement = replaceMarkerWithBoundary(root, end, 'end');
+    if (!startElement || !endElement) return;
+    if (startElement.parentNode === endElement.parentNode) {
+        const parent = startElement.parentNode;
+        let current = startElement.nextSibling;
+        while(current && current !== endElement){
+            const next = current.nextSibling;
+            replacement.append(current);
+            current = next;
+        }
+        if (current === endElement) {
+            startElement.replaceWith(replacement);
+            endElement.remove();
+            return;
+        }
+        parent?.append(replacement);
+        startElement.remove();
+        endElement.remove();
+        return;
+    }
+    const range = root.ownerDocument.createRange();
+    try {
+        range.setStartAfter(startElement);
+        range.setEndBefore(endElement);
+        const content = range.extractContents();
+        replacement.append(content);
+        startElement.replaceWith(replacement);
+        endElement.remove();
+    } catch  {
+        startElement.remove();
+        endElement.remove();
+    }
+}
+function replaceMarkerWithBoundary(root, marker, kind) {
+    const node = textNodes(root).find((candidate)=>candidate.data.includes(marker));
+    if (!node?.parentNode) return null;
+    const ownerDocument = root.ownerDocument;
+    if (!ownerDocument) return null;
+    const offset = node.data.indexOf(marker);
+    const before = node.data.slice(0, offset);
+    const after = node.data.slice(offset + marker.length);
+    const boundary = ownerDocument.createElement('span');
+    boundary.dataset.contentControlBoundary = kind;
+    node.parentNode.insertBefore(ownerDocument.createTextNode(before), node);
+    node.parentNode.insertBefore(boundary, node);
+    if (after) node.parentNode.insertBefore(ownerDocument.createTextNode(after), node);
+    node.remove();
+    return boundary;
+}
+function textNodes(root) {
+    const walker = root.ownerDocument?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    if (!walker) return nodes;
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    return nodes;
+}
+function validControlAttributes(element) {
+    return validContainerAttributes(element);
+}
+function validRun(run) {
+    if (hasNonWhitespaceText(run)) return false;
+    let sawContent = false;
+    let properties = 0;
+    for (const child of Array.from(run.children)){
+        if (!isDocxWordElement(child)) return false;
+        if ('rPr' === child.localName) {
+            properties += 1;
+            if (properties > 1 || sawContent) return false;
+            if (hasContentControlRelationshipReference(child)) return false;
+            continue;
+        }
+        if (!RUN_CONTENT_NAMES.has(child.localName)) return false;
+        sawContent = true;
+        if ('t' === child.localName && (child.textContent?.length ?? 0) > MAX_CONTENT_CONTROL_TEXT) return false;
+    }
+    return true;
+}
+function work_docx_content_control_import_runText(run) {
+    let value = '';
+    for (const child of Array.from(run.children))if (isDocxWordElement(child)) {
+        if ('t' === child.localName) value += child.textContent ?? '';
+        else if ('tab' === child.localName) value += '\t';
+        else if ('br' === child.localName || 'cr' === child.localName) value += '\n';
+        else if ('noBreakHyphen' === child.localName) value += '\u2011';
+        else if ('softHyphen' === child.localName) value += '\u00ad';
+    }
+    return value;
+}
+function isDirectParagraphControl(control) {
+    return isDocxWordElement(control) && Boolean(control.parentElement && isDocxWordElement(control.parentElement) && 'p' === control.parentElement.localName);
+}
+function hasContentControlAncestor(control) {
+    let current = control.parentElement;
+    while(current){
+        if (isDocxWordElement(current) && 'sdt' === current.localName) return true;
+        current = current.parentElement;
+    }
+    return false;
+}
+function isStructuralContentControl(control) {
+    const properties = Array.from(control.children).find((child)=>isDocxWordElement(child) && 'sdtPr' === child.localName);
+    if (!properties) return false;
+    return Array.from(properties.children).some((child)=>isDocxWordElement(child) && [
+            'docPartObj',
+            'docPartList'
+        ].includes(child.localName));
+}
+function wordAttribute(element, localName) {
+    const matches = Array.from(element.attributes).filter((item)=>xmlAttributeLocalName(item) === localName && xmlAttributeNamespace(element, item) === element.namespaceURI && WORD_NAMESPACES.has(element.namespaceURI ?? ''));
+    return 1 === matches.length ? matches[0].value : null;
+}
+function namespacedAttribute(element, localName, namespace) {
+    const matches = Array.from(element.attributes).filter((item)=>xmlAttributeLocalName(item) === localName && xmlAttributeNamespace(element, item) === namespace);
+    return 1 === matches.length ? matches[0].value : null;
+}
+function readStringProperty(element) {
+    if (!element) return '';
+    if (!validLeaf(element, new Set([
+        'val'
+    ]))) return null;
+    const value = wordAttribute(element, 'val');
+    if (null === value || /[\u0000-\u001f\u007f]/u.test(value)) return null;
+    return value.slice(0, 255);
+}
+function validContainerAttributes(element) {
+    return Array.from(element.attributes).every((item)=>{
+        const namespace = xmlAttributeNamespace(element, item);
+        return 'http://www.w3.org/2000/xmlns/' === namespace || namespace === MARKUP_COMPATIBILITY_NAMESPACE;
+    });
+}
+function hasNonWhitespaceText(element) {
+    return Array.from(element.childNodes).some((child)=>child.nodeType === Node.TEXT_NODE && Boolean(child.textContent?.trim()));
+}
+function validLeaf(element, allowedAttributes) {
+    return 0 === element.children.length && Array.from(element.childNodes).every((child)=>child.nodeType !== Node.TEXT_NODE || !(child.textContent ?? '').trim()) && Array.from(element.attributes).every((item)=>{
+        const namespace = xmlAttributeNamespace(element, item);
+        if ('http://www.w3.org/2000/xmlns/' === namespace) return true;
+        if (namespace === MARKUP_COMPATIBILITY_NAMESPACE) return true;
+        return namespace === element.namespaceURI && WORD_NAMESPACES.has(element.namespaceURI ?? '') && allowedAttributes.has(xmlAttributeLocalName(item));
+    });
+}
+function validNamespacedLeaf(element, allowedAttributes, namespace) {
+    return 0 === element.children.length && Array.from(element.childNodes).every((child)=>child.nodeType !== Node.TEXT_NODE || !(child.textContent ?? '').trim()) && Array.from(element.attributes).every((item)=>{
+        const attributeNamespace = xmlAttributeNamespace(element, item);
+        return 'http://www.w3.org/2000/xmlns/' === attributeNamespace || attributeNamespace === namespace && allowedAttributes.has(xmlAttributeLocalName(item));
+    });
+}
+function parseNativeId(value) {
+    if (null === value || !/^-?(0|[1-9][0-9]{0,9})$/u.test(value)) return null;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed >= -2147483648 && parsed <= 2147483647 ? parsed : null;
+}
 function isDocxEquationLikeRoot(element) {
     return 'oMath' === element.localName || 'oMathPara' === element.localName;
 }
@@ -276,7 +698,7 @@ function wordPrefix(element, namespace) {
 }
 const TRANSITIONAL_MATH_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/math';
 const STRICT_MATH_NAMESPACE = 'http://purl.oclc.org/ooxml/officeDocument/math';
-const STRICT_WORD_NAMESPACE = 'http://purl.oclc.org/ooxml/wordprocessingml/main';
+const work_docx_equation_import_STRICT_WORD_NAMESPACE = 'http://purl.oclc.org/ooxml/wordprocessingml/main';
 const DOCX_MATH_NAMESPACES = new Set([
     TRANSITIONAL_MATH_NAMESPACE,
     STRICT_MATH_NAMESPACE
@@ -1982,7 +2404,7 @@ function parseWordPosition(element) {
     const source = attributes.get('val')?.trim() ?? '';
     const integer = wordIntegerValue(source, MIN_WORD_POSITION_HALF_POINTS, MAX_WORD_POSITION_HALF_POINTS);
     if (null !== integer) return integer;
-    return element.namespaceURI === STRICT_WORD_NAMESPACE ? strictUniversalHalfPoints(source, MIN_WORD_POSITION_HALF_POINTS, MAX_WORD_POSITION_HALF_POINTS) : null;
+    return element.namespaceURI === work_docx_equation_import_STRICT_WORD_NAMESPACE ? strictUniversalHalfPoints(source, MIN_WORD_POSITION_HALF_POINTS, MAX_WORD_POSITION_HALF_POINTS) : null;
 }
 function parseWordHalfPointSize(element) {
     if (!element) return;
@@ -1992,7 +2414,7 @@ function parseWordHalfPointSize(element) {
     if (!attributes || 1 !== attributes.size) return null;
     const source = attributes.get('val')?.trim() ?? '';
     const integer = wordIntegerValue(source, 1, MAX_WORD_HALF_POINT_SIZE);
-    const halfPoints = integer ?? (element.namespaceURI === STRICT_WORD_NAMESPACE ? strictUniversalHalfPoints(source, 1, MAX_WORD_HALF_POINT_SIZE) : null);
+    const halfPoints = integer ?? (element.namespaceURI === work_docx_equation_import_STRICT_WORD_NAMESPACE ? strictUniversalHalfPoints(source, 1, MAX_WORD_HALF_POINT_SIZE) : null);
     return null === halfPoints ? null : halfPoints / 2;
 }
 function wordIntegerValue(source, minimum, maximum) {
@@ -2138,7 +2560,7 @@ function parseWordFitText(element) {
     if (!attributes?.has('val')) return null;
     const source = attributes.get('val')?.trim() ?? '';
     const integer = wordIntegerValue(source, 0, MAX_WORD_FIT_TEXT_WIDTH_TWIPS);
-    const widthTwips = integer ?? (element.namespaceURI === STRICT_WORD_NAMESPACE ? strictUniversalTwips(source, 0, MAX_WORD_FIT_TEXT_WIDTH_TWIPS) : null);
+    const widthTwips = integer ?? (element.namespaceURI === work_docx_equation_import_STRICT_WORD_NAMESPACE ? strictUniversalTwips(source, 0, MAX_WORD_FIT_TEXT_WIDTH_TWIPS) : null);
     const id = attributes.has('id') ? wordIntegerValue(attributes.get('id')?.trim() ?? '', MIN_WORD_FIT_TEXT_ID, MAX_WORD_FIT_TEXT_ID) : void 0;
     return null === widthTwips || null === id ? null : {
         widthTwips,
@@ -4073,7 +4495,7 @@ function nextEquationMarker(state) {
     state.occupiedText += marker;
     return marker;
 }
-const WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_index_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_index_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 function markDocxIndexes(document) {
     const fields = docxFieldOccurrences(document);
@@ -4124,11 +4546,11 @@ function applyImportedDocxIndexMarkers(document, markers) {
         });
         const parsed = document.createRange().createContextualFragment(html);
         const replacement = parsed.firstElementChild;
-        if (replacement instanceof HTMLElement) replaceMarkerRange(document.body, entry.start, entry.end, replacement);
+        if (replacement instanceof HTMLElement) work_docx_index_import_replaceMarkerRange(document.body, entry.start, entry.end, replacement);
     }
     const importedEntries = Array.from(document.body.querySelectorAll('[data-document-index-entry]'));
     for (const index of markers.indexes){
-        const text = textNodes(document.body).find((node)=>node.data.includes(index.marker));
+        const text = work_docx_index_import_textNodes(document.body).find((node)=>node.data.includes(index.marker));
         if (!text) continue;
         const entries = index.entries.map((entry, entryIndex)=>{
             const targets = importedEntries.filter((candidate)=>normalizedTerm(candidate.dataset.indexMainEntry) === normalizedTerm(entry.mainEntry) && normalizedTerm(candidate.dataset.indexSubEntry) === normalizedTerm(entry.subEntry));
@@ -4250,23 +4672,23 @@ function insertFieldBoundaryMarkers(document, field, start, end) {
     field.end.parentNode?.insertBefore(work_docx_index_import_markerRun(document, end), field.end.nextSibling);
 }
 function markerParagraph(document, marker) {
-    const paragraph = document.createElementNS(WORD_NAMESPACE, 'w:p');
+    const paragraph = document.createElementNS(work_docx_index_import_WORD_NAMESPACE, 'w:p');
     paragraph.append(work_docx_index_import_markerRun(document, marker));
     return paragraph;
 }
 function work_docx_index_import_markerRun(document, value) {
-    const run = document.createElementNS(WORD_NAMESPACE, 'w:r');
+    const run = document.createElementNS(work_docx_index_import_WORD_NAMESPACE, 'w:r');
     run.append(markerText(document, value));
     return run;
 }
 function markerText(document, value) {
-    const text = document.createElementNS(WORD_NAMESPACE, 'w:t');
+    const text = document.createElementNS(work_docx_index_import_WORD_NAMESPACE, 'w:t');
     text.setAttributeNS(work_docx_index_import_XML_NAMESPACE, 'xml:space', 'preserve');
     text.textContent = value;
     return text;
 }
-function replaceMarkerRange(root, start, end, replacement) {
-    const nodes = textNodes(root);
+function work_docx_index_import_replaceMarkerRange(root, start, end, replacement) {
+    const nodes = work_docx_index_import_textNodes(root);
     const startNode = nodes.find((node)=>node.data.includes(start));
     const endNode = nodes.find((node)=>node.data.includes(end));
     if (!startNode || !endNode) return;
@@ -4276,7 +4698,7 @@ function replaceMarkerRange(root, start, end, replacement) {
     range.deleteContents();
     range.insertNode(replacement);
 }
-function textNodes(root) {
+function work_docx_index_import_textNodes(root) {
     const walker = root.ownerDocument?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
     const nodes = [];
     if (!walker) return nodes;
@@ -4394,10 +4816,10 @@ function supportedNumberingChange(change) {
     if (1 !== levels.length || 1 !== numberingIds.length) return null;
     const level = boundedWordInteger(levels[0], 'val', 0, 8);
     const numberingId = boundedWordInteger(numberingIds[0], 'val', 0, MAX_DOCUMENT_NUMBERING_START);
-    const id = wordAttribute(change, 'id')?.trim() ?? '';
-    const author = wordAttribute(change, 'author')?.trim() ?? '';
-    const rawDate = wordAttribute(change, 'date');
-    const original = wordAttribute(change, 'original') ?? '';
+    const id = work_docx_numbering_change_import_wordAttribute(change, 'id')?.trim() ?? '';
+    const author = work_docx_numbering_change_import_wordAttribute(change, 'author')?.trim() ?? '';
+    const rawDate = work_docx_numbering_change_import_wordAttribute(change, 'date');
+    const original = work_docx_numbering_change_import_wordAttribute(change, 'original') ?? '';
     if (null === level || null === numberingId || !/^\+?\d{1,10}$/.test(id) || !author || author.length > 255 || /[\u0000-\u001f\u007f]/.test(author) || null !== rawDate && !Number.isFinite(Date.parse(rawDate))) return null;
     const definitions = parseOriginalNumbering(original);
     const definition = definitions?.get(level + 1);
@@ -4507,12 +4929,12 @@ function directWordChildren(parent, localName) {
 }
 function boundedWordInteger(element, name, minimum, maximum) {
     if (!element) return null;
-    const raw = wordAttribute(element, name);
+    const raw = work_docx_numbering_change_import_wordAttribute(element, name);
     if (!raw || !/^\d{1,10}$/.test(raw)) return null;
     const value = Number(raw);
     return Number.isSafeInteger(value) && value >= minimum && value <= maximum ? value : null;
 }
-function wordAttribute(element, localName) {
+function work_docx_numbering_change_import_wordAttribute(element, localName) {
     const namespace = element.namespaceURI;
     if (!namespace) return null;
     const attributes = Array.from(element.attributes).filter((attribute)=>xmlAttributeLocalName(attribute) === localName && xmlAttributeNamespace(element, attribute) === namespace);
@@ -5314,7 +5736,7 @@ function inspectDocxPageBorders(sectionProperties, themeSource) {
         spoofedCount: spoofedContainers
     };
     const attributes = wordContainerAttributes(container);
-    if (!attributes || hasNonWhitespaceText(container)) return {
+    if (!attributes || work_docx_page_borders_import_hasNonWhitespaceText(container)) return {
         status: 'invalid',
         invalidCount: 1,
         spoofedCount: spoofedContainers
@@ -5410,7 +5832,7 @@ function pageBorderZOrder(value) {
     const normalized = value.trim();
     return PAGE_BORDER_Z_ORDERS.has(normalized) ? normalized : null;
 }
-function hasNonWhitespaceText(element) {
+function work_docx_page_borders_import_hasNonWhitespaceText(element) {
     return Array.from(element.childNodes).some((node)=>node.nodeType === Node.TEXT_NODE && node.textContent?.trim());
 }
 function work_docx_page_borders_import_isNamespaceDeclaration(attribute) {
@@ -8511,4 +8933,4 @@ function work_docx_text_box_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
-export { applyImportedDocxEquationMarkers, applyImportedDocxIndexMarkers, applyImportedDocxNumberingChangeMarkers, applyImportedDocxParagraphAlignmentMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphDirectionMarkers, applyImportedDocxParagraphFormattingChangeMarkers, applyImportedDocxParagraphIndentMarkers, applyImportedDocxParagraphPaginationMarkers, applyImportedDocxParagraphShadingMarkers, applyImportedDocxParagraphSpacingMarkers, applyImportedDocxParagraphTabStopMarkers, applyImportedDocxRunFormattingMarkers, applyImportedDocxTableOfContentsMarkers, applyImportedDocxTextBoxMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, createImportedDocxRunFormattingMarkerState, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxRunPropertySources, docxTableCellStyleLayers, docxTablePropertySources, docxTableRunPropertySources, hasImportedDocxIndexMarkers, hasImportedDocxNumberingChangeMarkers, hasImportedDocxParagraphAlignmentMarkers, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxParagraphIndentMarkers, hasImportedDocxParagraphPaginationMarkers, hasImportedDocxParagraphShadingMarkers, hasImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphTabStopMarkers, hasImportedDocxRunFormattingMarkers, hasImportedDocxTableOfContentsMarkers, hasImportedDocxTextBoxMarkers, hasInvalidDocxFieldStructure, importedDocxStrike, importedDocxUnderline, inspectDocxEquation, inspectDocxHiddenText, inspectDocxLegacyTextEffects, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, inspectDocxRunBorder, inspectDocxRunFonts, inspectDocxRunShading, inspectDocxTextBoxes, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, isSupportedDocxNumberingChange, isSupportedDocxParagraphFormattingChange, isSupportedDocxRunFormattingChange, markDocxIndexes, markDocxNumberingChanges, markDocxPackageEquations, markDocxParagraphAlignments, markDocxParagraphBorders, markDocxParagraphDirections, markDocxParagraphFormattingChanges, markDocxParagraphIndents, markDocxParagraphPagination, markDocxParagraphShading, markDocxParagraphSpacing, markDocxParagraphTabStops, markDocxRunFormattingIntoState, markDocxTablesOfContents, markDocxTextBoxes, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxHiddenText, resolveDocxLegacyTextEffects, resolveDocxParagraphBordersForParagraph, resolveDocxRunBorder, resolveDocxRunShading, resolveDocxTableStyleResolver, supportedDocxIndexEntryField, supportedDocxIndexField, supportedDocxTableOfContentsField };
+export { applyImportedDocxContentControlMarkers, applyImportedDocxEquationMarkers, applyImportedDocxIndexMarkers, applyImportedDocxNumberingChangeMarkers, applyImportedDocxParagraphAlignmentMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphDirectionMarkers, applyImportedDocxParagraphFormattingChangeMarkers, applyImportedDocxParagraphIndentMarkers, applyImportedDocxParagraphPaginationMarkers, applyImportedDocxParagraphShadingMarkers, applyImportedDocxParagraphSpacingMarkers, applyImportedDocxParagraphTabStopMarkers, applyImportedDocxRunFormattingMarkers, applyImportedDocxTableOfContentsMarkers, applyImportedDocxTextBoxMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, createImportedDocxRunFormattingMarkerState, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxRunPropertySources, docxTableCellStyleLayers, docxTablePropertySources, docxTableRunPropertySources, hasImportedDocxContentControlMarkers, hasImportedDocxIndexMarkers, hasImportedDocxNumberingChangeMarkers, hasImportedDocxParagraphAlignmentMarkers, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxParagraphIndentMarkers, hasImportedDocxParagraphPaginationMarkers, hasImportedDocxParagraphShadingMarkers, hasImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphTabStopMarkers, hasImportedDocxRunFormattingMarkers, hasImportedDocxTableOfContentsMarkers, hasImportedDocxTextBoxMarkers, hasInvalidDocxFieldStructure, importedDocxStrike, importedDocxUnderline, inspectDocxContentControls, inspectDocxEquation, inspectDocxHiddenText, inspectDocxLegacyTextEffects, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, inspectDocxRunBorder, inspectDocxRunFonts, inspectDocxRunShading, inspectDocxTextBoxes, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, isSupportedDocxNumberingChange, isSupportedDocxParagraphFormattingChange, isSupportedDocxRunFormattingChange, markDocxContentControls, markDocxIndexes, markDocxNumberingChanges, markDocxPackageEquations, markDocxParagraphAlignments, markDocxParagraphBorders, markDocxParagraphDirections, markDocxParagraphFormattingChanges, markDocxParagraphIndents, markDocxParagraphPagination, markDocxParagraphShading, markDocxParagraphSpacing, markDocxParagraphTabStops, markDocxRunFormattingIntoState, markDocxTablesOfContents, markDocxTextBoxes, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxHiddenText, resolveDocxLegacyTextEffects, resolveDocxParagraphBordersForParagraph, resolveDocxRunBorder, resolveDocxRunShading, resolveDocxTableStyleResolver, supportedDocxIndexEntryField, supportedDocxIndexField, supportedDocxTableOfContentsField };