@docx-editor.dev/core 2.31.0 → 2.33.0

package/dist/metafile-drawing-DtMFyMKq.d.ts

@@ -0,0 +1,107 @@
+/** A 2D affine matrix `[a, b, c, d, e, f]`: x' = a·x + c·y + e, y' = b·x + d·y + f. @internal */
+type MetafileMatrix = readonly [number, number, number, number, number, number];
+/** One path command in canvas pixels, y down. @internal */
+type MetafilePathCommand = {
+    readonly op: 'M' | 'L';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'C';
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'Z';
+};
+/** A solid paint: 0–255 channels and 0–1 alpha. @internal */
+interface MetafilePaint {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly alpha: number;
+}
+/** The face a text command names. @internal */
+interface MetafileFont {
+    readonly family: string;
+    readonly sizePx: number;
+    readonly bold: boolean;
+    readonly italic: boolean;
+}
+/** Raster content a metafile draws. @internal */
+type MetafileRaster = {
+    readonly kind: 'rgba';
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8Array;
+} | {
+    readonly kind: 'encoded';
+    readonly mime: 'image/png' | 'image/jpeg';
+    readonly width: number;
+    readonly height: number;
+    readonly bytes: Uint8Array;
+};
+/**
+ * One recorded drawing command. Paths are in canvas pixels with the transform already
+ * applied. `matrix` on an image maps its unit square (y down) into canvas pixels; on text and
+ * a nested drawing it is the transform in force when it was drawn.
+ * @internal
+ */
+type MetafileCommand = {
+    readonly kind: 'save';
+} | {
+    readonly kind: 'restore';
+} | {
+    readonly kind: 'fill';
+    readonly path: readonly MetafilePathCommand[];
+    readonly evenOdd: boolean;
+    readonly paint: MetafilePaint;
+} | {
+    readonly kind: 'stroke';
+    readonly path: readonly MetafilePathCommand[];
+    readonly width: number;
+    readonly dash: readonly number[];
+    readonly paint: MetafilePaint;
+} | {
+    readonly kind: 'clip';
+    readonly path: readonly MetafilePathCommand[];
+    readonly evenOdd: boolean;
+} | {
+    readonly kind: 'image';
+    readonly raster: MetafileRaster;
+    readonly matrix: MetafileMatrix;
+} | {
+    readonly kind: 'text';
+    readonly text: string;
+    readonly font: MetafileFont;
+    readonly x: number;
+    readonly y: number;
+    readonly align: 'left' | 'center' | 'right';
+    readonly baseline: 'alphabetic' | 'top' | 'bottom' | 'middle';
+    readonly matrix: MetafileMatrix;
+    readonly paint: MetafilePaint;
+} | {
+    readonly kind: 'drawing';
+    readonly drawing: MetafileDrawing;
+    readonly matrix: MetafileMatrix;
+};
+/** A replayed metafile: its canvas size in pixels and its commands in order. @internal */
+interface MetafileDrawing {
+    readonly width: number;
+    readonly height: number;
+    readonly commands: readonly MetafileCommand[];
+}
+/** What a metafile renderer reads beside the bytes. @internal */
+interface MetafileRenderOptions {
+    /** Advance width of `text` in `font`, in pixels at `font.sizePx`. */
+    readonly textAdvance: (text: string, font: MetafileFont) => number;
+}
+/** A replayed metafile. `complete` is false when a bound stopped recording early. @internal */
+interface MetafileReplay {
+    readonly drawing: MetafileDrawing;
+    readonly complete: boolean;
+}
+
+export type { MetafileFont as M, MetafileReplay as a, MetafileCommand as b, MetafileDrawing as c, MetafileMatrix as d, MetafilePaint as e, MetafilePathCommand as f, MetafileRaster as g, MetafileRenderOptions as h };

package/dist/{note-properties-QsKh24sM.d.ts → note-properties-DCIJUKIy.d.ts}

