@a3s-lab/office 0.48.1 → 0.49.0

package/COLLABORATION_ROADMAP.md

@@ -110,8 +110,8 @@ Redis/NATS fan-out plus a distributed writer/lock policy.
 
 Status: browser collaboration foundation, participant roster, remote
 selection/caret projection, participant navigation, durable review-only
-comment and suggestion modes, character- and paragraph-formatting revisions,
-immutable decision audit, and native text/options/bounded structural
+comment and suggestion modes, character-, paragraph-formatting, numbering, and
+text-only move revisions, immutable decision audit, and native text/options/bounded structural
 paragraph/comment/suggestion mutations implemented; rich native mutation
 parity remains pending.
 
@@ -182,6 +182,14 @@ parity remains pending.
   level, tab stops, borders, shading, and collapsed state without changing
   text. Supported strict or transitional DOCX `w:pPrChange` records use the
   same model and export natively.
+- Text-only move revisions create one paired `move` identity with `from` and
+  `to` roles. Matching strict/transitional `w:moveFrom`/`w:moveTo` records are
+  imported and exported natively; accept removes the source, reject removes the
+  destination, and one immutable decision audit record covers both sides. The
+  browser review binding and Yrs projection validate exact text, identity,
+  author, and date, while rich/range/relationship-bound or unpaired moves fail
+  closed as structural diagnostics. The closed native suggestion mutations
+  remain insertion/deletion-only.
 - Rust, CLI, MCP, and A3S Code expose `document-comment-create`,
   `document-comment-reply`, `document-comment-set-resolved`,
   `document-comment-delete`, `document-suggestion-create`, and
@@ -199,10 +207,10 @@ parity remains pending.
   content, structure, options, non-suggestion formatting, authorship, order,
   claims, anchors, foreign deletion, or foreign suggestion changes fail before
   the durable store changes.
-- Native Yrs validation admits only the bounded character- and
-  paragraph-formatting schemas, preserves them across restart and
-  duplicate/reordered delivery, exposes `formatting` and
-  `paragraph-formatting` in immutable decision projections, and makes
+- Native Yrs validation admits only the bounded character-, paragraph-formatting,
+  numbering, and move schemas, preserves them across restart and
+  duplicate/reordered delivery, exposes `formatting`, `paragraph-formatting`,
+  `numbering`, and `move` in immutable decision projections, and makes
   `suggest` updates retain existing formatting revisions byte-semantically.
   Formatting revisions are Document change kinds, not native
   insertion/deletion suggestion kinds; the current closed

package/README.md

@@ -309,6 +309,22 @@ and [CLI reference](./docs/latest/en/cli-reference.md).
 
 ## Current release
 
+Version `0.49.0` adds bounded native Writer move revisions and hardens the
+local PDF workflow:
+
+- Strict and transitional DOCX `w:moveFrom`/`w:moveTo` text pairs import as one
+  atomic `move` review item. Accept/reject resolves both source and destination
+  sides together, the immutable collaboration audit records the single final
+  decision, and export/reopen restores native move records with no private
+  marker leakage.
+- Rich, range-marker, relationship-bound, malformed, and unpaired moves remain
+  visible as diagnosed compatibility boundaries. The review pane labels moves
+  distinctly and navigates to the destination range without selecting the text
+  between the two sides.
+- The Playground now serves the pinned PDFium WebAssembly asset from a stable
+  origin-relative path, keeping direct PDF imports ready in desktop and compact
+  layouts.
+
 Version `0.48.1` fixes the Writer floating selection toolbar's split emphasis
 controls without changing the document model or public command contract:
 

