@a3s-lab/office 0.45.0 → 0.47.0

package/dist/0~work-docx-export.js

@@ -1,5 +1,5 @@
 import jszip from "jszip";
-import { normalizeDocumentBookmarkName, normalizeDocumentEmphasisMark, DOCUMENT_STRIKE_STYLE_ATTRIBUTE, applyDocumentImageIdentityToElement, documentEmphasisMarkFromElement, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE, createDocumentImageIdentityRegistry, normalizeDocumentColumns, normalizeDocumentTableVerticalAlign, normalizeDocumentTextCase, documentCharacterSpacingTwipsFromElement, documentCharacterPositionHalfPointsFromElement, documentTableColumnPercentagesFromElement, documentTableCellMarginOverridesFromElement, applyDocumentTableRowIdentityToElement, normalizeDocumentBookmarksHtml, documentImageIdentityFromElement, documentTableGeometryFromElement, normalizeDocumentTableRowHeightRule, documentNoteKey, DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE, normalizeDocumentHiddenText, documentLegacyTextEffectsConflict, normalizeDocumentTableBorderWidth, normalizeDocumentCharacterSpacingTwips, documentStrikeFormattingFromElement, normalizeDocumentTableBorderStyle, parseDocumentNumberingChange, normalizeDocumentBookmarkReferencesHtml, documentCitationInstruction, documentImageWrapContourFromElement, documentImagePositionFromElement, normalizeDocumentCharacterScalePercent, normalizeDocumentUnderlineStyle, normalizeDocumentPageChrome, documentPageMarginsForLayout, normalizeDocumentImageLayer, documentKerningThresholdHalfPointsFromElement, documentImageCropFromElement, documentBookmarkReferenceInstruction, normalizeDocumentPageBorders, documentImageLayerFromElement, serializeDocumentOpenTypeFeatures, documentCaptionLabel, documentCaptionKind, isContourImageLayout, normalizeDocumentLegacyTextEffects, DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE, normalizeDocumentImageIdentity, normalizeDocumentStrikeStyle, normalizeTableColor, normalizeDocumentOpenTypeFeatures, documentCitationTags, docxDocumentFieldKind, documentTableBordersFromElement, documentSections, wrapsBesideImage, normalizeDocumentCharacterPositionHalfPoints, normalizeDocumentKerningThresholdHalfPoints, defaultDocumentImageWrapContour, parseDocumentOpenTypeFeatures, normalizeDocumentPaperSource, DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE, documentEquationFromElement, documentImageTransformFromElement, parseDocumentCharacterFormatting, documentLegacyTextEffectsFromElement, documentUnderlineFormattingFromElement, DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE, normalizeDocumentEquation, parseDocumentParagraphFormatting, documentOpenTypeFeaturesFromElement, normalizeDocumentBookmarkNativeId, documentTableRowIdentityFromElement, DOCUMENT_PAGE_MARGIN_KEYS, uniqueDocumentImageIdentity, documentHiddenTextFromElement, collectDocumentNotes, documentImageLayoutFromElement, documentPageHorizontalMarginTwips, DOCUMENT_OPEN_TYPE_ATTRIBUTE, MAX_DOCUMENT_NUMBERING_START, documentPageGeometryForLayout, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, documentCharacterScalePercentFromElement, normalizeDocumentPageMargins, normalizeDocumentLegacyTextEffect, documentNoteKind } from "./4174.js";
+import { normalizeDocumentBookmarkName, normalizeDocumentEmphasisMark, DOCUMENT_STRIKE_STYLE_ATTRIBUTE, applyDocumentImageIdentityToElement, documentEmphasisMarkFromElement, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE, createDocumentImageIdentityRegistry, normalizeDocumentColumns, normalizeDocumentTableVerticalAlign, normalizeDocumentTextCase, documentCharacterSpacingTwipsFromElement, documentCharacterPositionHalfPointsFromElement, documentTableColumnPercentagesFromElement, documentTableCellMarginOverridesFromElement, applyDocumentTableRowIdentityToElement, normalizeDocumentBookmarksHtml, documentImageIdentityFromElement, documentTableGeometryFromElement, normalizeDocumentTableRowHeightRule, documentNoteKey, DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE, normalizeDocumentHiddenText, documentLegacyTextEffectsConflict, normalizeDocumentTableBorderWidth, normalizeDocumentCharacterSpacingTwips, documentStrikeFormattingFromElement, normalizeDocumentTableBorderStyle, parseDocumentNumberingChange, normalizeDocumentBookmarkReferencesHtml, documentCitationInstruction, documentImageWrapContourFromElement, documentImagePositionFromElement, normalizeDocumentCharacterScalePercent, normalizeDocumentUnderlineStyle, normalizeDocumentPageChrome, documentPageMarginsForLayout, normalizeDocumentImageLayer, documentKerningThresholdHalfPointsFromElement, documentImageCropFromElement, documentBookmarkReferenceInstruction, normalizeDocumentPageBorders, documentImageLayerFromElement, serializeDocumentOpenTypeFeatures, documentCaptionLabel, documentCaptionKind, isContourImageLayout, normalizeDocumentLegacyTextEffects, DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE, normalizeDocumentImageIdentity, supportedDocxDocumentFieldInstruction, normalizeDocumentStrikeStyle, normalizeDocumentOpenTypeFeatures, documentCitationTags, docxDocumentFieldKind, normalizeTableColor, documentTableBordersFromElement, documentSections, wrapsBesideImage, normalizeDocumentCharacterPositionHalfPoints, normalizeDocumentKerningThresholdHalfPoints, documentTextBoxPropertiesFromElement, defaultDocumentImageWrapContour, parseDocumentOpenTypeFeatures, normalizeDocumentPaperSource, DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE, documentEquationFromElement, documentImageTransformFromElement, parseDocumentCharacterFormatting, documentLegacyTextEffectsFromElement, documentUnderlineFormattingFromElement, DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE, normalizeDocumentEquation, parseDocumentParagraphFormatting, documentOpenTypeFeaturesFromElement, normalizeDocumentBookmarkNativeId, documentTableRowIdentityFromElement, DOCUMENT_PAGE_MARGIN_KEYS, uniqueDocumentImageIdentity, documentHiddenTextFromElement, collectDocumentNotes, documentImageLayoutFromElement, documentPageHorizontalMarginTwips, DOCUMENT_OPEN_TYPE_ATTRIBUTE, MAX_DOCUMENT_NUMBERING_START, documentPageGeometryForLayout, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, documentCharacterScalePercentFromElement, normalizeDocumentPageMargins, normalizeDocumentLegacyTextEffect, documentNoteKind } from "./4174.js";
 import { normalizeDocumentRunBorder, parseDocumentScriptFonts, parseDocxThemeReference, parseXml, parseDocumentRunShading, applyDocumentParagraphIdentityToElement, DOCUMENT_RUN_SHADING_ATTRIBUTE, documentScriptFontSlotFromElement, DOCUMENT_HIGHLIGHT_ATTRIBUTE, normalizeDocumentIndexesHtml, serializeDocumentScriptFonts, attribute as work_ooxml_package_attribute, createDocumentParagraphIdentityRegistry, uniqueDocumentParagraphIdentity, DOCUMENT_NO_PROOF_ATTRIBUTE, documentHighlightForCssColor, directChildren, documentTableOfContentsValueFromElement, DOCUMENT_PROOFING_LANGUAGES_ATTRIBUTE, DocxThemePatchCollector, normalizeDocumentScriptFonts, normalizeDocumentParagraphIdentity, normalizeDocumentHighlight, normalizeDocumentParagraphBorders, serializeUtf8Xml, DOCUMENT_PARAGRAPH_BORDER_EDGES, parseDocumentRunBorder, normalizeDocumentNoProof, decodeXmlBytes, documentParagraphIdentityFromElement, normalizeDocumentParagraphId, documentScriptFontFamily, descendants, resolvePartTarget, documentProofingLanguagesFromElement, documentHighlightFromElement, parseDocumentRunShadingElement, parseDocumentProofingLanguages, patchDocxThemeReferences, parseDocumentParagraphBordersElement, DOCUMENT_RUN_BORDER_ATTRIBUTE, parseDocumentRunBorderElement, xmlNamespacePrefix, documentScriptFontSlotFromHint, documentNoProofFromElement, documentScriptFontsFromElement, normalizeDocumentRunShading, normalizeDocumentScriptFontSlot, directChild, documentIndexEntryFromElement, documentIndexValueFromElement, parseDocumentParagraphShadingElement, documentFontNameFromCssFamily } from "./6968.js";
 import { assignDocxNoteIds, patchDocxPageColor, normalizeDocxCommentId, assignDocxCommentThreads } from "./0~4980.js";
 import { DocxImageTransformPatchCollector, paragraphTabStops, patchDocxImageTransforms, mergeDocxIgnorableExtensionsAtPairs, DOCX_WORD_2010_NAMESPACE, docxKerningThresholdValue, patchDocxBibliography, documentIndexInstruction, docxCharacterScaleValue, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, paragraphAlignment, xmlNamespaceUri, paragraphSpacingOptions, docxCharacterPositionValue, documentIndexEntryInstruction, docxEmphasisMarkRunOptions, hasNonWhitespaceXmlText, patchDocxExplicitZeroCharacterSpacing, cloneXmlElement, cssColorToHex, xmlDeclaredPrefix, assertXmlRoot, DOCX_WORDPROCESSING_NAMESPACES, paragraphIndent, domDirection, xmlAttributeNamespace, paragraphBidirectional, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, mergeDocxIgnorableExtensions, DocxParagraphDefaultCollapsedPatchCollector, dataBoolean, patchDocxParagraphDefaultCollapsed, patchDocxExplicitZeroKerningThresholds, parseDocxColorSchemeMappingElement, paragraphPaginationOptions, DOCX_COLOR_SCHEME_MAPPING_ATTRIBUTES, documentProofingLanguageDocxOptions, xmlAttributeLocalName, cssFontSize, paragraphDirectionOptions, cssFontFamily, docxCharacterSpacingValue } from "./0~4042.js";