@@ -1,4 +1,4 @@
-import { O as OoxmlPart, N as OoxmlNode, Q as OoxmlPackage } from './types-barrel-CkF2JbU4.js';
+import { O as OoxmlPart, a4 as OoxmlNode, a5 as OoxmlPackage } from './tree-op-types-Df4oY2u4.js';
 
 /** `w:pos` — where a section's footnotes are laid out. */
 type FootnotePosition = 'pageBottom' | 'beneathText' | 'sectEnd' | 'docEnd';

package/dist/output.cjs

@@ -1 +1 @@
-'use strict';var chunkXMJKFURD_cjs=require('./chunk-XMJKFURD.cjs');require('./chunk-5JPIEN54.cjs'),require('./chunk-DBOOTED4.cjs'),require('./chunk-IBRBNT37.cjs'),require('./chunk-243W4WW2.cjs'),require('./chunk-WO4V6PNS.cjs');Object.defineProperty(exports,"DEFAULT_FIELD_SHADING",{enumerable:true,get:function(){return chunkXMJKFURD_cjs.n}});Object.defineProperty(exports,"collectPageChangeBars",{enumerable:true,get:function(){return chunkXMJKFURD_cjs.h}});Object.defineProperty(exports,"lumTransfer",{enumerable:true,get:function(){return chunkXMJKFURD_cjs.i}});Object.defineProperty(exports,"paintSelectionOverlay",{enumerable:true,get:function(){return chunkXMJKFURD_cjs.s}});Object.defineProperty(exports,"paintSemanticLayout",{enumerable:true,get:function(){return chunkXMJKFURD_cjs.q}});
+'use strict';var chunkLI42N7OW_cjs=require('./chunk-LI42N7OW.cjs');require('./chunk-SZURLHR3.cjs'),require('./chunk-2DEY5NUC.cjs'),require('./chunk-DYUVJNDD.cjs'),require('./chunk-ZDFJW5XS.cjs'),require('./chunk-KE6ZWRIY.cjs');Object.defineProperty(exports,"DEFAULT_FIELD_SHADING",{enumerable:true,get:function(){return chunkLI42N7OW_cjs.p}});Object.defineProperty(exports,"collectPageChangeBars",{enumerable:true,get:function(){return chunkLI42N7OW_cjs.j}});Object.defineProperty(exports,"lumTransfer",{enumerable:true,get:function(){return chunkLI42N7OW_cjs.k}});Object.defineProperty(exports,"observeUnsupportedElements",{enumerable:true,get:function(){return chunkLI42N7OW_cjs.a}});Object.defineProperty(exports,"paintSelectionOverlay",{enumerable:true,get:function(){return chunkLI42N7OW_cjs.u}});Object.defineProperty(exports,"paintSemanticLayout",{enumerable:true,get:function(){return chunkLI42N7OW_cjs.s}});

package/dist/output.d.ts

@@ -8,13 +8,17 @@
  * @packageDocumentation
  * @public
  */
