@docx-editor.dev/core 2.30.0 → 2.32.0

package/dist/{protocol-CZ1uUlPO.d.ts → protocol-DKa4qt7F.d.ts}

@@ -1,5 +1,5 @@
-import { aw as AutomationTableMutation, a9 as RevisionBatchResult, a8 as RevisionAuthorResult } from './types-barrel-CA0xB8kH.js';
-import { c as HeaderFooterVariant, N as NoteKind } from './tree-package-store-DKhdEVym.js';
+import { aE as AutomationTableMutation, Q as RevisionBatchResult, K as RevisionAuthorResult } from './tree-op-types-C_S2niXW.js';
+import { c as HeaderFooterVariant, N as NoteKind } from './tree-package-store-CRHvMyNj.js';
 
 /** Word's shape types, as `Word.ShapeType` spells them. */
 type AutomationShapeType = 'TextBox' | 'GeometricShape' | 'Picture' | 'Group' | 'Canvas' | 'Unsupported';
@@ -162,6 +162,25 @@ type AutomationAuthoringOperation = {
     readonly op: 'setFieldCode';
     readonly field: AutomationHandle;
     readonly code: string;
+}
+/** The text of a field's cached result, read as a range over the field reads it. */
+ | {
+    readonly op: 'getFieldResult';
+    readonly field: AutomationHandle;
+    readonly projection?: AutomationTextProjection;
+}
+/** Replace a field's cached result with plain text. The instruction never changes. */
+ | {
+    readonly op: 'setFieldResult';
+    readonly field: AutomationHandle;
+    readonly text: string;
+}
+/** Insert the one equation a Flat OPC package holds. See `equation-snippet.ts`. */
+ | {
+    readonly op: 'insertOoxml';
+    readonly span: AutomationSpanRef;
+    readonly location: 'Before' | 'After' | 'Start' | 'End' | 'Replace';
+    readonly ooxml: string;
 } | {
     readonly op: 'insertField';
     readonly span: AutomationSpanRef;
@@ -189,6 +208,15 @@ type AutomationAuthoringOperation = {
     readonly table: AutomationHandle;
     readonly rowIndex: number;
     readonly cellIndex: number;
+}
+/** The cell a merge of this rectangle merges into, read before the merge applies. */
+ | {
+    readonly op: 'getMergedTableCell';
+    readonly table: AutomationHandle;
+    readonly topRow: number;
+    readonly firstCell: number;
+    readonly bottomRow: number;
+    readonly lastCell: number;
 } | {
     readonly op: 'getTableCellProperties' | 'getTableCellBody';
     readonly cell: AutomationHandle;
@@ -199,6 +227,8 @@ type AutomationAuthoringOperation = {
         kind: 'cell';
     } | {
         kind: 'insertRows';
+    } | {
+        kind: 'splitCell';
     }>;
 } | {
     readonly op: 'updateTableCell';
@@ -208,6 +238,13 @@ type AutomationAuthoringOperation = {
     } | {
         kind: 'insertRows';
     }>, 'kind' | 'cellId'>;
+}
+/** Split one cell into `rowCount` by `columnCount` cells. */
+ | {
+    readonly op: 'splitTableCell';
+    readonly cell: AutomationHandle;
+    readonly rowCount: number;
+    readonly columnCount: number;
 } | {
     readonly op: 'insertTable';
     readonly span: AutomationSpanRef;
@@ -344,16 +381,20 @@ type AutomationSpanRef = {
     readonly body: AutomationHandle;
 };
 /**
- * Where to look for content controls: a whole story, or inside one control.
+ * Where to look for content controls: a whole story, inside one control, or across a span.
  *
  * A control's own scope is how nesting is expressed. Listing every control of a story flat
  * would answer a form field and the group wrapping it as siblings, which is not what either of
- * them is.
+ * them is. A SPAN scope is the exception on purpose: it answers every control the span
+ * overlaps, at any depth, including a control that holds the whole span, because a caller asks
+ * a range for its controls to learn what an edit through it would touch.
  */
 type AutomationContentControlScope = {
     readonly body: AutomationHandle;
 } | {
     readonly contentControl: AutomationHandle;
+} | {
+    readonly span: AutomationSpanRef;
 };
 /** The value a control accepts, by what kind of control it is. */
 type AutomationContentControlValue = {
@@ -496,6 +537,35 @@ type AutomationOperation = AutomationAuthoringOperation | {
     readonly span: AutomationSpanRef;
     readonly projection?: AutomationTextProjection;
 }
+/**
+ * A span split into ranges that each end after one of `endingMarks`, or at a paragraph end.
+ *
+ * Boundaries come from the model text, so a field, an equation, or another atom is never
+ * split. `trimSpacing` removes spaces, tabs, and column breaks from each range's edges and
+ * drops a range left empty. A range the projection shows no character of is not answered.
+ */
+ | {
+    readonly op: 'getTextRanges';
+    readonly scope: AutomationSpanRef;
+    readonly endingMarks: readonly string[];
+    readonly trimSpacing?: boolean;
+    readonly projection?: AutomationTextProjection;
+}
+/** The smallest span covering both spans. Both must be in one story. */
+ | {
+    readonly op: 'expandSpan';
+    readonly span: AutomationSpanRef;
+    readonly to: AutomationSpanRef;
+}
+/**
+ * A span's text as if every pending revision were accepted (`current`) or rejected
+ * (`original`), with a carriage return at each paragraph mark that view keeps.
+ */
+ | {
+    readonly op: 'getReviewedText';
+    readonly span: AutomationSpanRef;
+    readonly version: 'original' | 'current';
+}
 /**
  * A paragraph's own identity as the DOCUMENT writes it (`w14:paraId`).
  *
@@ -877,6 +947,50 @@ type AutomationOperation = AutomationAuthoringOperation | {
     readonly op: 'getBookmarkRange';
     readonly bookmark: AutomationHandle;
 }
+/**
+ * The names of the bookmarks a span overlaps, in document order: `Range.getBookmarks`.
+ *
+ * A non-empty span holds a bookmark when the two share text, and a point bookmark when the
+ * point is inside the span. An empty span holds the bookmarks around it. `includeAdjacent`
+ * adds the bookmarks that only touch the span; `includeHidden` adds names starting with `_`.
+ */
+ | {
+    readonly op: 'getBookmarkNames';
+    readonly scope: AutomationSpanRef;
+    readonly includeHidden: boolean;
+    readonly includeAdjacent: boolean;
+}
+/**
+ * The range of the bookmark with this name, compared without case, in any story: main text
+ * first, then headers, footers and notes. Answers no span when nothing declares the name.
+ */
+ | {
+    readonly op: 'getBookmarkRangeByName';
+    readonly document: AutomationHandle;
+    readonly name: string;
+}
+/**
+ * Add a bookmark around a span, or at a point. A bookmark any story declares under the same
+ * name, compared without case, moves here in the same write.
+ */
+ | {
+    readonly op: 'insertBookmark';
+    readonly span: AutomationSpanRef;
+    readonly name: string;
+}
+/**
+ * Remove a bookmark: by name anywhere in the document, or the one a handle names. The text
+ * stays. A name nothing declares is not an error and changes nothing.
+ */
+ | {
+    readonly op: 'deleteBookmark';
+    readonly target: {
+        readonly document: AutomationHandle;
+        readonly name: string;
+    } | {
+        readonly bookmark: AutomationHandle;
+    };
+}
 /**
  * The comments anchored in a scope, in document order — the TOP-LEVEL ones.
  *
@@ -990,6 +1104,31 @@ type AutomationOperation = AutomationAuthoringOperation | {
     readonly op: 'getRevisions';
     readonly body: AutomationHandle;
 }
+/**
+ * The listed tracked changes whose characters a span overlaps, in document order. A collapsed
+ * span lists the changes it touches. Handles are the story-wide listing's handles.
+ */
+ | {
+    readonly op: 'getRevisions';
+    readonly scope: AutomationSpanRef;
+}
+/**
+ * The listed tracked changes a review-queue key names: one, or the two halves of a paired
+ * replacement. A key naming nothing answers no handles.
+ */
+ | {
+    readonly op: 'getRevisions';
+    readonly key: string;
+}
+/**
+ * The stretch a review-queue key names: `revision-<id>`, a paired `revision-replace:<a>+<b>`,
+ * or `comment-<id>`. Answers `spans` holding one span covering every range of the item, or no
+ * span when the key names nothing this document holds.
+ */
+ | {
+    readonly op: 'getReviewItemRange';
+    readonly key: string;
+}
 /** Resolve eligible decisions in one story. Omit revisions to select every canonical decision. */
  | {
     readonly op: 'resolveRevisionBatch';
@@ -1061,6 +1200,24 @@ type AutomationOperation = AutomationAuthoringOperation | {
     readonly op: 'rejectAllRevisions';
     readonly document: AutomationHandle;
 }
+/**
+ * Accept or reject every change a span overlaps, or the changes a review-queue key names, as
+ * one transaction. Structural changes absent from listings are included. Refused whole when
+ * any of them is read-only or cannot be resolved, and when the key names nothing.
+ */
+ | {
+    readonly op: 'acceptAllRevisions';
+    readonly scope: AutomationSpanRef;
+} | {
+    readonly op: 'rejectAllRevisions';
+    readonly scope: AutomationSpanRef;
+} | {
+    readonly op: 'acceptAllRevisions';
+    readonly key: string;
+} | {
+    readonly op: 'rejectAllRevisions';
+    readonly key: string;
+}
 /**
  * Put the reader's selection on a span. Requires the `selection` capability, so a headless
  * host refuses it rather than pretending to have a caret.
@@ -1493,6 +1650,11 @@ type AutomationValue = {
 } | {
     readonly kind: 'text';
     readonly text: string;
+}
+/** Several strings, in document order: the names of the bookmarks a range holds. */
+ | {
+    readonly kind: 'texts';
+    readonly texts: readonly string[];
 } | {
     readonly kind: 'span';
     readonly span: AutomationSpan;
@@ -1648,4 +1810,4 @@ interface AutomationHost {
     dispose(): void;
 }
 
-export type { AutomationOperation as A, AutomationPoint as B, AutomationReadingOrder as C, AutomationSaveResult as D, AutomationSearchOptions as E, AutomationSelectionMode as F, AutomationSpan as G, AutomationSpanRef as H, AutomationTextProjection as I, AutomationUnsubscribe as J, AutomationValue as K, AutomationCapabilities as a, AutomationHost as b, AutomationAlignment as c, AutomationBatchRequest as d, AutomationBatchResponse as e, AutomationChangeEvent as f, AutomationContentControlLock as g, AutomationContentControlRangeLocation as h, AutomationContentControlScope as i, AutomationContentControlSubtype as j, AutomationContentControlValue as k, AutomationError as l, AutomationErrorCode as m, AutomationFontRead as n, AutomationFontWrite as o, AutomationHandle as p, AutomationHandleRef as q, AutomationObjectKind as r, AutomationOperationKind as s, AutomationOperationResult as t, AutomationPageOrientation as u, AutomationPageSetupRead as v, AutomationPageSetupWrite as w, AutomationParagraphFormatRead as x, AutomationParagraphFormatWrite as y, AutomationParagraphRef as z };
+export type { AutomationOperation as A, AutomationOperationKind as B, AutomationOperationResult as C, AutomationPageOrientation as D, AutomationPageSetupRead as E, AutomationPageSetupWrite as F, AutomationParagraphFormatRead as G, AutomationParagraphFormatWrite as H, AutomationParagraphRef as I, AutomationPoint as J, AutomationReadingOrder as K, AutomationSaveResult as L, AutomationSearchOptions as M, AutomationSelectionMode as N, AutomationShapeRead as O, AutomationShapeType as P, AutomationSpan as Q, AutomationSpanRef as R, AutomationTextProjection as S, AutomationUnsubscribe as T, AutomationValue as U, AutomationCapabilities as a, AutomationHost as b, AutomationAlignment as c, AutomationAuthoringOperation as d, AutomationBatchRequest as e, AutomationBatchResponse as f, AutomationChangeEvent as g, AutomationContentControlLock as h, AutomationContentControlRangeLocation as i, AutomationContentControlScope as j, AutomationContentControlSubtype as k, AutomationContentControlValue as l, AutomationCustomNodePayload as m, AutomationEndpoint as n, AutomationError as o, AutomationErrorCode as p, AutomationFontRead as q, AutomationFontWrite as r, AutomationHandle as s, AutomationHandleRef as t, AutomationInlinePictureRead as u, AutomationInlinePictureWrite as v, AutomationListBullet as w, AutomationListLevelFormat as x, AutomationListNumbering as y, AutomationObjectKind as z };

package/dist/{review-paragraph-order-CqVelc5A.d.ts → review-paragraph-order-Dc17w_6v.d.ts}

@@ -1,4 +1,4 @@
-import { N as OoxmlNode, ah as OoxmlElement, ai as OoxmlContentControlNode, V as OoxmlGenericElementNode, aj as OoxmlContentControlContentNode, C as CommentRecord, O as OoxmlPart } from './types-barrel-CA0xB8kH.js';
+import { a4 as OoxmlNode, av as OoxmlElement, aw as OoxmlContentControlNode, ax as OoxmlGenericElementNode, ay as OoxmlContentControlContentNode, C as CommentRecord, O as OoxmlPart } from './tree-op-types-C_S2niXW.js';
 
 /** Nested content-control wrappers deeper than this stop flattening; content stays preserved. */
 declare const MAX_CONTENT_CONTROL_NESTING = 32;

package/dist/revision-projection-Cn6rZJ7H.d.ts

@@ -0,0 +1,258 @@
+import { a4 as OoxmlNode } from './tree-op-types-C_S2niXW.js';
+
+/** Named revision colors. Identifiers are stable and never contain CSS. @public */
+declare const REVISION_MARKUP_COLORS: readonly ['black', 'blue', 'turquoise', 'green', 'pink', 'red', 'yellow', 'white', 'darkBlue', 'teal', 'darkGreen', 'violet', 'darkRed', 'darkYellow', 'gray50', 'gray25', 'lightBlue', 'lightYellow', 'lightOrange', 'lightPurple', 'lightGreen', 'gray'];
+/** @public */
+type RevisionMarkupNamedColor = (typeof REVISION_MARKUP_COLORS)[number];
+/** @public */
+type RevisionMarkupColor = RevisionMarkupNamedColor | 'byAuthor' | 'auto';
+/** @public */
+type RevisionMarkupMark = 'none' | 'colorOnly' | 'bold' | 'italic' | 'underline' | 'doubleUnderline' | 'strikethrough' | 'doubleStrikethrough';
+/** @public */
+type RevisionDeletionMark = RevisionMarkupMark | 'hidden' | 'caret' | 'pound';
+/** @public */
+type RevisionChangedLinesMark = 'none' | 'leftBorder' | 'rightBorder' | 'outsideBorder';
+/** @public */
+interface RevisionMarkupStyle<Mark extends string = RevisionMarkupMark> {
+    readonly mark: Mark;
+    readonly color: RevisionMarkupColor;
+}
+/** Viewer-only text styling. Document highlighting remains unchanged. @public */
+interface RevisionMarkupTextStyle<Mark extends string = RevisionMarkupMark> extends RevisionMarkupStyle<Mark> {
+    /** Background color behind revision text. Defaults to `none`. */
+    readonly background: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+}
+/** Fully resolved, immutable viewer preferences. @public */
+interface ResolvedRevisionMarkup {
+    readonly insertions: RevisionMarkupTextStyle;
+    readonly deletions: RevisionMarkupTextStyle<RevisionDeletionMark>;
+    readonly movedFrom: RevisionMarkupTextStyle<RevisionDeletionMark>;
+    readonly movedTo: RevisionMarkupTextStyle;
+    readonly formatting: RevisionMarkupTextStyle;
+    readonly changedLines: RevisionMarkupStyle<RevisionChangedLinesMark>;
+    readonly cells: {
+        readonly inserted: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+        readonly deleted: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+        readonly merged: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+        readonly split: RevisionMarkupNamedColor | 'byAuthor' | 'none';
+    };
+    readonly trackMoves: boolean;
+    readonly trackFormatting: boolean;
+}
+/** Partial viewer preferences. Omitted values keep the previous value. @public */
+type RevisionMarkupOptions = {
+    readonly [K in keyof ResolvedRevisionMarkup]?: ResolvedRevisionMarkup[K] extends boolean ? boolean : Partial<ResolvedRevisionMarkup[K]>;
+};
+/** Initial viewer preferences. @public */
+declare const DEFAULT_REVISION_MARKUP: ResolvedRevisionMarkup;
+/** Validate and merge preferences without modifying the input. @public */
+declare function resolveRevisionMarkup(input?: RevisionMarkupOptions, previous?: ResolvedRevisionMarkup): ResolvedRevisionMarkup;
+/** CSS token for a validated named color. */
+declare function revisionMarkupColor(color: RevisionMarkupColor, authorColor: string, auto?: string): string;
+/** Select the visual style without changing revision identity. */
+declare function revisionMarkupStyle(settings: ResolvedRevisionMarkup, kind: 'insert' | 'delete' | 'moveFrom' | 'moveTo' | 'format'): RevisionMarkupTextStyle<RevisionDeletionMark>;
+/** A local settings draft owned by the editor. @public */
+interface RevisionMarkupDialogSession {
+    /** Aborts on close, replacement, load, detach, destroy, or renderer disposal. */
+    readonly signal: AbortSignal;
+    /** Read the immutable draft. */
+    get(): ResolvedRevisionMarkup;
+    /** Merge validated options into the draft without committing preferences. */
+    set(options: RevisionMarkupOptions): void;
+    /** Restore default preferences in the draft only. */
+    reset(): void;
+    /** Observe draft changes, including effective external preference changes. */
+    subscribe(listener: () => void): () => void;
+    canApply(): boolean;
+    /** Commit the draft and close. Returns false after cancellation. */
+    apply(): boolean;
+    /** Close without committing the draft. */
+    cancel(): void;
+}
+/** Host rendering for the Track changes options dialog. @public */
+interface RevisionMarkupChromeHandlers {
+    readonly onRequest?: (session: RevisionMarkupDialogSession) => void;
+}
+
+/**
+ * What a revision wrapper asserts about the content inside it.
+ *
+ * `moveFrom` / `moveTo` are deliberately distinct from `delete` / `insert`: a move is one
+ * decision with two halves, and presenting it as an unrelated deletion and insertion invites
+ * resolving one without the other, which duplicates or loses the content.
+ */
+type RevisionKind = 'insert' | 'delete' | 'moveFrom' | 'moveTo' | 'format';
+/**
+ * One revision wrapper's provenance, as authored.
+ *
+ * `id` is the verbatim `@w:id` string rather than a number: `ST_DecimalNumber` restricts
+ * `xsd:integer` with no bounds, so a file may carry a value outside the safe integer range, and
+ * parsing it to a number would silently merge two distinct revisions.
+ *
+ * `date` is absent when the file omits it. `@w:date` is optional on `CT_TrackChange`, and
+ * inventing one is a silent content change.
+ */
+interface RevisionAttribution {
+    readonly kind: RevisionKind;
+    readonly id: string;
+    readonly author: string;
+    readonly date?: string;
+    /** The wrapper's node id, so a surface can address this exact site. */
+    readonly nodeId: string;
+}
+/**
+ * Which revisions layout resolves before producing pages.
+ *
+ * - `all-markup` shows both halves of every change.
+ * - `proposed` shows what the document becomes if every change is accepted.
+ * - `original` shows what it was before any of them.
+ *
+ * The last two are specified as equal to accept-all and reject-all OUTPUT, which is what makes
+ * them testable, without either applying an op.
+ */
+type RevisionDisplayMode = 'all-markup' | 'proposed' | 'original';
+/**
+ * The views the review chrome offers, in Word's terms: the three layout projections plus
+ * Simple Markup, which reads as the proposed result with a red change bar beside every line
+ * a change touched — the document as accepting everything would leave it, and where.
+ */
+type ReviewDisplayMode = RevisionDisplayMode | 'simple-markup';
+/**
+ * How a document renders tracked changes when nothing says otherwise.
+ *
+ * `all-markup` matches Word's own default: a reader who opens a document with pending changes
+ * sees them, rather than a clean-looking document hiding edits nobody has accepted.
+ */
+declare const DEFAULT_REVISION_DISPLAY_MODE: RevisionDisplayMode;
+/**
+ * A view-time tracked-change filter. Revisions rejected by `includes` use the filter's accepted
+ * or rejected projection, while included revisions keep the display mode's normal projection.
+ *
+ * `cacheKey` is a canonical, content-based identity for layout caches. The set itself is kept
+ * because author names are attacker-controlled strings and must never be parsed back from a
+ * delimiter-based key.
+ */
+interface RevisionFilter {
+    readonly revisionMarkup?: ResolvedRevisionMarkup;
+    readonly hiddenAuthors: ReadonlySet<string>;
+    readonly includes?: (revision: RevisionAttribution) => boolean;
+    readonly includesNode?: (nodeId: string, author: string) => boolean;
+    /** Accepted/original projection for a revision excluded by `includesNode`. */
+    readonly excludedNodeMode?: (nodeId: string, author: string) => 'proposed' | 'original';
+    /**
+     * In a resolved view, content the view keeps paints as ORDINARY text: no author ink, no
+     * decoration, no change bar of its own. This is Word's No Markup, Original and Simple
+     * Markup, which the review chrome asks for. Without it the accepted projection keeps the
+     * attribution on kept insertions, which is what the engine paints when no review module
+     * is registered — colour by author, deletions resolved — and what its roster reads.
+     */
+    readonly resolvedMarkup?: 'plain';
+    readonly cacheKey: string;
+    /**
+     * @internal Revision records the review queue leaves out, by change-element node id, and the
+     * paragraphs that hold them. Their paragraphs project without those records, so they paint
+     * no markup. Not a selection: it never moves a projection off the unfiltered path.
+     */
+    readonly unlisted?: {
+        readonly sites: ReadonlySet<string>;
+        /** Each paragraph that holds one, keyed by the records it holds. */
+        readonly paragraphs: ReadonlyMap<string, string>;
+        /** Names the styles and numbering the records were decided against. */
+        readonly key: string;
+    };
+}
+/** @deprecated Use {@link RevisionFilter}. */
+interface RevisionAuthorFilter extends RevisionFilter {
+}
+/** Build a canonical reviewer filter. An empty input returns `undefined` for the fast path. */
+declare function revisionAuthorFilter(hiddenAuthors: Iterable<string>): RevisionAuthorFilter | undefined;
+/**
+ * Whether content under this stack of revisions is laid out in the given mode.
+ *
+ * Containment governs, so a single enclosing wrapper the mode resolves away suppresses
+ * everything inside it regardless of what the inner wrappers say. An insertion inside a
+ * deletion does not survive the proposed result: the deletion it sits in was accepted.
+ */
+declare function revisionsVisible(revisions: readonly RevisionAttribution[], mode: RevisionDisplayMode, authorFilter?: RevisionAuthorFilter): boolean;
+/**
+ * Every revision on a paragraph's own MARK, from `w:pPr/w:rPr/w:ins|w:del|w:moveFrom|w:moveTo`.
+ *
+ * All four members of `EG_ParaRPrTrackChanges`. A moved paragraph carries `w:moveFrom` on the
+ * mark of the copy it left and `w:moveTo` on the mark of the copy it arrived at, so a move
+ * that spans whole paragraphs is recorded here and nowhere else.
+ *
+ * `EG_ParaRPrTrackChanges` records that the pilcrow itself was inserted or deleted, which is how
+ * Word writes a paragraph split or merge. It is not content — there is no text to decorate — so
+ * a surface shows it as a mark of its own beside the paragraph, the way Word draws a struck-
+ * through ¶.
+ *
+ * A LIST, because the group is `ins? del? moveFrom? moveTo?` and the first two can both be
+ * there: that pair is what Word writes when a second author proposes removing a mark the first
+ * proposed adding, and it is what this engine's own writer emits (`tree-op-tracked.ts`).
+ * Answering with the first one hid the second author's decision from the PAGE. The review pane
+ * walks the tree itself and always listed both, which is the worse shape of the two: a card
+ * offering a decision the reader could see no sign of.
+ *
+ * Ordered as the file orders them, which is the order the group declares.
+ *
+ * Property-position `w:ins`/`w:del` stay `generic` in the tree deliberately, so this reads them
+ * by name rather than by kind.
+ */
+declare function paragraphMarkRevisionsOf(paragraph: OoxmlNode): readonly RevisionAttribution[];
+/**
+ * The tracked FORMAT change on a paragraph's own mark, from `w:pPr/w:rPr/w:rPrChange`.
+ *
+ * `CT_ParaRPr` ends with it (§17.13.5.32), and Word writes it when a user changes the mark's
+ * own run properties with tracking on. It reaches the fragment rather than a span because it
+ * decorates no characters, and it is not in `props`: a fragment's `props` carry the mark's
+ * `w:rPr` by NAME only, with none of its children.
+ *
+ * Note that `w:rPrChange/w:rPr` is `CT_ParaRPrOriginal`, which may carry its own revision
+ * marks. Those describe the mark as it WAS and must not be read as live ones, which is why
+ * this reads the change element's own attributes and never descends into it.
+ */
+declare function paragraphMarkFormatRevisionOf(paragraph: OoxmlNode): RevisionAttribution | null;
+/**
+ * The single decision a one-field reader sees.
+ *
+ * A DELETION wins when a mark carries both, for the reason paint draws it that way: a break
+ * proposed and then unproposed ends up removed, so that is the decision a reader who can only
+ * see one must see. One function decides it, so the deprecated field, the deprecated function
+ * and the painted glyph cannot answer differently.
+ */
+declare function shownMarkRevision(revisions: readonly RevisionAttribution[]): RevisionAttribution | undefined;
+/**
+ * Does this decision, taken, remove the paragraph mark?
+ *
+ * A deletion does, and so does a `moveFrom`: the copy the paragraph moved OUT of goes away
+ * when the move is accepted. `insert` and `moveTo` are the other half of each pair, and they
+ * keep the break. Paint, the change bar and the resolved views all ask this one question, so
+ * a `moveFrom` cannot end up struck through in the margin and blue on the glyph.
+ */
+declare function markRevisionRemovesMark(revision: RevisionAttribution): boolean;
+/**
+ * The one decision on a paragraph's mark that a single-field reader sees.
+ *
+ * @deprecated Reads one of the revisions a mark can carry. Use {@link paragraphMarkRevisionsOf},
+ * which answers with all of them.
+ */
+declare function paragraphMarkRevisionOf(paragraph: OoxmlNode): RevisionAttribution | null;
+/**
+ * The tracked FORMAT change on a property list, from `w:rPrChange` or `w:pPrChange`.
+ *
+ * A property change alters no characters, so it has no span of its own to strike or underline.
+ * Word marks the affected text and says what changed; the minimum a reader needs is to see that
+ * this text's formatting is itself a pending decision.
+ *
+ * Read from the flattened property list because that is what layout already carries — the
+ * change wrapper is a `w:rPr`/`w:pPr` child like any other.
+ */
+declare function formatRevisionOf(properties: readonly {
+    readonly localName: string;
+    readonly attributes?: Readonly<Record<string, string>>;
+}[]): RevisionAttribution | null;
+/** True when this stack of revisions marks its content as deleted from the live document. */
+declare function revisionsAreDeletion(revisions: readonly RevisionAttribution[]): boolean;
+
+export { revisionAuthorFilter as A, revisionsAreDeletion as B, revisionsVisible as C, DEFAULT_REVISION_MARKUP as D, shownMarkRevision as E, REVISION_MARKUP_COLORS as c, revisionMarkupColor as n, revisionMarkupStyle as o, resolveRevisionMarkup as r, DEFAULT_REVISION_DISPLAY_MODE as s, formatRevisionOf as v, markRevisionRemovesMark as w, paragraphMarkFormatRevisionOf as x, paragraphMarkRevisionOf as y, paragraphMarkRevisionsOf as z };
+export type { RevisionMarkupDialogSession as R, ReviewDisplayMode as a, RevisionDisplayMode as b, ResolvedRevisionMarkup as d, RevisionChangedLinesMark as e, RevisionDeletionMark as f, RevisionMarkupChromeHandlers as g, RevisionMarkupColor as h, RevisionMarkupMark as i, RevisionMarkupNamedColor as j, RevisionMarkupOptions as k, RevisionMarkupStyle as l, RevisionMarkupTextStyle as m, RevisionAuthorFilter as p, RevisionAttribution as q, RevisionFilter as t, RevisionKind as u };

package/dist/{semantic-cell-selection-Dr9yxFZt.d.ts → semantic-cell-selection-BaUR0iJ4.d.ts}

@@ -1,5 +1,5 @@
-import { S as SemanticPosition, C as CaretGeometry, a as SemanticSelection } from './semantic-interaction-Dc3pf3hr.js';
-import { I as InlineDrawingRecord, A as AnchoredDrawingRecord, T as TextMeasurer, L as LineRecord, g as StyleSpanRecord, S as SemanticLayout, C as ContentControlBoundaryRecord, h as TableRowFragmentRecord, i as TableCellFragmentRecord } from './semantic-records-CjcF26ZL.js';
+import { S as SemanticPosition, C as CaretGeometry, a as SemanticSelection } from './semantic-interaction-CJoHLoOl.js';
+import { I as InlineDrawingRecord, A as AnchoredDrawingRecord, T as TextMeasurer, L as LineRecord, g as StyleSpanRecord, S as SemanticLayout, C as ContentControlBoundaryRecord, h as TableRowFragmentRecord, i as TableCellFragmentRecord } from './semantic-records-BvN-WWst.js';
 
 /** A point in the coordinate space named by the function taking it. */
 interface HitPoint {

package/dist/{semantic-interaction-Dc3pf3hr.d.ts → semantic-interaction-CJoHLoOl.d.ts}

@@ -1,4 +1,4 @@
-import { T as TextMeasurer, S as SemanticLayout, B as BlockFragmentRecord, C as ContentControlBoundaryRecord, g as StyleSpanRecord } from './semantic-records-CjcF26ZL.js';
+import { T as TextMeasurer, S as SemanticLayout, B as BlockFragmentRecord, C as ContentControlBoundaryRecord, g as StyleSpanRecord } from './semantic-records-BvN-WWst.js';
 
 /** How `moveCaret` resolves a motion. */
 interface MoveCaretOptions {

package/dist/{semantic-paint-Bz3FBAoH.d.ts → semantic-paint-BPw_n0li.d.ts}

@@ -1,6 +1,7 @@
-import { c as PageRecord, q as ResolvedRevisionMarkup, C as ContentControlBoundaryRecord, S as SemanticLayout } from './semantic-records-CjcF26ZL.js';
-import { S as SemanticRootStoryKind } from './semantic-record-queries-Bx0pl6kL.js';
-import { V as ValidatedImageBytesHandle, R as RenderableImageMime } from './image-resources-Bipz8toD.js';
+import { d as ResolvedRevisionMarkup } from './revision-projection-Cn6rZJ7H.js';
+import { ap as ValidatedImageBytesHandle, al as RenderableImageMime, av as OoxmlElement } from './tree-op-types-C_S2niXW.js';
+import { a as PageRecord, C as ContentControlBoundaryRecord, S as SemanticLayout } from './semantic-records-BvN-WWst.js';
+import { S as SemanticRootStoryKind } from './semantic-record-queries-C0rJ3sB4.js';
 
 /**
  * Everything a host can say about ONE author's presentation. Every field is optional and
@@ -199,6 +200,8 @@ declare const DEFAULT_FIELD_SHADING: FieldShadingMode;
  * set through these options is ever serialised back into the document.
  */
 interface PaintOptions {
+    readonly unsupportedOwnerPartName?: (nodeId: string) => string;
+    readonly unsupportedSource?: (nodeId: string, ownerPartName?: string) => OoxmlElement | null;
     /** Points to CSS pixels. 96/72 renders a point as a CSS point at 100% zoom. */
     readonly scale?: number;
     /** Generated paragraphs that paint as non-editable navigation surfaces. */
@@ -335,4 +338,4 @@ interface PaintOptions {
 declare function paintSemanticLayout(container: HTMLElement, layout: SemanticLayout, options?: PaintOptions): void;
 
 export { DEFAULT_FIELD_SHADING as D, collectPageChangeBars as e, paintSemanticLayout as p };
-export type { BreakMarkStrings as B, ChangeBarsMode as C, FieldShadingMode as F, PageChangeBars as P, ReviewAuthorInfo as R, PaintOptions as a, RevisionAuthorAssignments as b, RevisionAuthorStyle as c, RevisionStyles as d, DrawingPaintStrings as f };
+export type { BreakMarkStrings as B, ChangeBarsMode as C, FieldShadingMode as F, PageChangeBars as P, ReviewAuthorInfo as R, RevisionAuthorAssignments as a, RevisionAuthorStyle as b, RevisionStyles as c, PaintOptions as d, DrawingPaintStrings as f };

package/dist/{semantic-record-queries-Bx0pl6kL.d.ts → semantic-record-queries-C0rJ3sB4.d.ts}

@@ -1,4 +1,4 @@
-import { I as InlineDrawingRecord, A as AnchoredDrawingRecord, P as ParagraphFragmentRecord, L as LineRecord, c as PageRecord, N as NoteAreaRecord, d as LayoutBox, H as HeaderFooterStoryRecord, e as NoteStoryRecord, B as BlockFragmentRecord, S as SemanticLayout, C as ContentControlBoundaryRecord, f as ContentControlLock } from './semantic-records-CjcF26ZL.js';
+import { I as InlineDrawingRecord, A as AnchoredDrawingRecord, P as ParagraphFragmentRecord, L as LineRecord, a as PageRecord, N as NoteAreaRecord, b as LayoutBox, H as HeaderFooterStoryRecord, c as NoteStoryRecord, B as BlockFragmentRecord, S as SemanticLayout, C as ContentControlBoundaryRecord, d as ContentControlLock } from './semantic-records-BvN-WWst.js';
 
 /**
  * Depth-first paragraph fragments of one page, in reading order.