package/dist/{0~3320.js → 0~5600.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 { hasUnsupportedContentControlSemanticChild, docxThemeFont, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, hasContentControlRelationshipReference, 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, xmlAttributeLocalName, isDocxWordElement, resolveDocxOpenTypeFeatures, resolveDocxEmphasisMark, docxCharacterScalePercentFromProperties, docxCharacterPositionHalfPointsFromProperties, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxKerningThresholdHalfPoints, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace, parseDocxTwipsMeasure } from "./0~3534.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;
@@ -159,9 +159,267 @@ 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 XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const MOVE_FROM = 'moveFrom';
+const MOVE_TO = 'moveTo';
+const MAX_MOVE_REVISIONS = 65536;
+const MAX_MOVE_TEXT_LENGTH = 1000000;
+const MAX_MOVE_DATE_LENGTH = 64;
+function markDocxTextChanges(document) {
+    const changes = [];
+    const movePairs = supportedMovePairs(document);
+    const moveByElement = new Map();
+    for (const pair of movePairs){
+        moveByElement.set(pair.from.element, pair);
+        moveByElement.set(pair.to.element, pair);
+    }
+    const processedMoves = new Set();
+    let markerIndex = 0;
+    const revisions = [
+        ...descendants(document, 'ins'),
+        ...descendants(document, 'del'),
+        ...movePairs.flatMap((pair)=>[
+                pair.from.element,
+                pair.to.element
+            ])
+    ].sort(compareDocumentOrder);
+    for (const revision of revisions){
+        if (!revision.parentNode || closestRevision(revision.parentElement)) continue;
+        const move = moveByElement.get(revision);
+        if (move) {
+            if (processedMoves.has(move)) continue;
+            processedMoves.add(move);
+            const id = uniqueChangeId(`docx-move-${move.from.id}`, changes);
+            const ordered = [
+                move.from,
+                move.to
+            ].sort((left, right)=>compareDocumentOrder(left.element, right.element));
+            for (const side of ordered){
+                markerIndex += 1;
+                if ('from' === side.role) convertDeletedText(document, side.element);
+                const marker = {
+                    id,
+                    kind: 'move',
+                    moveRole: side.role,
+                    author: side.author,
+                    date: side.date,
+                    start: `__A3S_WORK_CHANGE_START_${markerIndex}__`,
+                    end: `__A3S_WORK_CHANGE_END_${markerIndex}__`
+                };
+                unwrapRevision(document, side.element, marker.start, marker.end);
+                changes.push(marker);
+            }
+            continue;
+        }
+        const kind = 'del' === revision.localName ? 'deletion' : 'insertion';
+        if (!revisionText(revision, kind)) continue;
+        if ('deletion' === kind) convertDeletedText(document, revision);
+        markerIndex += 1;
+        const sourceId = work_ooxml_package_attribute(revision, 'id')?.trim() ?? '';
+        const id = uniqueChangeId(sourceId ? `docx-change-${sourceId}` : `docx-change-${markerIndex}`, changes);
+        const marker = {
+            id,
+            kind,
+            author: work_ooxml_package_attribute(revision, 'author')?.trim() || '未知审阅者',
+            date: normalizeDate(work_ooxml_package_attribute(revision, 'date')),
+            start: `__A3S_WORK_CHANGE_START_${markerIndex}__`,
+            end: `__A3S_WORK_CHANGE_END_${markerIndex}__`
+        };
+        unwrapRevision(document, revision, marker.start, marker.end);
+        changes.push(marker);
+    }
+    return {
+        changes
+    };
+}
+function applyImportedDocxChangeMarkers(document, markers) {
+    for (const marker of markers.changes){
+        const isMoveFrom = 'move' === marker.kind && 'from' === marker.moveRole;
+        const element = document.createElement('deletion' === marker.kind || isMoveFrom ? 'del' : 'ins');
+        element.dataset.documentChange = 'true';
+        element.dataset.changeKind = marker.kind;
+        if ('move' === marker.kind && marker.moveRole) element.dataset.changeMoveRole = marker.moveRole;
+        element.dataset.changeId = marker.id;
+        element.dataset.changeAuthor = marker.author;
+        element.dataset.changeDate = marker.date;
+        wrapMarkerRange(document.body, marker.start, marker.end, element);
+    }
+}
+function hasImportedDocxChangeMarkers(markers) {
+    return markers.changes.length > 0;
+}
+function revisionText(revision, kind) {
+    const names = 'deletion' === kind ? [
+        'delText',
+        't'
+    ] : [
+        't'
+    ];
+    return names.flatMap((name)=>descendants(revision, name)).map((element)=>element.textContent ?? '').join('');
+}
+function isSupportedDocxMoveChange(element) {
+    return null !== supportedMoveRevision(element);
+}
+function supportedDocxMovePairCount(document) {
+    return supportedMovePairs(document).length;
+}
+function supportedMovePairs(document) {
+    const from = descendants(document, MOVE_FROM).map((element)=>supportedMoveRevision(element, 'from')).filter((value)=>null !== value);
+    const to = descendants(document, MOVE_TO).map((element)=>supportedMoveRevision(element, 'to')).filter((value)=>null !== value);
+    const fromById = uniqueMoveById(from);
+    const toById = uniqueMoveById(to);
+    const pairs = [];
+    for (const [id, source] of fromById){
+        const destination = toById.get(id);
+        if (!(!destination || source.author !== destination.author || source.date !== destination.date || source.text !== destination.text || closestRevision(source.element.parentElement) || closestRevision(destination.element.parentElement))) pairs.push({
+            from: source,
+            to: destination
+        });
+    }
+    return pairs.slice(0, MAX_MOVE_REVISIONS);
+}
+function uniqueMoveById(revisions) {
+    const result = new Map();
+    const duplicates = new Set();
+    for (const revision of revisions)if (!duplicates.has(revision.id)) {
+        if (result.has(revision.id)) {
+            result.delete(revision.id);
+            duplicates.add(revision.id);
+            continue;
+        }
+        result.set(revision.id, revision);
+    }
+    return result;
+}
+function supportedMoveRevision(element, role) {
+    const resolvedRole = role ?? (element.localName === MOVE_FROM ? 'from' : element.localName === MOVE_TO ? 'to' : null);
+    if (!resolvedRole || !DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '') || element.localName !== MOVE_FROM && element.localName !== MOVE_TO || null !== element.parentElement && element.namespaceURI !== element.parentElement.namespaceURI) return null;
+    const id = wordAttribute(element, 'id')?.trim() ?? '';
+    const author = wordAttribute(element, 'author')?.trim() ?? '';
+    const rawDate = wordAttribute(element, 'date');
+    const text = moveRevisionText(element, resolvedRole);
+    if (!/^\d{1,10}$/.test(id) || !author || author.length > 255 || /[\u0000-\u001f\u007f]/.test(author) || null !== rawDate && rawDate.length > MAX_MOVE_DATE_LENGTH || null !== rawDate && !Number.isFinite(Date.parse(rawDate)) || !text || text.length > MAX_MOVE_TEXT_LENGTH || hasUnsupportedWordAttribute(element) || !moveChildrenAreTextOnly(element, resolvedRole)) return null;
+    return {
+        element,
+        role: resolvedRole,
+        id,
+        author,
+        date: normalizeDate(rawDate),
+        text
+    };
+}
+function moveRevisionText(revision, role) {
+    const names = 'from' === role ? [
+        'delText'
+    ] : [
+        't'
+    ];
+    return names.flatMap((name)=>descendants(revision, name)).map((element)=>element.textContent ?? '').join('');
+}
+function moveChildrenAreTextOnly(revision, role) {
+    const allowedText = 'from' === role ? new Set([
+        'delText'
+    ]) : new Set([
+        't'
+    ]);
+    const runs = Array.from(revision.children);
+    if (!runs.length || runs.some((run)=>'r' !== run.localName || !DOCX_WORDPROCESSING_NAMESPACES.has(run.namespaceURI ?? ''))) return false;
+    for (const run of runs){
+        const properties = Array.from(run.children).filter((child)=>'rPr' === child.localName);
+        if (properties.length > 1) return false;
+        for (const child of Array.from(run.children)){
+            if (!DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? '')) return false;
+            if ('rPr' === child.localName) {
+                if (Array.from(child.querySelectorAll('*')).some((descendant)=>!DOCX_WORDPROCESSING_NAMESPACES.has(descendant.namespaceURI ?? ''))) return false;
+                continue;
+            }
+            if (!allowedText.has(child.localName)) return false;
+            if (child.querySelector('*')) return false;
+        }
+        if (!Array.from(run.children).some((child)=>allowedText.has(child.localName))) return false;
+    }
+    return true;
+}
+function wordAttribute(element, localName) {
+    const namespace = element.namespaceURI;
+    if (!namespace) return null;
+    const matches = Array.from(element.attributes).filter((candidate)=>xmlAttributeLocalName(candidate) === localName && xmlAttributeNamespace(element, candidate) === namespace);
+    return 1 === matches.length ? matches[0]?.value ?? null : null;
+}
+function hasUnsupportedWordAttribute(element) {
+    const namespace = element.namespaceURI;
+    const supported = new Set([
+        'id',
+        'author',
+        'date'
+    ]);
+    return Array.from(element.attributes).some((candidate)=>xmlAttributeNamespace(element, candidate) === namespace && !supported.has(xmlAttributeLocalName(candidate)));
+}
+function convertDeletedText(document, revision) {
+    for (const deleted of descendants(revision, 'delText')){
+        const text = document.createElementNS(WORD_NAMESPACE, 'w:t');
+        const preserve = deleted.getAttributeNS(XML_NAMESPACE, 'space') ?? deleted.getAttribute('xml:space');
+        if (preserve) text.setAttributeNS(XML_NAMESPACE, 'xml:space', preserve);
+        text.textContent = deleted.textContent;
+        deleted.replaceWith(text);
+    }
+}
+function unwrapRevision(document, revision, start, end) {
+    const parent = revision.parentNode;
+    if (!parent) return;
+    parent.insertBefore(work_docx_change_import_markerRun(document, start), revision);
+    while(revision.firstChild)parent.insertBefore(revision.firstChild, revision);
+    parent.insertBefore(work_docx_change_import_markerRun(document, end), revision);
+    revision.remove();
+}
+function work_docx_change_import_markerRun(document, value) {
+    const run = document.createElementNS(WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = value;
+    run.append(text);
+    return run;
+}
+function wrapMarkerRange(root, start, end, wrapper) {
+    const html = root.innerHTML;
+    const startIndex = html.indexOf(start);
+    const endIndex = html.indexOf(end, startIndex + start.length);
+    if (startIndex < 0 || endIndex < 0) return false;
+    const closingTag = `</${wrapper.localName}>`;
+    const serializedWrapper = wrapper.outerHTML;
+    if (!serializedWrapper.endsWith(closingTag)) return false;
+    const openingTag = serializedWrapper.slice(0, -closingTag.length);
+    root.innerHTML = `${html.slice(0, startIndex)}${openingTag}${html.slice(startIndex + start.length, endIndex)}${closingTag}${html.slice(endIndex + end.length)}`;
+    return true;
+}
+function closestRevision(element) {
+    let current = element;
+    while(current){
+        if ('ins' === current.localName || 'del' === current.localName || current.localName === MOVE_FROM || current.localName === MOVE_TO) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function uniqueChangeId(base, changes) {
+    const ids = new Set(changes.map((change)=>change.id));
+    if (!ids.has(base)) return base;
+    let suffix = 2;
+    while(ids.has(`${base}-${suffix}`))suffix += 1;
+    return `${base}-${suffix}`;
+}
+function normalizeDate(value) {
+    if (!value) return '';
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? new Date(time).toISOString() : '';
+}
+function compareDocumentOrder(left, right) {
+    if (left === right) return 0;
+    return left.compareDocumentPosition(right) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+}
+const work_docx_content_control_import_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,
+    work_docx_content_control_import_WORD_NAMESPACE,
     STRICT_WORD_NAMESPACE
 ]);
 const MARKUP_COMPATIBILITY_NAMESPACE = 'http://schemas.openxmlformats.org/markup-compatibility/2006';
@@ -342,7 +600,7 @@ function readProperties(properties) {
     if (id && !validLeaf(id, new Set([
         'val'
     ]))) return null;
-    const nativeId = id ? parseNativeId(wordAttribute(id, 'val')) : null;
+    const nativeId = id ? parseNativeId(work_docx_content_control_import_wordAttribute(id, 'val')) : null;
     if (id && null === nativeId) return null;
     const alias = readStringProperty(groups.get('alias')?.[0]);
     const tag = readStringProperty(groups.get('tag')?.[0]);
@@ -351,7 +609,7 @@ function readProperties(properties) {
     if (lockElement && !validLeaf(lockElement, new Set([
         'val'
     ]))) return null;
-    const lockValue = lockElement ? wordAttribute(lockElement, 'val') : null;
+    const lockValue = lockElement ? work_docx_content_control_import_wordAttribute(lockElement, 'val') : null;
     const lock = lockValue ?? 'unlocked';
     if (!LOCK_VALUES.has(lock)) return null;
     const textElement = groups.get('text')?.[0];
@@ -361,7 +619,7 @@ function readProperties(properties) {
         'multiLine'
     ]))) return null;
     if (richTextElement && !validLeaf(richTextElement, new Set())) return null;