-import { R as ReviewAuthorInfo } from './semantic-paint-DLzA8sjP.js';
-export { B as BreakMarkStrings, C as ChangeBarsMode, D as DEFAULT_FIELD_SHADING, F as FieldShadingMode, P as PageChangeBars, a as PaintOptions, b as RevisionAuthorAssignments, c as RevisionAuthorStyle, d as RevisionStyles, e as collectPageChangeBars, p as paintSemanticLayout } from './semantic-paint-DLzA8sjP.js';
-import { S as SemanticLayout } from './semantic-records-B-akgRch.js';
-import './semantic-record-queries-3yp9o11g.js';
-import './types-barrel-CkF2JbU4.js';
-import './editor-scope-C7ke1KJG.js';
-import './omml-equation-BsLAa2lX.js';
+import { R as ReviewAuthorInfo } from './semantic-paint-B5JcIv9c.js';
+export { B as BreakMarkStrings, C as ChangeBarsMode, D as DEFAULT_FIELD_SHADING, F as FieldShadingMode, P as PageChangeBars, d as PaintOptions, a as RevisionAuthorAssignments, b as RevisionAuthorStyle, c as RevisionStyles, e as collectPageChangeBars, p as paintSemanticLayout } from './semantic-paint-B5JcIv9c.js';
+import { S as SemanticLayout } from './semantic-records-DoK0lNjS.js';
+export { U as UnsupportedElement, e as UnsupportedElementLayout, f as UnsupportedElementRule } from './semantic-records-DoK0lNjS.js';
+export { U as UnsupportedElementHost, o as observeUnsupportedElements } from './unsupported-elements-CUojsaCr.js';
+export { D as DrawingGraphicKind, a as DrawingSupport, b as DrawingSupportIssue } from './drawing-graphic-kind-CXYGYbB3.js';
+import './revision-projection-OVusTS77.js';
+import './tree-op-types-Df4oY2u4.js';
+import './editor-scope-CA6egMaK.js';
+import './semantic-record-queries-DnO8J5_j.js';
+import './tree-package-store-DXhX1PE-.js';
 
 /** A rectangle in page-content coordinates, on a named page. */
 interface OverlayRect {

package/dist/output.js

@@ -1 +1 @@
-export{n as DEFAULT_FIELD_SHADING,h as collectPageChangeBars,i as lumTransfer,s as paintSelectionOverlay,q as paintSemanticLayout}from'./chunk-LZY6B6IV.js';import'./chunk-FNNOJNGY.js';import'./chunk-RIYSCEFQ.js';import'./chunk-4S24UOPG.js';import'./chunk-VWIJKH4A.js';import'./chunk-Q5K2GGNG.js';import'./chunk-T2QQHG5C.js';
+export{p as DEFAULT_FIELD_SHADING,j as collectPageChangeBars,k as lumTransfer,a as observeUnsupportedElements,u as paintSelectionOverlay,s as paintSemanticLayout}from'./chunk-23MKR33J.js';import'./chunk-SVM6PGMS.js';import'./chunk-RIYSCEFQ.js';import'./chunk-CM5VZRBV.js';import'./chunk-PLKDS4JT.js';import'./chunk-JNGLSBPH.js';import'./chunk-AU33YWEJ.js';

package/dist/{protocol-COZJUKUY.d.ts → protocol-Cp_QzVxS.d.ts}

@@ -1,5 +1,5 @@
-import { aF as AutomationTableMutation, ac as RevisionBatchResult, ab as RevisionAuthorResult } from './types-barrel-CkF2JbU4.js';
-import { c as HeaderFooterVariant, N as NoteKind } from './tree-package-store-B8l8DX3Z.js';
+import { aB as AutomationTableMutation, Q as RevisionBatchResult, K as RevisionAuthorResult } from './tree-op-types-Df4oY2u4.js';
+import { H as HeaderFooterVariant, N as NoteKind } from './tree-package-store-DXhX1PE-.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`).
  *
@@ -1740,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-C_QbCKcH.d.ts → review-paragraph-order-BJQ43_r0.d.ts}

@@ -1,4 +1,4 @@
-import { N as OoxmlNode, ap as OoxmlElement, aq as OoxmlContentControlNode, V as OoxmlGenericElementNode, ar as OoxmlContentControlContentNode, C as CommentRecord, O as OoxmlPart } from './types-barrel-CkF2JbU4.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-Df4oY2u4.js';
 
 /** Nested content-control wrappers deeper than this stop flattening; content stays preserved. */
 declare const MAX_CONTENT_CONTROL_NESTING = 32;

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

@@ -0,0 +1,258 @@
+import { a4 as OoxmlNode } from './tree-op-types-Df4oY2u4.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-Cub9FDa8.d.ts → semantic-cell-selection-CoI5hHBm.d.ts}