@@ -2093,7 +2093,7 @@ function imageDimensions(blob) {
 function docxDocumentFieldRun(element, docx) {
     const instruction = element.dataset.fieldInstruction?.trim() ?? '';
     const display = element.dataset.fieldDisplay?.trim() || element.textContent?.trim() || '';
-    if (!docxDocumentFieldKind(instruction)) return new docx.TextRun(display);
+    if (!docxDocumentFieldKind(instruction) || !supportedDocxDocumentFieldInstruction(instruction)) return new docx.TextRun(display);
     return new docx.SimpleField(instruction, display);
 }
 const work_docx_run_shading_export_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
@@ -4906,6 +4906,84 @@ function removeWordAttribute(element, localName) {
 function work_docx_table_of_contents_export_wordQualifiedName(root, localName) {
     return `${xmlNamespacePrefix(root, work_docx_table_of_contents_export_WORD_NAMESPACE) ?? 'w'}:${localName}`;
 }
+const DOC_PROPERTIES_ID_MAX = 0xffffffff;
+const TEXT_BOX_ID_MARKER_PATTERN = /__A3S_TEXT_BOX_ID_\d+__/g;
+class DocxTextBoxIdentityPatchCollector {
+    patches = [];
+    nextMarker = 1;
+    register(properties) {
+        const marker = `__A3S_TEXT_BOX_ID_${this.nextMarker}__`;
+        this.nextMarker += 1;
+        this.patches.push({
+            marker,
+            preferredId: properties.docPropertiesId
+        });
+        return {
+            marker,
+            docPropertiesId: properties.docPropertiesId
+        };
+    }
+}
+async function patchDocxTextBoxIdentities(buffer, patches) {
+    if (!patches.length) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const byMarker = new Map(patches.map((patch)=>[
+            patch.marker,
+            patch
+        ]));
+    const entries = Object.values(archive.files).filter((entry)=>!entry.dir && /^word\/(?:document|header\d+|footer\d+|footnotes|endnotes|comments)\.xml$/.test(entry.name));
+    const documents = await Promise.all(entries.map(async (entry)=>({
+            entry,
+            document: parseXml(await entry.async('text'), entry.name)
+        })));
+    const properties = documents.flatMap(({ document })=>descendants(document, 'docPr'));
+    const marked = properties.map((property)=>({
+            property,
+            patch: textBoxIdentityPatch(property, byMarker)
+        })).filter((value)=>Boolean(value.patch));
+    if (!marked.length) return buffer;
+    const used = new Set();
+    for (const property of properties){
+        if (marked.some((value)=>value.property === property)) continue;
+        const id = parseDocPropertiesId(property.getAttribute('id'));
+        if (null !== id) used.add(id);
+    }
+    let nextId = 1;
+    const changedDocuments = new Set();
+    for (const { property, patch } of marked){
+        removeTextBoxIdentityMarker(property, patch.marker);
+        const preferred = null === patch.preferredId || used.has(patch.preferredId) ? nextAvailableDocPropertiesId(used, nextId) : patch.preferredId;
+        used.add(preferred);
+        nextId = preferred + 1;
+        property.setAttribute('id', String(preferred));
+        changedDocuments.add(property.ownerDocument);
+    }
+    for (const { entry, document } of documents)if (changedDocuments.has(document)) archive.file(entry.name, new XMLSerializer().serializeToString(document));
+    return archive.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function textBoxIdentityPatch(property, byMarker) {
+    for (const attribute of Array.from(property.attributes)){
+        const marker = attribute.value.match(TEXT_BOX_ID_MARKER_PATTERN)?.find((value)=>byMarker.has(value));
+        if (marker) return byMarker.get(marker) ?? null;
+    }
+    return null;
+}
+function removeTextBoxIdentityMarker(property, marker) {
+    for (const attribute of Array.from(property.attributes))if (attribute.value.includes(marker)) attribute.value = attribute.value.replace(marker, '').replace(/\s{2,}/g, ' ').trim();
+}
+function parseDocPropertiesId(value) {
+    if (null === value || !/^\d+$/.test(value)) return null;
+    const id = Number(value);
+    return Number.isSafeInteger(id) && id <= DOC_PROPERTIES_ID_MAX ? id : null;
+}
+function nextAvailableDocPropertiesId(used, start) {
+    let candidate = Math.max(1, start);
+    while(candidate <= DOC_PROPERTIES_ID_MAX && used.has(candidate))candidate += 1;
+    if (candidate > DOC_PROPERTIES_ID_MAX) throw new Error('DOCX drawing-property IDs are exhausted.');
+    return candidate;
+}
 const work_docx_table_sizing_export_TWIPS_PER_PIXEL = 15;
 function documentTableSizingDocxOptions(table, docx) {
     const geometry = documentTableGeometryFromElement(table);
@@ -8688,6 +8766,7 @@ async function createDocxBlob(content, sourcePackage) {
         imageLayerPatches: new DocxImageLayerPatchCollector(),
         imageWrapPatches: new DocxImageWrapPatchCollector(),
         imageTransformPatches: new DocxImageTransformPatchCollector(),
+        textBoxIdentityPatches: new DocxTextBoxIdentityPatchCollector(),
         paragraphBorderPatches: new DocxParagraphBorderPatchCollector(JSON.stringify(normalizedContent)),
         paragraphDefaultCollapsedPatches: new DocxParagraphDefaultCollapsedPatchCollector(),
         paragraphIdentityPatches: new DocxParagraphIdentityPatchCollector(JSON.stringify(normalizedContent)),
@@ -8777,7 +8856,8 @@ async function createDocxBlob(content, sourcePackage) {
     const imageLayerPatched = await patchDocxImageLayers(imageWrapPatched, noteContext.imageLayerPatches.patches);
     const imageTransformPatched = await patchDocxImageTransforms(imageLayerPatched, noteContext.imageTransformPatches.patches);
     const imageIdentityPatched = await patchDocxImageIdentities(imageTransformPatched, noteContext.imageIdentityPatches.patches);
-    const bookmarkPatched = await patchDocxBookmarks(imageIdentityPatched, noteContext.bookmarkPatches.patches);
+    const textBoxIdentityPatched = await patchDocxTextBoxIdentities(imageIdentityPatched, noteContext.textBoxIdentityPatches.patches);
+    const bookmarkPatched = await patchDocxBookmarks(textBoxIdentityPatched, noteContext.bookmarkPatches.patches);
     const paragraphDefaultCollapsedPatched = await patchDocxParagraphDefaultCollapsed(bookmarkPatched, noteContext.paragraphDefaultCollapsedPatches.patches);
     const paragraphIdentityPatched = await patchDocxParagraphIdentities(paragraphDefaultCollapsedPatched, noteContext.paragraphIdentityPatches.patches);
     const tableOfContentsPatched = await patchDocxTableOfContents(paragraphIdentityPatched, noteContext.tableOfContentsPatches.patches);
@@ -8977,6 +9057,13 @@ async function blockToFileChildren(element, docx, noteContext) {
     if (element.hasAttribute('data-document-caption')) return [
         docxCaptionParagraph(element, await paragraphRuns(element, docx, noteContext), docx, paragraphBidirectional(element))
     ];
+    if (element.hasAttribute('data-document-text-box')) return [
+        new docx.Paragraph({
+            children: [
+                await textBoxToDocx(element, docx, noteContext)
+            ]
+        })
+    ];
     if ('table' === tag) return [
         await tableToDocx(element, docx, noteContext)
     ];
@@ -9007,6 +9094,114 @@ async function blockToFileChildren(element, docx, noteContext) {
         })
     ];
 }
+async function textBoxToDocx(element, docx, noteContext) {
+    const properties = documentTextBoxPropertiesFromElement(element);
+    const identity = noteContext.textBoxIdentityPatches.register(properties);
+    const runs = await paragraphRuns(element, docx, noteContext);
+    const paragraph = new docx.Paragraph({
+        children: runs.length ? runs : [
+            new docx.TextRun('')
+        ],
+        alignment: paragraphAlignment(element, docx),
+        ...paragraphDirectionOptions(element)
+    });
+    const shapeOptions = {
+        type: 'wps',
+        transformation: {
+            width: millimetersToPixels(properties.width),
+            height: millimetersToPixels(properties.height)
+        },
+        children: [
+            paragraph
+        ],
+        nonVisualProperties: {
+            txBox: '1'
+        },
+        bodyProperties: {
+            verticalAnchor: textBoxVerticalAnchor(properties, docx),
+            margins: {
+                top: work_docx_export_millimetersToEmus(properties.padding),
+                right: work_docx_export_millimetersToEmus(properties.padding),
+                bottom: work_docx_export_millimetersToEmus(properties.padding),
+                left: work_docx_export_millimetersToEmus(properties.padding)
+            },
+            noAutoFit: true
+        },
+        altText: {
+            name: `A3S Text Box ${properties.id || 'text-box'} ${identity.marker}`,
+            description: 'A3S editable text box',
+            title: 'Text box',
+            ...null === identity.docPropertiesId ? {} : {
+                id: String(identity.docPropertiesId)
+            }
+        },
+        ...'transparent' === properties.fill ? {} : {
+            solidFill: {
+                type: 'rgb',
+                value: properties.fill.slice(1)
+            }
+        },
+        outline: 'none' === properties.borderColor || properties.borderWidth <= 0 ? {
+            type: 'noFill'
+        } : {
+            type: 'solidFill',
+            solidFillType: 'rgb',
+            value: properties.borderColor.slice(1),
+            width: work_docx_export_millimetersToEmus(properties.borderWidth)
+        },
+        ...'floating' === properties.layout ? {
+            floating: textBoxFloatingOptions(properties, docx)
+        } : {}
+    };
+    return new docx.WpsShapeRun(shapeOptions);
+}
+function textBoxVerticalAnchor(properties, docx) {
+    if ('center' === properties.verticalAlign) return docx.VerticalAnchor.CENTER;
+    if ('bottom' === properties.verticalAlign) return docx.VerticalAnchor.BOTTOM;
+    return docx.VerticalAnchor.TOP;
+}
+function textBoxFloatingOptions(properties, docx) {
+    return {
+        horizontalPosition: {
+            relative: textBoxHorizontalReference(properties, docx),
+            offset: work_docx_export_millimetersToEmus(properties.horizontalOffset ?? 0)
+        },
+        verticalPosition: {
+            relative: textBoxVerticalReference(properties, docx),
+            offset: work_docx_export_millimetersToEmus(properties.verticalOffset ?? 0)
+        },
+        allowOverlap: true,
+        behindDocument: false,
+        layoutInCell: true,
+        lockAnchor: false,
+        zIndex: 0,
+        margins: {
+            top: 0,
+            right: 0,
+            bottom: 0,
+            left: 0
+        },
+        wrap: {
+            type: docx.TextWrappingType.SQUARE
+        }
+    };
+}
+function textBoxHorizontalReference(properties, docx) {
+    if ('margin' === properties.horizontalReference) return docx.HorizontalPositionRelativeFrom.MARGIN;
+    if ('page' === properties.horizontalReference) return docx.HorizontalPositionRelativeFrom.PAGE;
+    return docx.HorizontalPositionRelativeFrom.COLUMN;
+}
+function textBoxVerticalReference(properties, docx) {
+    if ('margin' === properties.verticalReference) return docx.VerticalPositionRelativeFrom.MARGIN;
+    if ('page' === properties.verticalReference) return docx.VerticalPositionRelativeFrom.PAGE;
+    return docx.VerticalPositionRelativeFrom.PARAGRAPH;
+}
+function millimetersToPixels(value) {
+    return 96 * value / 25.4;
+}
+function work_docx_export_millimetersToEmus(value) {
+    return Math.round(36000 * value);
+}
 function paragraphHeadingLevel(tag, docx) {
     if ('h1' === tag) return docx.HeadingLevel.HEADING_1;
     if ('h2' === tag) return docx.HeadingLevel.HEADING_2;

package/dist/0~work-docx-import.js

@@ -1,7 +1,7 @@
 import jszip from "jszip";
 import { documentRunBorderDomAttributes, contentTypeForPart, bytesToDataUrl, OoxmlPackage, normalizeDocumentIndexesHtml, firstDescendant, normalizeDocumentParagraphId, applyDocumentParagraphIdentityToElement, descendants, documentHighlightDomAttributes, attribute as work_ooxml_package_attribute, documentHighlightFromDocxValue, serializeDocxThemeReference, normalizeDocumentTableOfContentsHtml, directChildren, documentParagraphShadingDomAttributes, documentProofingDomAttributes, documentParagraphBordersDomAttributes, directChild, documentScriptFontSegments, normalizeDocumentParagraphIdentity, documentRunShadingDomAttributes } from "./6968.js";
-import { normalizeDocumentBookmarkName, renderDocumentTableCellMarginOverrides, applyDocumentImageIdentityToElement, documentCharacterPositionDomAttributes, createDocumentImageIdentityRegistry, normalizeDocumentColumns, documentStrikeDomAttributes, normalizeDocumentImageWrapContour, DOCUMENT_TABLE_ROW_ID_ATTRIBUTE, normalizeDocumentBookmarksHtml, applyDocumentTableRowIdentityToElement, normalizeDocumentCaptionsHtml, documentCharacterSpacingDomAttributes, normalizeDocumentImageAlignment, applyDocumentImageLayerToElement, normalizeDocumentNotesHtml, normalizeDocumentBookmarkReferencesHtml, documentCitationTagsFromInstruction, applyDocumentImageWrapContourToElement, documentUnderlineDomAttributes, documentHiddenTextDomAttributes, normalizeDocumentPageChrome, normalizeDocumentImageLayoutOptions, applyDocumentImageCropToElement, documentPageMarginsForLayout, applyDocumentPageGeometry, createDocumentNoteElement, normalizeDocumentImageLayer, DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE, documentBookmarkReferenceInstruction, applyDocumentImageTransformToElement, documentInitialSectionLayout, normalizeDocumentFieldsHtml, documentCaptionLabel, documentTableBordersFromElement, isContourImageLayout, normalizeDocumentCitationsHtml, normalizeDocumentImageIdentity, normalizeDocumentImageWrapSide, documentKerningDomAttributes, docxDocumentFieldKind, renderDocumentTableBorders, docxBookmarkReferenceTarget, normalizeDocumentImagePosition, wrapsBesideImage, documentPageChromeLegacyFields, documentCharacterScaleDomAttributes, DEFAULT_DOCUMENT_TABLE_GEOMETRY, documentSectionDomAttributes, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, documentPageMarginBody, documentLegacyTextEffectsDomAttributes, normalizeDocumentTableRowIdentity, normalizeDocumentBookmarkNativeId, documentOpenTypeDomAttributes, uniqueDocumentImageIdentity, applyDocumentTableGeometryToElement, normalizeDocumentImageCrop, documentContentLayoutProperties, documentEmphasisMarkDomAttributes } from "./4174.js";
-import { hasImportedDocxIndexMarkers, markDocxRunFormattingIntoState, applyImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphIndentMarkers, resolveDocxParagraphBordersForParagraph, applyImportedDocxNumberingChangeMarkers, applyImportedDocxParagraphShadingMarkers, markDocxParagraphSpacing, docxCaptionBookmark, docxFieldResultText, createDocxParagraphStyleResolver, docxTableCellStyleLayers, createImportedDocxRunFormattingMarkerState, parseDocxPaperSource, resolveDocxLegacyTextEffects, markDocxTablesOfContents, hasImportedDocxParagraphSpacingMarkers, applyImportedDocxIndexMarkers, applyImportedDocxTableOfContentsMarkers, markDocxIndexes, parseDocxPageMargins, docxTablePropertySources, parseDirectDocxParagraphShading, markDocxParagraphIndents, markDocxPackageEquations, resolveDocxRunBorder, parseDocxPageGeometry, docxCaptionReferenceTarget, applyImportedDocxEquationMarkers, hasImportedDocxParagraphPaginationMarkers, createDocxTableStyleResolver, hasImportedDocxParagraphShadingMarkers, isDocxEquationLikeRoot, importedDocxStrike, docxTableRunPropertySources, hasImportedDocxNumberingChangeMarkers, inspectDocxPageMarginSettings, hasImportedDocxRunFormattingMarkers, hasImportedDocxTableOfContentsMarkers, applyImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxParagraphTabStopMarkers, resolveDocxRunShading, docxCaptionSequenceKind, applyImportedDocxRunFormattingMarkers, markDocxParagraphAlignments, markDocxParagraphDirections, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphFormattingChangeMarkers, resolveDocxHiddenText, docxEquationHtml, docxFieldOccurrences, hasImportedDocxParagraphAlignmentMarkers, markDocxParagraphTabStops, applyImportedDocxParagraphIndentMarkers, resolveDocxTableStyleResolver, applyImportedDocxParagraphDirectionMarkers, markDocxNumberingChanges, applyImportedDocxParagraphAlignmentMarkers, importedDocxUnderline, markDocxParagraphBorders, markDocxParagraphPagination, applyImportedDocxParagraphTabStopMarkers, applyImportedDocxParagraphPaginationMarkers, docxFieldOccurrenceIsInlineEditable, applyImportedDocxParagraphBorderMarkers, docxRunPropertySources, markDocxParagraphFormattingChanges, markDocxParagraphShading, parseDocxPageBorders } from "./0~2330.js";
+import { normalizeDocumentBookmarkName, renderDocumentTableCellMarginOverrides, applyDocumentImageIdentityToElement, documentCharacterPositionDomAttributes, createDocumentImageIdentityRegistry, normalizeDocumentColumns, documentStrikeDomAttributes, normalizeDocumentImageWrapContour, DOCUMENT_TABLE_ROW_ID_ATTRIBUTE, normalizeDocumentBookmarksHtml, applyDocumentTableRowIdentityToElement, normalizeDocumentCaptionsHtml, documentCharacterSpacingDomAttributes, normalizeDocumentImageAlignment, applyDocumentImageLayerToElement, normalizeDocumentNotesHtml, normalizeDocumentBookmarkReferencesHtml, documentCitationTagsFromInstruction, applyDocumentImageWrapContourToElement, documentUnderlineDomAttributes, documentHiddenTextDomAttributes, normalizeDocumentPageChrome, normalizeDocumentImageLayoutOptions, applyDocumentImageCropToElement, documentPageMarginsForLayout, applyDocumentPageGeometry, createDocumentNoteElement, normalizeDocumentImageLayer, DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE, documentBookmarkReferenceInstruction, applyDocumentImageTransformToElement, documentInitialSectionLayout, normalizeDocumentFieldsHtml, documentCaptionLabel, documentTableBordersFromElement, isContourImageLayout, normalizeDocumentCitationsHtml, normalizeDocumentImageIdentity, normalizeDocumentImageWrapSide, supportedDocxDocumentFieldInstruction, documentKerningDomAttributes, docxDocumentFieldKind, renderDocumentTableBorders, docxBookmarkReferenceTarget, normalizeDocumentImagePosition, wrapsBesideImage, documentPageChromeLegacyFields, documentCharacterScaleDomAttributes, DEFAULT_DOCUMENT_TABLE_GEOMETRY, documentSectionDomAttributes, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, documentPageMarginBody, documentLegacyTextEffectsDomAttributes, normalizeDocumentTableRowIdentity, normalizeDocumentBookmarkNativeId, documentOpenTypeDomAttributes, uniqueDocumentImageIdentity, applyDocumentTableGeometryToElement, normalizeDocumentImageCrop, documentContentLayoutProperties, documentEmphasisMarkDomAttributes, docxDocumentFieldTarget } from "./4174.js";
+import { hasImportedDocxIndexMarkers, markDocxRunFormattingIntoState, applyImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphIndentMarkers, resolveDocxParagraphBordersForParagraph, applyImportedDocxTextBoxMarkers, applyImportedDocxNumberingChangeMarkers, applyImportedDocxParagraphShadingMarkers, markDocxParagraphSpacing, docxCaptionBookmark, docxFieldResultText, markDocxTextBoxes, createDocxParagraphStyleResolver, docxTableCellStyleLayers, createImportedDocxRunFormattingMarkerState, parseDocxPaperSource, resolveDocxLegacyTextEffects, markDocxTablesOfContents, hasImportedDocxParagraphSpacingMarkers, applyImportedDocxIndexMarkers, applyImportedDocxTableOfContentsMarkers, markDocxIndexes, docxTablePropertySources, parseDirectDocxParagraphShading, markDocxPackageEquations, markDocxParagraphIndents, parseDocxPageMargins, resolveDocxRunBorder, parseDocxPageGeometry, docxCaptionReferenceTarget, applyImportedDocxEquationMarkers, hasImportedDocxParagraphPaginationMarkers, createDocxTableStyleResolver, hasImportedDocxParagraphShadingMarkers, isDocxEquationLikeRoot, importedDocxStrike, docxTableRunPropertySources, hasImportedDocxNumberingChangeMarkers, inspectDocxPageMarginSettings, hasImportedDocxRunFormattingMarkers, hasImportedDocxTableOfContentsMarkers, applyImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxParagraphTabStopMarkers, resolveDocxRunShading, docxCaptionSequenceKind, applyImportedDocxRunFormattingMarkers, markDocxParagraphAlignments, markDocxParagraphDirections, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphFormattingChangeMarkers, resolveDocxHiddenText, docxEquationHtml, docxFieldOccurrences, hasImportedDocxParagraphAlignmentMarkers, markDocxParagraphTabStops, applyImportedDocxParagraphIndentMarkers, resolveDocxTableStyleResolver, hasImportedDocxTextBoxMarkers, markDocxNumberingChanges, markDocxParagraphPagination, importedDocxUnderline, markDocxParagraphBorders, applyImportedDocxParagraphDirectionMarkers, applyImportedDocxParagraphAlignmentMarkers, docxFieldOccurrenceIsInlineEditable, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphPaginationMarkers, applyImportedDocxParagraphTabStopMarkers, docxRunPropertySources, markDocxParagraphFormattingChanges, markDocxParagraphShading, parseDocxPageBorders } from "./0~2133.js";
 import { readDocxBibliography, resolveDocxProofing, XMLNS_NAMESPACE, docxCharacterScalePercentFromProperties, docxCharacterSpacingTwipsFromProperties, parseBoundedDocxInteger, resolveDocxOpenTypeFeatures, xmlAttributeLocalName, resolveDocxEmphasisMark, createDocxThemeResolver, docxCharacterPositionHalfPointsFromProperties, readDocxImageTransform, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxKerningThresholdHalfPoints, resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace } from "./0~4042.js";
 import { importDocxPageColor, importedDocumentNoteId } from "./0~4980.js";
 const WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
@@ -933,17 +933,34 @@ function work_docx_comment_import_compareDocumentOrder(left, right) {
 }
 const work_docx_field_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_field_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
-function markDocxBodyFields(document) {
+function markDocxBodyFields(document, bookmarks = []) {
+    const bookmarkTargets = bookmarks.length ? new Map(bookmarks.map((bookmark)=>[
+            bookmark.sourceName.trim().toLowerCase(),
+            {
+                id: bookmark.id,
+                name: bookmark.name
+            }
+        ])) : pairedBookmarkTargets(document);
     const fields = docxFieldOccurrences(document).flatMap((field, index)=>{
         const kind = docxDocumentFieldKind(field.instruction);
-        if (!kind || !docxFieldOccurrenceIsInlineEditable(field)) return [];
+        if (!kind || !supportedDocxDocumentFieldInstruction(field.instruction) || !docxFieldOccurrenceIsInlineEditable(field)) return [];
+        const targetName = docxDocumentFieldTarget(field.instruction) ?? void 0;
+        const target = targetName ? bookmarkTargets.get(targetName.toLowerCase()) : void 0;
+        if ('pageReference' === kind && !target) return [];
         const marker = {
             start: `__A3S_WORK_FIELD_START_${index + 1}__`,
             end: `__A3S_WORK_FIELD_END_${index + 1}__`,
             id: `docx-field-${index + 1}`,
             kind,
             instruction: field.instruction,
-            display: docxFieldResultText(field)
+            display: docxFieldResultText(field),
+            ...target ? {
+                targetId: target.id,
+                targetName: target.name
+            } : {},
+            ...'pageReference' === kind ? {
+                orphaned: !target
+            } : {}
         };
         work_docx_field_import_insertFieldBoundaryMarkers(document, field, marker.start, marker.end);
         return [
@@ -954,6 +971,22 @@ function markDocxBodyFields(document) {
         fields
     };
 }
+function pairedBookmarkTargets(document) {
+    const endIds = new Set(descendants(document, 'bookmarkEnd').map((element)=>work_ooxml_package_attribute(element, 'id')?.trim() ?? '').filter(Boolean));
+    return new Map(descendants(document, 'bookmarkStart').flatMap((element)=>{
+        const id = work_ooxml_package_attribute(element, 'id')?.trim() ?? '';
+        const name = work_ooxml_package_attribute(element, 'name')?.trim() ?? '';
+        return id && name && endIds.has(id) ? [
+            [
+                name.toLowerCase(),
+                {
+                    id,
+                    name
+                }
+            ]
+        ] : [];
+    }));
+}
 function applyImportedDocxFieldMarkers(document, markers) {
     for (const field of markers.fields){
         const element = document.createElement('span');
@@ -961,6 +994,9 @@ function applyImportedDocxFieldMarkers(document, markers) {
         element.dataset.fieldId = field.id;
         element.dataset.fieldKind = field.kind;
         element.dataset.fieldInstruction = field.instruction;
+        if (field.targetId) element.dataset.fieldTargetId = field.targetId;
+        if (field.targetName) element.dataset.fieldTargetName = field.targetName;
+        if (field.orphaned) element.dataset.fieldOrphaned = 'true';
         const convertedDisplay = work_docx_field_import_replaceMarkerRange(document.body, field.start, field.end, element);
         const display = field.display.trim() || convertedDisplay.trim();
         element.dataset.fieldDisplay = display;
@@ -2910,6 +2946,9 @@ async function prepareDocxImport(buffer, sourcePackage) {
         imageLayoutMarkers: {
             images: []
         },
+        textBoxMarkers: {
+            textBoxes: []
+        },
         paragraphIdentityMarkers: {
             paragraphs: []
         },
@@ -2964,6 +3003,7 @@ async function prepareDocxImport(buffer, sourcePackage) {
     const pageColor = importDocxPageColor(document);
     const tableOfContentsMarkers = markDocxTablesOfContents(document);
     const indexMarkers = markDocxIndexes(document);
+    const textBoxMarkers = markDocxTextBoxes(document);
     const paragraphIdentityMarkers = markDocxParagraphIdentities(document);
     const numbering = archive.has('word/numbering.xml') ? await archive.xml('word/numbering.xml') : null;
     const commentMarkers = await markDocxComments(document, archive);
@@ -2971,7 +3011,7 @@ async function prepareDocxImport(buffer, sourcePackage) {
     const captionMarkers = markDocxCaptionFields(document);
     const bookmarkMarkers = markDocxBookmarks(document);
     const citationMarkers = markDocxCitationFields(document);
-    const fieldMarkers = markDocxBodyFields(document);
+    const fieldMarkers = markDocxBodyFields(document, bookmarkMarkers.bookmarks);
     const listMarkers = markDocxLists(document, numbering);
     const numberingChangeMarkers = markDocxNumberingChanges(document);
     const imageLayoutMarkerState = createImportedDocxImageLayoutMarkerState();
@@ -3009,7 +3049,7 @@ async function prepareDocxImport(buffer, sourcePackage) {
     const trackChanges = Boolean(settings && firstDescendant(settings, 'trackRevisions')) || changeMarkers.changes.length > 0 || numberingChangeMarkers.groups.length > 0 || paragraphFormattingChangeMarkers.paragraphs.length > 0 || runFormattingMarkers.runs.some((run)=>Boolean(run.change));
     const sectionElements = effectiveSectionProperties(document);
     if (!sectionElements.length) return {
-        conversionBuffer: hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxBookmarkMarkers(bookmarkMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || hasImportedDocxTableOfContentsMarkers(tableOfContentsMarkers) || hasImportedDocxIndexMarkers(indexMarkers) || equationMarkers.changed || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxNumberingChangeMarkers(numberingChangeMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxParagraphIdentityMarkers(paragraphIdentityMarkers) || hasImportedDocxParagraphFormattingChangeMarkers(paragraphFormattingChangeMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphBorderMarkers(paragraphBorderMarkers) || hasImportedDocxParagraphShadingMarkers(paragraphShadingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document, equationMarkers.parts) : buffer,
+        conversionBuffer: hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxBookmarkMarkers(bookmarkMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || hasImportedDocxTableOfContentsMarkers(tableOfContentsMarkers) || hasImportedDocxIndexMarkers(indexMarkers) || equationMarkers.changed || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxNumberingChangeMarkers(numberingChangeMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxTextBoxMarkers(textBoxMarkers) || hasImportedDocxParagraphIdentityMarkers(paragraphIdentityMarkers) || hasImportedDocxParagraphFormattingChangeMarkers(paragraphFormattingChangeMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphBorderMarkers(paragraphBorderMarkers) || hasImportedDocxParagraphShadingMarkers(paragraphShadingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document, equationMarkers.parts) : buffer,
         sections: [
             {
                 id: 'document-section-1',
@@ -3029,6 +3069,7 @@ async function prepareDocxImport(buffer, sourcePackage) {
         listMarkers,
         numberingChangeMarkers,
         imageLayoutMarkers,
+        textBoxMarkers,
         paragraphIdentityMarkers,
         paragraphFormattingChangeMarkers,
         paragraphAlignmentMarkers,
@@ -3060,7 +3101,7 @@ async function prepareDocxImport(buffer, sourcePackage) {
     }
     if (sections.length > 1) addSectionMarkers(document, sectionElements);
     return {
-        conversionBuffer: sections.length > 1 || hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxBookmarkMarkers(bookmarkMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || hasImportedDocxTableOfContentsMarkers(tableOfContentsMarkers) || hasImportedDocxIndexMarkers(indexMarkers) || equationMarkers.changed || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxNumberingChangeMarkers(numberingChangeMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxParagraphIdentityMarkers(paragraphIdentityMarkers) || hasImportedDocxParagraphFormattingChangeMarkers(paragraphFormattingChangeMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphBorderMarkers(paragraphBorderMarkers) || hasImportedDocxParagraphShadingMarkers(paragraphShadingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document, equationMarkers.parts) : buffer,
+        conversionBuffer: sections.length > 1 || hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxBookmarkMarkers(bookmarkMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || hasImportedDocxTableOfContentsMarkers(tableOfContentsMarkers) || hasImportedDocxIndexMarkers(indexMarkers) || equationMarkers.changed || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxNumberingChangeMarkers(numberingChangeMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxTextBoxMarkers(textBoxMarkers) || hasImportedDocxParagraphIdentityMarkers(paragraphIdentityMarkers) || hasImportedDocxParagraphFormattingChangeMarkers(paragraphFormattingChangeMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphBorderMarkers(paragraphBorderMarkers) || hasImportedDocxParagraphShadingMarkers(paragraphShadingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document, equationMarkers.parts) : buffer,
         sections,
         pageColor,
         captionMarkers,
@@ -3075,6 +3116,7 @@ async function prepareDocxImport(buffer, sourcePackage) {
         listMarkers,
         numberingChangeMarkers,
         imageLayoutMarkers,
+        textBoxMarkers,
         paragraphIdentityMarkers,
         paragraphFormattingChangeMarkers,
         paragraphAlignmentMarkers,
@@ -3155,6 +3197,8 @@ function applyDocxSectionsToHtml(html, sections, captionMarkers = {
     rows: []
 }, tableSizingMarkers = {
     tables: []
+}, textBoxMarkers = {
+    textBoxes: []
 }) {
     const document = new DOMParser().parseFromString(html, 'text/html');
     applyImportedDocxRunFormattingMarkers(document, runFormattingMarkers);
@@ -3181,6 +3225,7 @@ function applyDocxSectionsToHtml(html, sections, captionMarkers = {
     applyImportedDocxChangeMarkers(document, changeMarkers);
     applyImportedDocxCommentMarkers(document, commentMarkers);
     applyImportedDocxParagraphIdentityMarkers(document, paragraphIdentityMarkers);
+    applyImportedDocxTextBoxMarkers(document, textBoxMarkers);
     applyImportedDocxTableOfContentsMarkers(document, tableOfContentsMarkers);
     applyImportedDocxIndexMarkers(document, indexMarkers);
     const notes = extractMammothDocumentNotes(document);

package/dist/0~work-office-diagnostics.js

@@ -1,7 +1,7 @@
 import { __webpack_require__ } from "./0~rslib-runtime.js";
 import { contentTypeForPart, directChildren, OoxmlPackage, parseXml, firstDescendant, isDocumentParagraphArtBorderStyle, descendants, directChild, xmlContainsAnyElement, attribute, documentRunBorderIsVisible } from "./6968.js";
-import { normalizeDocumentBookmarkName, docxBookmarkReferenceTarget, normalizeDocumentBookmarkNativeId, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, supportedDocxBookmarkReferenceInstruction, documentCitationTagsFromInstruction, docxDocumentFieldKind } from "./4174.js";
-import { markDocxParagraphShading, inspectDocxPageSize, isSupportedDocxNumberingChange, docxCaptionBookmark, hasInvalidDocxFieldStructure, inspectDocxLegacyTextEffects, inspectDocxPageMargins, inspectDocxPaperSource, createDocxParagraphStyleResolver, supportedDocxTableOfContentsField, docxFieldOccurrences, supportedDocxIndexEntryField, createDocxTableStyleResolver, inspectDocxEquation, inspectDocxPageMarginSettings, inspectDocxRunBorder, inspectDocxRunFonts, inspectDocxRunShading, markDocxParagraphBorders, isSupportedDocxParagraphFormattingChange, docxFieldOccurrenceIsInlineEditable, supportedDocxIndexField, docxCaptionSequenceKind, inspectDocxHiddenText, inspectDocxPageBorders, isSupportedDocxRunFormattingChange, docxFieldInstructions, isSupportedDocxEquationPlacement } from "./0~2330.js";
+import { normalizeDocumentBookmarkName, docxBookmarkReferenceTarget, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, normalizeDocumentBookmarkNativeId, supportedDocxDocumentFieldInstruction, supportedDocxBookmarkReferenceInstruction, documentCitationTagsFromInstruction, docxDocumentFieldKind, docxDocumentFieldTarget } from "./4174.js";
+import { isSupportedDocxEquationPlacement, inspectDocxPageSize, hasInvalidDocxFieldStructure, createDocxTableStyleResolver, inspectDocxRunBorder, inspectDocxEquation, inspectDocxPageMarginSettings, inspectDocxRunShading, supportedDocxIndexField, docxCaptionSequenceKind, inspectDocxPageBorders, docxCaptionBookmark, inspectDocxLegacyTextEffects, inspectDocxPageMargins, inspectDocxPaperSource, createDocxParagraphStyleResolver, inspectDocxRunFonts, supportedDocxTableOfContentsField, docxFieldOccurrences, supportedDocxIndexEntryField, inspectDocxTextBoxes, markDocxParagraphBorders, isSupportedDocxParagraphFormattingChange, docxFieldOccurrenceIsInlineEditable, inspectDocxHiddenText, isSupportedDocxRunFormattingChange, isSupportedDocxNumberingChange, markDocxParagraphShading, docxFieldInstructions } from "./0~2133.js";
 import { normalizeDocumentHref } from "./0~work-document-links.js";
 import { xmlAttributeLocalName, resolveDocxOpenTypeFeatures, inspectDocxProofingLanguages, readDocxBibliography, inspectDocxEmphasisMark, createDocxThemeResolver, DOCX_WORD_2010_NAMESPACE, inspectDocxNoProof, parseDocxParagraphDefaultCollapsed, readDocxImageTransform, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace, inspectDocxKerningThresholdHalfPoints } from "./0~4042.js";
 import { updateSpreadsheetWorksheetCompatibilitySummary, inspectXlsxPivotTables, isSupportedXlsxChartLegend, isSupportedXlsxChartPlotLayout, xlsxChartNodeUsesStackedGrouping, isSupportedXlsxChartSeriesFormatting, readXlsxFormulaFeaturesFromPackage, inspectXlsxHeaderFooterText, emptySpreadsheetWorksheetCompatibilitySummary, isSupportedXlsxWorksheetImageContentType, MAX_XLSX_WORKSHEET_IMAGE_BYTES, xlsxChartSeriesFormattingShapeProperties, diagnoseXlsxProtection, isEditableXlsxPaperSizeCode, isSupportedXlsxCombinationChartNodes } from "./4166.js";
@@ -117,13 +117,15 @@ function diagnoseDocxCaptions(document) {
     };
     const isSupportedBlockField = (field)=>isTableOfContentsField(field) || isIndexField(field);
     const sequences = fields.filter((field)=>docxCaptionSequenceKind(field.instruction));
-    const bodyFields = fields.filter((field)=>'orphan' !== field.syntax && Boolean(docxDocumentFieldKind(field.instruction)));
-    const editableBodyFields = bodyFields.filter(docxFieldOccurrenceIsInlineEditable);
-    const hasUnsupportedFieldStructure = hasInvalidDocxFieldStructure(document, isSupportedBlockField) || bodyFields.some((field)=>!docxFieldOccurrenceIsInlineEditable(field));
     const bookmarkNames = new Set([
         ...captionBookmarkNames(sequences),
         ...pairedBookmarkNames(document)
     ]);
+    const bodyFields = fields.filter((field)=>'orphan' !== field.syntax && Boolean(docxDocumentFieldKind(field.instruction)));
+    const supportedBodyFields = bodyFields.filter((field)=>supportedBodyField(field, bookmarkNames));
+    const unsupportedBodyFields = bodyFields.filter((field)=>!supportedBodyField(field, bookmarkNames));
+    const editableBodyFields = supportedBodyFields.filter(docxFieldOccurrenceIsInlineEditable);
+    const hasUnsupportedFieldStructure = hasInvalidDocxFieldStructure(document, isSupportedBlockField) || bodyFields.some((field)=>!docxFieldOccurrenceIsInlineEditable(field));
     return {
         issues: [
             ...sequences.length ? [
@@ -138,10 +140,18 @@ function diagnoseDocxCaptions(document) {
                 {
                     code: 'docx.fields.body',
                     feature: 'Body fields',
-                    message: 'PAGE, NUMPAGES, SECTION, SECTIONPAGES, DATE, and TIME fields remain live, editable body fields and update in preview, PDF, and native DOCX output.',
+                    message: 'PAGE, NUMPAGES, SECTION, SECTIONPAGES, NUMWORDS, NUMCHARS, DATE, TIME, and bookmark-backed PAGEREF fields remain live, editable body fields and update in preview, PDF, and native DOCX output.',
                     severity: 'info'
                 }
             ] : [],
+            ...unsupportedBodyFields.length ? [
+                {
+                    code: 'docx.fields.instructions',
+                    feature: 'Field instructions',
+                    message: 'Unsupported field switches or PAGEREF targets remain at their cached displayed value; only the bounded common instruction subset is made editable.',
+                    severity: 'warning'
+                }
+            ] : [],
             ...tableOfContentsFields.length ? [
                 {
                     code: 'docx.tableOfContents',
@@ -183,11 +193,16 @@ function captionBookmarkNames(fields) {
 }
 function isSupportedCaptionField(instruction, bookmarkNames) {
     if (documentCitationTagsFromInstruction(instruction).length || /^\s*BIBLIOGRAPHY\b/i.test(instruction)) return true;
-    if (docxDocumentFieldKind(instruction)) return true;
+    if (docxDocumentFieldKind(instruction)) return supportedDocxDocumentFieldInstruction(instruction) && ('pageReference' !== docxDocumentFieldKind(instruction) || Boolean(docxDocumentFieldTarget(instruction) && bookmarkNames.has(docxDocumentFieldTarget(instruction)?.toLowerCase() ?? '')));
     if (docxCaptionSequenceKind(instruction)) return true;
     const target = docxBookmarkReferenceTarget(instruction);
     return Boolean(target && bookmarkNames.has(target.toLowerCase()));
 }
+function supportedBodyField(field, bookmarkNames) {
+    if (!supportedDocxDocumentFieldInstruction(field.instruction)) return false;
+    const kind = docxDocumentFieldKind(field.instruction);
+    return 'pageReference' !== kind || Boolean(docxDocumentFieldTarget(field.instruction) && bookmarkNames.has(docxDocumentFieldTarget(field.instruction)?.toLowerCase() ?? ''));
+}
 function pairedBookmarkNames(document) {
     const endIds = new Set(descendants(document, 'bookmarkEnd').map((bookmark)=>attribute(bookmark, 'id')?.trim() ?? ''));
     return new Set(descendants(document, 'bookmarkStart').flatMap((bookmark)=>{
@@ -2190,8 +2205,13 @@ async function analyzeDocxCompatibility(file, messages, sourcePackage) {
             issues.push(...await diagnoseDocxCitations(archive, document));
             const captionDiagnostics = diagnoseDocxCaptions(document);
             issues.push(...captionDiagnostics.issues);
+            const textBoxInspection = inspectDocxTextBoxes(document);
+            if (textBoxInspection.supported) issues.push(work_office_diagnostics_issue('docx.text-boxes', 'Text boxes', `${textBoxInspection.supported} isolated WPS text box(es) remain editable with native DrawingML geometry, inline or floating layout, safe page-relative offsets, fill, outline, padding, and vertical alignment. Mixed paragraphs are intentionally kept on the normal DOCX compatibility path.`, 'info'));
+            if (textBoxInspection.unsupported) issues.push(work_office_diagnostics_issue('docx.text-boxes.unsupported', 'Text boxes', `${textBoxInspection.unsupported} WPS text box(es) mix a drawing with other paragraph content or have unsupported shape content. Only isolated text-box paragraphs are converted to editable text boxes; the rest may normalize during browser conversion.`));
             if (descendants(document, 'tbl').length) issues.push(work_office_diagnostics_issue('docx.tables', 'Tables', 'Table rows, non-splitting rows, repeated headers, cell shading, vertical alignment, per-edge borders, and paragraph-boundary row continuation remain editable. Native row identities survive body and page-chrome HTML; uniquely matched passive extensions on stable table, row, and cell scopes and their property nodes are retained, while duplicate, cross-kind, relationship-bound, or semantic branches fail closed. Layout algorithm, preferred auto, percentage, or pixel width, alignment, indent, percentage or pixel column widths, table-level cell margins, and cell-level margin overrides are preserved independently across edit, preview, and DOCX export. Percentage column preferences use pixel grid widths as responsive browser fallbacks and remain coherent through merged cells. Nested tables retain independent edit and DOCX geometry, and tall outer rows can paginate at nested-row boundaries. Row-spanning cells continue through every covered physical row with in-cell page breaks and contiguous content ranges; combined row and column spans retain native DOCX merge semantics. Common inherited Word table styles apply whole-table, banded row or column, first or last row or column, corner-cell, border, fill, text-emphasis, paragraph alignment, direction, indents, spacing, line, pagination, and tab-stop rules before direct table, cell, paragraph, and run formatting. Theme tint and shade values resolve to stable RGB for edit and preview, while untouched run colors, run shading, cell fills, and per-edge borders retain their semantic theme references on export; explicit color edits use direct RGB. Less-common conditional paragraph properties may be normalized.'));
-            if (descendants(document, 'drawing').length || descendants(document, 'pict').length) {
+            const drawingCount = descendants(document, 'drawing').length;
+            const textBoxDrawingCount = textBoxInspection.supported + textBoxInspection.unsupported;
+            if (drawingCount > textBoxDrawingCount || descendants(document, 'pict').length) {
                 const unsupportedImageTransforms = docxUnsupportedImageTransformCount(document);
                 issues.push(work_office_diagnostics_issue('docx.images', 'Images', 'Inline images and supported square, tight, through, top-and-bottom, or no-wrap free-floating images remain embedded with editable size, alternative text, alignment, wrap side and distance where applicable, signed horizontal or vertical offsets relative to the column, paragraph, margin, or page, four-edge percentage cropping, 90-degree rotation, horizontal or vertical reflection, and drawing-layer options. Aligned and precise DOCX anchors retain their distinct position semantics; inline and floating crop geometry round-trips as DrawingML source rectangles; tight or through anchors retain their ordered wrap polygons; no-wrap anchors remain outside the body text flow and use behind-text placement to choose their side of the text; and supported floating images preserve relative Z-order, overlap and cell-layout policy, and anchor locking. Inline and floating pictures retain unique drawing-property and anchor IDs together with their edit IDs. Copies receive independent identities while move, delete, undo, and relationship regeneration retain the original object identity. Arbitrary-angle or malformed picture transforms and unsupported drawing types may be normalized.'));
                 if (unsupportedImageTransforms) issues.push(work_office_diagnostics_issue('docx.images.transform', 'Image transforms', `${unsupportedImageTransforms} picture transform(s) use an arbitrary angle or malformed rotation/reflection value. Work imports the editable 90-degree/reflection subset and normalizes the unsupported transform instead of exposing an inexact control.`));