-    const multilineValue = textElement ? wordAttribute(textElement, 'multiLine') : null;
+    const multilineValue = textElement ? work_docx_content_control_import_wordAttribute(textElement, 'multiLine') : null;
     if (null !== multilineValue && ![
         '0',
         '1',
@@ -417,7 +675,7 @@ function replaceControlWithMarkers(document, control, start, end) {
     return true;
 }
 function work_docx_content_control_import_markerRun(document, context, value) {
-    const namespace = context.namespaceURI ?? WORD_NAMESPACE;
+    const namespace = context.namespaceURI ?? work_docx_content_control_import_WORD_NAMESPACE;
     const prefix = xmlNamespacePrefix(context, namespace) ?? 'w';
     const run = document.createElementNS(namespace, `${prefix}:r`);
     const text = document.createElementNS(namespace, `${prefix}:t`);
@@ -535,7 +793,7 @@ function isStructuralContentControl(control) {
             'docPartList'
         ].includes(child.localName));
 }
-function wordAttribute(element, localName) {
+function work_docx_content_control_import_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;
 }
@@ -548,7 +806,7 @@ function readStringProperty(element) {
     if (!validLeaf(element, new Set([
         'val'
     ]))) return null;
-    const value = wordAttribute(element, 'val');
+    const value = work_docx_content_control_import_wordAttribute(element, 'val');
     if (null === value || /[\u0000-\u001f\u007f]/u.test(value)) return null;
     return value.slice(0, 255);
 }
@@ -1495,7 +1753,7 @@ const WORD_COMBINE_BRACKETS = new Set([
     'angle',
     'curly'
 ]);
-const XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const work_docx_equation_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const MAX_IMPORTED_EQUATIONS = 4096;
 const MAX_MATH_DEPTH = 32;
 const MAX_MATH_NODES = 4096;
@@ -4374,7 +4632,7 @@ function hasMeaningfulDirectText(element) {
     return Array.from(element.childNodes).some((node)=>(node.nodeType === Node.TEXT_NODE || node.nodeType === Node.CDATA_SECTION_NODE) && Boolean(node.textContent?.trim()));
 }
 function safeMathTextAttributes(element) {
-    return meaningfulAttributes(element).every((attribute)=>xmlAttributeNamespace(element, attribute) === XML_NAMESPACE && 'space' === xmlAttributeLocalName(attribute) && ('default' === attribute.value || 'preserve' === attribute.value));
+    return meaningfulAttributes(element).every((attribute)=>xmlAttributeNamespace(element, attribute) === work_docx_equation_import_XML_NAMESPACE && 'space' === xmlAttributeLocalName(attribute) && ('default' === attribute.value || 'preserve' === attribute.value));
 }
 function mathValue(element) {
     if (!DOCX_MATH_NAMESPACES.has(element.namespaceURI ?? '') || work_ooxml_package_directChildren(element).length || hasMeaningfulDirectText(element)) return null;
@@ -4810,7 +5068,7 @@ function supportedNumberingChange(change) {
     const paragraph = properties?.parentElement;
     if (numbering?.localName !== 'numPr' || numbering.namespaceURI !== namespace || properties?.localName !== 'pPr' || properties.namespaceURI !== namespace || paragraph?.localName !== 'p' || paragraph.namespaceURI !== namespace) return null;
     const numberingChildren = work_ooxml_package_directChildren(numbering);
-    if (3 !== numberingChildren.length || numberingChildren.some((child)=>child.namespaceURI !== namespace) || 1 !== work_ooxml_package_directChildren(numbering, 'numberingChange').length || 0 !== change.children.length || hasUnsupportedWordAttribute(change)) return null;
+    if (3 !== numberingChildren.length || numberingChildren.some((child)=>child.namespaceURI !== namespace) || 1 !== work_ooxml_package_directChildren(numbering, 'numberingChange').length || 0 !== change.children.length || work_docx_numbering_change_import_hasUnsupportedWordAttribute(change)) return null;
     const levels = directWordChildren(numbering, 'ilvl');
     const numberingIds = directWordChildren(numbering, 'numId');
     if (1 !== levels.length || 1 !== numberingIds.length) return null;
@@ -4940,7 +5198,7 @@ function work_docx_numbering_change_import_wordAttribute(element, localName) {
     const attributes = Array.from(element.attributes).filter((attribute)=>xmlAttributeLocalName(attribute) === localName && xmlAttributeNamespace(element, attribute) === namespace);
     return 1 === attributes.length ? attributes[0]?.value ?? null : null;
 }
-function hasUnsupportedWordAttribute(element) {
+function work_docx_numbering_change_import_hasUnsupportedWordAttribute(element) {
     const namespace = element.namespaceURI;
     const supported = new Set([
         'id',
@@ -8933,4 +9191,4 @@ function work_docx_text_box_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
-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 };
+export { applyImportedDocxChangeMarkers, 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, hasImportedDocxChangeMarkers, 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, isSupportedDocxMoveChange, isSupportedDocxNumberingChange, isSupportedDocxParagraphFormattingChange, isSupportedDocxRunFormattingChange, markDocxContentControls, markDocxIndexes, markDocxNumberingChanges, markDocxPackageEquations, markDocxParagraphAlignments, markDocxParagraphBorders, markDocxParagraphDirections, markDocxParagraphFormattingChanges, markDocxParagraphIndents, markDocxParagraphPagination, markDocxParagraphShading, markDocxParagraphSpacing, markDocxParagraphTabStops, markDocxRunFormattingIntoState, markDocxTablesOfContents, markDocxTextBoxes, markDocxTextChanges, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxHiddenText, resolveDocxLegacyTextEffects, resolveDocxParagraphBordersForParagraph, resolveDocxRunBorder, resolveDocxRunShading, resolveDocxTableStyleResolver, supportedDocxIndexEntryField, supportedDocxIndexField, supportedDocxMovePairCount, supportedDocxTableOfContentsField };

package/dist/0~controlled-editor-composition.js

@@ -1,22 +1,114 @@
 const COMPOSITION_SETTLE_RETRY_MS = 20;
 const MAX_COMPOSITION_SETTLE_RETRIES = 4;
+const COMPOSITION_SETTLE_QUIET_MS = 24;
+const COMPOSITION_SETTLE_MAX_MS = 240;
+function inputTypeOf(event) {
+    const inputType = event.inputType;
+    return 'string' == typeof inputType ? inputType : '';
+}
+function inputDataOf(event) {
+    const data = event.data;
+    return 'string' == typeof data ? data : null;
+}
+function isCommittedInput(event) {
+    return 'insertFromComposition' === inputTypeOf(event);
+}
 class ControlledEditorComposition {
     active = false;
+    committedInputSeen = false;
+    committedText = null;
+    compositionData = null;
+    deadline = 0;
     generation = 0;
+    awaitingCommittedTransaction = false;
+    range = null;
+    rangeFrozen = false;
     settling = false;
+    settleAt = 0;
+    settleHandler = null;
+    settleEditor = null;
+    sessionId = 0;
     timer = null;
-    start() {
+    start(editor) {
+        if (this.active) {
+            if (!this.range && editor && !editor.isDestroyed) this.range = this.selectionRange(editor);
+            return;
+        }
         this.generation += 1;
         this.cancelTimer();
         this.active = true;
+        this.awaitingCommittedTransaction = false;
+        this.committedInputSeen = false;
+        this.committedText = null;
+        this.compositionData = null;
+        this.deadline = 0;
+        this.range = editor && !editor.isDestroyed ? this.selectionRange(editor) : null;
+        this.rangeFrozen = false;
         this.settling = false;
+        this.settleAt = 0;
+        this.settleEditor = null;
+        this.settleHandler = null;
+        this.sessionId += 1;
     }
-    end(editor, onSettled) {
+    recordTransaction(transaction) {
+        if (!this.active && !this.settling || !this.range || this.rangeFrozen || !transaction.docChanged) return;
+        const from = transaction.mapping.map(this.range.from, -1);
+        const to = transaction.mapping.map(this.range.to, 1);
+        this.range = {
+            from: Math.min(from, to),
+            to: Math.max(from, to)
+        };
+        if (this.settling && this.awaitingCommittedTransaction) {
+            this.awaitingCommittedTransaction = false;
+            this.rangeFrozen = true;
+        }
+    }
+    noteInput(event) {
+        const data = inputDataOf(event);
+        const committed = isCommittedInput(event);
+        if (this.active) {
+            if (committed && data) {
+                this.committedInputSeen = true;
+                this.committedText = data;
+                this.awaitingCommittedTransaction = true;
+            }
+            return;
+        }
+        if (!this.settling) return;
+        const matchesCompositionData = Boolean(data && this.compositionData && data === this.compositionData);
+        if (!committed && !matchesCompositionData) {
+            if (data) {
+                this.awaitingCommittedTransaction = false;
+                this.rangeFrozen = true;
+                this.scheduleQuietSettlement();
+            }
+            return;
+        }
+        if (data) this.committedText = data;
+        this.committedInputSeen = true;
+        this.awaitingCommittedTransaction = true;
+        this.scheduleQuietSettlement();
+    }
+    end(editor, dataOrHandler, maybeHandler) {
+        const legacySettlement = 'function' == typeof dataOrHandler;
+        const data = legacySettlement ? null : dataOrHandler;
+        const handler = 'function' == typeof dataOrHandler ? dataOrHandler : maybeHandler;
+        if (!handler || !this.active && !this.settling) return;
+        if ('string' == typeof data) {
+            this.compositionData = data;
+            if (data && !this.committedText) this.committedText = data;
+            if (data && this.currentRangeText(editor) === data) this.committedInputSeen = true;
+        }
         const generation = ++this.generation;
         this.cancelTimer();
         this.active = false;
         this.settling = true;
-        this.scheduleSettlement(editor, onSettled, generation, 0);
+        this.deadline = Date.now() + COMPOSITION_SETTLE_MAX_MS;
+        this.settleEditor = editor;
+        this.settleHandler = handler;
+        this.settleAt = legacySettlement ? Date.now() : this.committedInputSeen ? Date.now() + COMPOSITION_SETTLE_QUIET_MS : this.deadline;
+        if (legacySettlement) this.deadline = Date.now() + COMPOSITION_SETTLE_RETRY_MS * MAX_COMPOSITION_SETTLE_RETRIES;
+        this.scheduleSettlement(generation);
     }
     isBlocking(editor) {
         return this.active || this.settling || Boolean(editor && !editor.isDestroyed && editor.view.composing);
@@ -26,24 +118,84 @@ class ControlledEditorComposition {
         this.cancelTimer();
         this.active = false;
         this.settling = false;
+        this.committedInputSeen = false;
+        this.committedText = null;
+        this.compositionData = null;
+        this.deadline = 0;
+        this.range = null;
+        this.rangeFrozen = false;
+        this.settleAt = 0;
+        this.settleEditor = null;
+        this.settleHandler = null;
+    }
+    selectionRange(editor) {
+        return {
+            from: editor.state.selection.from,
+            to: editor.state.selection.to
+        };
+    }
+    currentRangeText(editor) {
+        if (!this.range || editor.isDestroyed) return null;
+        const maximum = editor.state.doc.content.size;
+        if (this.range.from < 0 || this.range.to < this.range.from || this.range.to > maximum) return null;
+        return editor.state.doc.textBetween(this.range.from, this.range.to, '\n', '\n');
     }
-    scheduleSettlement(editor, onSettled, generation, retry) {
-        const delay = 0 === retry ? 0 : COMPOSITION_SETTLE_RETRY_MS;
+    snapshot(editor) {
+        const maximum = editor.state.doc.content.size;
+        const from = this.range ? Math.max(0, Math.min(maximum, this.range.from)) : null;
+        const to = this.range ? Math.max(0, Math.min(maximum, this.range.to)) : null;
+        return {
+            id: this.sessionId,
+            range: null === from || null === to ? null : {
+                from: Math.min(from, to),
+                to: Math.max(from, to)
+            },
+            text: this.committedText
+        };
+    }
+    scheduleQuietSettlement() {
+        if (!this.settling) return;
+        this.settleAt = Math.min(this.deadline, Date.now() + COMPOSITION_SETTLE_QUIET_MS);
+        this.scheduleSettlement(this.generation);
+    }
+    scheduleSettlement(expectedGeneration) {
+        this.cancelTimer();
+        const wait = Math.max(0, this.settleAt - Date.now());
         this.timer = setTimeout(()=>{
             this.timer = null;
-            if (generation !== this.generation) return;
-            if (editor.isDestroyed) {
-                this.settling = false;
-                return;
-            }
+            if (expectedGeneration !== this.generation || !this.settling) return;
+            const editor = this.settleEditor;
+            const handler = this.settleHandler;
+            if (!editor || !handler || editor.isDestroyed) return void this.clearSettlement();
             if (editor.view.composing) {
-                if (retry < MAX_COMPOSITION_SETTLE_RETRIES) this.scheduleSettlement(editor, onSettled, generation, retry + 1);
-                else this.settling = false;
+                if (Date.now() < this.deadline) {
+                    this.settleAt = Math.min(this.deadline, Date.now() + COMPOSITION_SETTLE_RETRY_MS);
+                    this.scheduleSettlement(expectedGeneration);
+                } else this.clearSettlement();
                 return;
             }
-            this.settling = false;
-            onSettled(editor);
-        }, delay);
+            if (Date.now() < this.settleAt) return void this.scheduleSettlement(expectedGeneration);
+            const snapshot = this.snapshot(editor);
+            try {
+                handler(editor, snapshot);
+            } finally{
+                this.clearSettlement();
+            }
+        }, wait);
+    }
+    clearSettlement() {
+        this.active = false;
+        this.awaitingCommittedTransaction = false;
+        this.settling = false;
+        this.committedInputSeen = false;
+        this.committedText = null;
+        this.compositionData = null;
+        this.deadline = 0;
+        this.range = null;
+        this.rangeFrozen = false;
+        this.settleAt = 0;
+        this.settleEditor = null;
+        this.settleHandler = null;
     }
     cancelTimer() {
         if (null === this.timer) return;