@@ -1,5 +1,5 @@
-import { S as SemanticPosition, C as CaretGeometry, a as SemanticSelection } from './semantic-interaction-dApRIYpt.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-B-akgRch.js';
+import { S as SemanticPosition, C as CaretGeometry, a as SemanticSelection } from './semantic-interaction-BbA4dgEo.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-DoK0lNjS.js';
 
 /** A point in the coordinate space named by the function taking it. */
 interface HitPoint {

package/dist/{semantic-interaction-dApRIYpt.d.ts → semantic-interaction-BbA4dgEo.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-B-akgRch.js';
+import { T as TextMeasurer, S as SemanticLayout, B as BlockFragmentRecord, C as ContentControlBoundaryRecord, g as StyleSpanRecord } from './semantic-records-DoK0lNjS.js';
 
 /** How `moveCaret` resolves a motion. */
 interface MoveCaretOptions {

package/dist/{semantic-paint-DLzA8sjP.d.ts → semantic-paint-B5JcIv9c.d.ts}

@@ -1,6 +1,7 @@
-import { c as PageRecord, q as ResolvedRevisionMarkup, C as ContentControlBoundaryRecord, S as SemanticLayout } from './semantic-records-B-akgRch.js';
-import { S as SemanticRootStoryKind } from './semantic-record-queries-3yp9o11g.js';
-import { aj as ValidatedImageBytesHandle, aa as RenderableImageMime } from './types-barrel-CkF2JbU4.js';
+import { d as ResolvedRevisionMarkup } from './revision-projection-OVusTS77.js';
+import { ap as ValidatedImageBytesHandle, al as RenderableImageMime, av as OoxmlElement } from './tree-op-types-Df4oY2u4.js';
+import { a as PageRecord, C as ContentControlBoundaryRecord, S as SemanticLayout } from './semantic-records-DoK0lNjS.js';
+import { S as SemanticRootStoryKind } from './semantic-record-queries-DnO8J5_j.js';
 
 /**
  * Everything a host can say about ONE author's presentation. Every field is optional and
@@ -118,14 +119,14 @@ interface RevisionStyleContext {
     readonly key: string;
 }
 
-/** Host port for safe blob URLs — only called for {@link ImageResourceState.kind} `ready`. */
-interface PaintImageUrlPort {
-    create(handle: ValidatedImageBytesHandle, mime: RenderableImageMime): string;
-    revoke(url: string): void;
-}
 /** Localized refusal labels; adapters supply i18n-backed implementations. */
 interface DrawingPaintStrings {
     readonly unsupportedFormat: (format: string) => string;
+    /**
+     * The whole label of a placeholder for a graphic that is not a picture. `kind` is a
+     * `DrawingPlaceholderKind` (`chart`, `diagram`, `shape`, `group`, `textbox`, `canvas` or
+     * `graphic`); the label names that kind, so a chart reads as a chart that is not shown.
+     */
     readonly nonPictureGraphic: (kind: string) => string;
     readonly missingResource: string;
     readonly externalResource: string;
@@ -136,6 +137,12 @@ interface DrawingPaintStrings {
     readonly pendingResource: string;
 }
 
+/** Host port for safe blob URLs — only called for {@link ImageResourceState.kind} `ready`. */
+interface PaintImageUrlPort {
+    create(handle: ValidatedImageBytesHandle, mime: RenderableImageMime): string;
+    revoke(url: string): void;
+}
+
 /** Localized break labels; adapters supply i18n-backed implementations. */
 interface BreakMarkStrings {
     readonly pageBreak: string;
@@ -199,6 +206,9 @@ 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 includePartial?: boolean;
+    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 +345,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-3yp9o11g.d.ts → semantic-record-queries-DnO8J5_j.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-B-akgRch.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-DoK0lNjS.js';
 
 /**
  * Depth-first paragraph fragments of one page, in reading order.