@notectl/core 2.1.2 → 2.1.3

package/dist/plugins/toolbar/ToolbarRenderers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolbarRenderers.d.ts","sourceRoot":"","sources":["../../../src/plugins/toolbar/ToolbarRenderers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAI3E;;;GAGG;AACH,wBAAgB,gBAAgB,CAC/B,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,MAAM,IAAI,EACnB,MAAM,GAAE,aAAiC,GACvC,IAAI,CA4DN;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAO5F;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC7B,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,cAAc,EACtB,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EACzC,OAAO,EAAE,MAAM,IAAI,GACjB,IAAI,CAmCN;AAED,iDAAiD;AACjD,wBAAgB,eAAe,IAAI,eAAe,CAKjD"}
+{"version":3,"file":"ToolbarRenderers.d.ts","sourceRoot":"","sources":["../../../src/plugins/toolbar/ToolbarRenderers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAI3E;;;GAGG;AACH,wBAAgB,gBAAgB,CAC/B,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,MAAM,IAAI,EACnB,MAAM,GAAE,aAAiC,GACvC,IAAI,CA4DN;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAO5F;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC7B,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,cAAc,EACtB,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EACzC,OAAO,EAAE,MAAM,IAAI,GACjB,IAAI,CAmCN;AAED,iDAAiD;AACjD,wBAAgB,eAAe,IAAI,eAAe,CAMjD"}

package/dist/plugins/toolbar/index.d.ts

@@ -1,4 +1,4 @@
-export { ToolbarPlugin, ToolbarServiceKey, type ToolbarServiceAPI, type ToolbarLayoutConfig, } from './ToolbarPlugin.js';
+export { ToolbarPlugin, ToolbarServiceKey, type ToolbarServiceAPI, type ToolbarLayoutConfig, type ToolbarGroupConfig, } from './ToolbarPlugin.js';
 export type { ToolbarItem, ToolbarItemCombobox, ToolbarGroup, PopupType, GridPickerConfig, DropdownConfig, } from './ToolbarItem.js';
 export { ToolbarOverflowBehavior } from './ToolbarOverflowBehavior.js';
 export { ToolbarRegistry } from './ToolbarRegistry.js';

package/dist/plugins/toolbar/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/toolbar/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,aAAa,EACb,iBAAiB,EACjB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,GACxB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACX,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,cAAc,GACd,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEvE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EACN,iBAAiB,EACjB,iBAAiB,GACjB,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/toolbar/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,aAAa,EACb,iBAAiB,EACjB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GACvB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACX,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,cAAc,GACd,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEvE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EACN,iBAAiB,EACjB,iBAAiB,GACjB,MAAM,oBAAoB,CAAC"}

package/dist/plugins/toolbar.mjs

@@ -1 +1 @@
-import{a,i as s,n as o,o as r,r as i,t as m}from"../chunks/ToolbarPlugin-DeH8n5d2.mjs";export{s as TOOLBAR_LOCALE_EN,i as ToolbarOverflowBehavior,m as ToolbarPlugin,r as ToolbarRegistry,o as ToolbarServiceKey,a as loadToolbarLocale};
+import{a,i as s,n as o,o as r,r as n,t as i}from"../chunks/ToolbarPlugin-D5_-gWmH.mjs";export{s as TOOLBAR_LOCALE_EN,n as ToolbarOverflowBehavior,i as ToolbarPlugin,r as ToolbarRegistry,o as ToolbarServiceKey,a as loadToolbarLocale};

package/dist/presets/full.mjs

@@ -1 +1 @@
-import{t as m}from"../chunks/full-5hGvv-bG.mjs";export{m as createFullPreset};
+import{t as m}from"../chunks/full-yocxIDB8.mjs";export{m as createFullPreset};

package/dist/presets/minimal.mjs

@@ -1 +1 @@
-import{t as m}from"../chunks/minimal-pBhi4EJI.mjs";export{m as createMinimalPreset};
+import{t as m}from"../chunks/minimal-BL3kgYy-.mjs";export{m as createMinimalPreset};

package/dist/presets.mjs

@@ -1 +1 @@
-import{t as m}from"./chunks/minimal-pBhi4EJI.mjs";import{t as s}from"./chunks/full-5hGvv-bG.mjs";export{s as createFullPreset,m as createMinimalPreset};
+import{t as m}from"./chunks/minimal-BL3kgYy-.mjs";import{t as s}from"./chunks/full-yocxIDB8.mjs";export{s as createFullPreset,m as createMinimalPreset};

package/dist/state/History.d.ts

@@ -1,4 +1,5 @@
 import { EditorState } from './EditorState.js';
+import { Mapping } from './Mapping.js';
 import { Transaction } from './Transaction.js';
 export interface HistoryResult {
     readonly state: EditorState;
@@ -17,8 +18,27 @@ export declare class HistoryManager {
     /**
      * Pushes a transaction onto the undo stack.
      * Groups consecutive input transactions within the timeout window.
+     *
+     * Pushed transactions never propagate their mapping onto older groups'
+     * {@link interveningMapping}: linear undo pops newer groups before older
+     * ones, reverting their effects first, so by the time an older group is
+     * undone the newer ones' forward maps no longer reflect document state.
+     * Out-of-band edits that the caller does NOT want undoable should use
+     * {@link recordIntervening} instead.
      */
     push(tr: Transaction): void;
+    /**
+     * Records an out-of-band transaction's mapping so subsequent undos *and*
+     * redos fold their steps and restored selection through it. Use for
+     * transactions applied to the editor without going through {@link push}
+     * (e.g. collaboration or agent updates that the user is not supposed to
+     * undo / redo). Empty mappings are a no-op.
+     *
+     * Propagates to **both** stacks so a `undo → intervening → redo` flow
+     * is safe: the redo group's steps get rebased through the new mapping
+     * just as the undo group's would have.
+     */
+    recordIntervening(mapping: Mapping): void;
     /** Undoes the last group and returns the new state with transaction, or null if nothing to undo. */
     undo(state: EditorState): HistoryResult | null;
     /** Redoes the last undone group and returns the new state with transaction, or null if nothing to redo. */

package/dist/state/History.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"History.d.ts","sourceRoot":"","sources":["../../src/state/History.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAQ,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG1D,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;CAClC;AAUD,qBAAa,cAAc;IAC1B,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,UAAU,CAAuB;gBAE7B,OAAO,CAAC,EAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE;IAKpE;;;OAGG;IACH,IAAI,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IA6C3B,oGAAoG;IACpG,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,GAAG,IAAI;IAmC9C,2GAA2G;IAC3G,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,GAAG,IAAI;IAgC9C,iDAAiD;IACjD,OAAO,IAAI,OAAO;IAIlB,iDAAiD;IACjD,OAAO,IAAI,OAAO;IAIlB,0BAA0B;IAC1B,KAAK,IAAI,IAAI;IAMb;;;OAGG;IACH,OAAO,CAAC,eAAe;CAUvB"}
+{"version":3,"file":"History.d.ts","sourceRoot":"","sources":["../../src/state/History.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,OAAO,EAA8C,MAAM,cAAc,CAAC;AAInF,OAAO,KAAK,EAAQ,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE1D,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;CAClC;AAiBD,qBAAa,cAAc;IAC1B,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,UAAU,CAAuB;gBAE7B,OAAO,CAAC,EAAE;QAAE,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE;IAKpE;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IA2C3B;;;;;;;;;;OAUG;IACH,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAMzC,oGAAoG;IACpG,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,GAAG,IAAI;IAuB9C,2GAA2G;IAC3G,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,GAAG,IAAI;IAmB9C,iDAAiD;IACjD,OAAO,IAAI,OAAO;IAIlB,iDAAiD;IACjD,OAAO,IAAI,OAAO;IAIlB,0BAA0B;IAC1B,KAAK,IAAI,IAAI;IAMb;;;OAGG;IACH,OAAO,CAAC,eAAe;CASvB"}

package/dist/state/InlineContentOps.d.ts

@@ -1,4 +1,5 @@
 import { ChildNode, InlineNode, Mark, TextNode, TextSegment } from '../model/Document.js';
+import { MarkTypeName } from '../model/TypeBrands.js';
 /**
  * Inserts text into mixed inline content at the given offset.
  * Handles both TextNode and InlineNode children.
@@ -23,6 +24,35 @@ export declare function sliceInlineContent(nodes: readonly (TextNode | InlineNod
  * InlineNodes are passed through unchanged (marks only apply to text).
  */
 export declare function applyMarkToInlineContent(nodes: readonly (TextNode | InlineNode)[], from: number, to: number, mark: Mark, add: boolean): (TextNode | InlineNode)[];
+/**
+ * Maximal sub-ranges within [from, to) where no text node carries a mark
+ * of type `markType`. InlineNodes are inert: they pass through and do not
+ * break coalescing, but a range never starts on an InlineNode.
+ *
+ * Used by `TransactionBuilder.addMark` to emit `AddMarkStep`s only over
+ * sub-ranges that actually lack the mark, so the symmetric inverse
+ * preserves any marks that pre-existed.
+ */
+export declare function findRangesMissingMark(nodes: readonly (TextNode | InlineNode)[], from: number, to: number, markType: MarkTypeName): readonly {
+    readonly from: number;
+    readonly to: number;
+}[];
+/**
+ * Maximal sub-ranges within [from, to) where every text node carries a mark
+ * of type `markType`. Each range is paired with the actual mark from the
+ * document (including attrs). Adjacent sub-ranges coalesce only when their
+ * marks are `marksEqual`. InlineNodes are inert: they pass through and do
+ * not break coalescing, but a range never starts on an InlineNode.
+ *
+ * Used by `TransactionBuilder.removeMark` to emit `RemoveMarkStep`s whose
+ * `mark` reflects the actual document content, so the symmetric inverse
+ * restores attrs faithfully.
+ */
+export declare function findRangesWithMark(nodes: readonly (TextNode | InlineNode)[], from: number, to: number, markType: MarkTypeName): readonly {
+    readonly from: number;
+    readonly to: number;
+    readonly mark: Mark;
+}[];
 /** Inserts an InlineNode at the given offset in mixed inline content. */
 export declare function insertInlineNodeAtOffset(nodes: readonly (TextNode | InlineNode)[], offset: number, inlineNode: InlineNode): (TextNode | InlineNode)[];
 /** Removes the InlineNode at the given offset from mixed inline content. */

package/dist/state/InlineContentOps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InlineContentOps.d.ts","sourceRoot":"","sources":["../../src/state/InlineContentOps.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,IAAI,EACT,KAAK,QAAQ,EACb,KAAK,WAAW,EAMhB,MAAM,sBAAsB,CAAC;AAE9B;;;GAGG;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,EACzC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,IAAI,EAAE,GACpB,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,CAE3B;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAC9C,KAAK,EAAE,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,EACzC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,SAAS,WAAW,EAAE,GAC9B,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,CAI3B;AAgDD;;;GAGG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,EACzC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACR,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,CAgC3B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,EACzC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACR,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,CAmC3B;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,EACzC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,OAAO,GACV,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,CA0C3B;AAED,yEAAyE;AACzE,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,EACzC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACpB,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,CAuC3B;AAED,4EAA4E;AAC5E,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,EACzC,MAAM,EAAE,MAAM,GACZ,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,CAiB3B;AAED,+DAA+D;AAC/D,wBAAgB,0BAA0B,CACzC,KAAK,EAAE,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,EACzC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,GACxD,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,CAmB3B;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACpC,QAAQ,EAAE,SAAS,SAAS,EAAE,EAC9B,iBAAiB,EAAE,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC,EAAE,GACnD,SAAS,SAAS,EAAE,CAQtB"}
+{"version":3,"file":"InlineContentOps.d.ts","sourceRoot":"","sources":["../../src/state/InlineContentOps.ts"],"names":[],"mappings":"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"}

package/dist/state/Mapping.d.ts

@@ -0,0 +1,261 @@
+import { BlockNode } from '../model/Document.js';
+import { Position } from '../model/Selection.js';
+import { BlockId } from '../model/TypeBrands.js';
+/**
+ * Result of mapping an `(blockId, [from, to))` range through a {@link Mapping}.
+ *
+ * Both endpoints are guaranteed to live in the same block. Callers can rely
+ * on `from <= to` (the helper returns `null` rather than producing an
+ * inverted range).
+ */
+export interface MappedInBlockRange {
+    readonly blockId: BlockId;
+    readonly from: number;
+    readonly to: number;
+}
+/** Position-mapping bias at a boundary. */
+export type Assoc = -1 | 1;
+/** No-op map: positions pass through unchanged. */
+export interface IdentityMap {
+    readonly type: 'identity';
+}
+/**
+ * Within `blockId`, the offset range `[from, to)` is replaced with content
+ * of length `newLen`. Covers all in-block content edits with a single
+ * primitive:
+ *
+ * - `insertText(blockId, off, text)` → `{from: off, to: off, newLen: text.length}`.
+ * - `deleteText(blockId, f, t)`      → `{from: f,   to: t,   newLen: 0}`.
+ * - `insertInlineNode(blockId, off)` → `{from: off, to: off, newLen: 1}`.
+ * - `removeInlineNode(blockId, off)` → `{from: off, to: off + 1, newLen: 0}`.
+ */
+export interface ShiftMap {
+    readonly type: 'shift';
+    readonly blockId: BlockId;
+    readonly from: number;
+    readonly to: number;
+    readonly newLen: number;
+}
+/**
+ * A block is split at `offset`. Content `[0, offset)` stays in `blockId`;
+ * content `[offset, length)` migrates to `newBlockId` rebased to start at 0.
+ */
+export interface SplitMap {
+    readonly type: 'split';
+    readonly blockId: BlockId;
+    readonly offset: number;
+    readonly newBlockId: BlockId;
+}
+/**
+ * `sourceBlockId` is appended to `targetBlockId`. Positions in the source
+ * block migrate to the target block with offset shifted by
+ * `targetLengthBefore` (the target's length before the merge).
+ */
+export interface MergeMap {
+    readonly type: 'merge';
+    readonly targetBlockId: BlockId;
+    readonly sourceBlockId: BlockId;
+    readonly targetLengthBefore: number;
+}
+/**
+ * A block subtree is removed from the document. Positions whose `blockId`
+ * is in `removedBlockIds` are marked deleted; `removedBlockIds` covers the
+ * removed root **plus all descendant block IDs** (see
+ * {@link collectRemovedBlockIds}).
+ *
+ * `parentPath` and `index` carry the removal's structural coordinates so
+ * sibling child-indices in the same parent can be rebased: any
+ * `(parentPath, i)` with `i === index` becomes invalid (the block is gone),
+ * and `i > index` shifts down by one. See {@link mapChildIndex}.
+ */
+export interface BlockRemovalMap {
+    readonly type: 'blockRemoval';
+    readonly removedBlockIds: ReadonlySet<BlockId>;
+    readonly parentPath: readonly BlockId[];
+    readonly index: number;
+}
+/**
+ * A new block was inserted at `fromIndex` in `parentPath`'s child list.
+ * Sibling child-indices `≥ fromIndex` shift up by `delta` (always `+1`
+ * since {@link InsertNodeStep} inserts a single block). Position space
+ * (`{blockId, offset}`) is unaffected — the new block has no prior
+ * positions, and positions inside other siblings keep their offsets.
+ *
+ * Only consumed by {@link mapChildIndex}.
+ */
+export interface ChildIndexShiftMap {
+    readonly type: 'childIndexShift';
+    readonly parentPath: readonly BlockId[];
+    readonly fromIndex: number;
+    readonly delta: number;
+}
+/** Discriminated union of all StepMap variants. */
+export type StepMap = IdentityMap | ShiftMap | SplitMap | MergeMap | BlockRemovalMap | ChildIndexShiftMap;
+/** Result of mapping a single position. */
+export interface MapResult {
+    readonly pos: Position;
+    /** True if the input position fell inside content removed by the map. */
+    readonly deleted: boolean;
+}
+/** A range expressed in `Position` space. */
+export interface PositionRange {
+    readonly from: Position;
+    readonly to: Position;
+}
+/** The shared identity StepMap; reuse instead of allocating per step. */
+export declare const IDENTITY_MAP: IdentityMap;
+/**
+ * Walks a block subtree and returns the set of its own ID plus every
+ * descendant block ID. Used to build {@link BlockRemovalMap.removedBlockIds}.
+ */
+export declare function collectRemovedBlockIds(node: BlockNode): Set<BlockId>;
+/**
+ * Maps a single position through one {@link StepMap}.
+ *
+ * @param pos input position
+ * @param map the StepMap describing the change
+ * @param assoc which side of a boundary to stick to (default `-1`)
+ * @returns mapped position plus a `deleted` flag indicating whether `pos`
+ *          fell inside content that the step removed
+ */
+export declare function mapPositionThroughStep(pos: Position, map: StepMap, assoc?: Assoc): MapResult;
+/**
+ * Composes a sequence of {@link StepMap}s into a single mapper. A `Mapping`
+ * is immutable; `appendMap` returns a new instance.
+ *
+ * Construction always normalizes by dropping identity maps — they're a
+ * common case and would otherwise inflate every transaction's mapping
+ * pipeline with no-ops.
+ */
+export declare class Mapping {
+    /** Shared empty Mapping. */
+    static readonly empty: Mapping;
+    readonly maps: readonly StepMap[];
+    private constructor();
+    /** Creates a Mapping from a list of StepMaps, dropping identity maps. */
+    static from(maps: readonly StepMap[]): Mapping;
+    /** Returns a new Mapping with `map` appended. */
+    appendMap(map: StepMap): Mapping;
+    /** Concatenates two mappings into a new one. */
+    appendMapping(other: Mapping): Mapping;
+    /** True if the mapping contains no position-changing maps. */
+    get isEmpty(): boolean;
+    /**
+     * Folds a position through every contained StepMap in order.
+     * Returns the mapped position; the `deleted` flag is **not** preserved
+     * (use {@link mapResult} when you need it).
+     */
+    map(pos: Position, assoc?: Assoc): Position;
+    /**
+     * Like {@link map}, but returns whether the position landed in deleted
+     * content at any step. Once a position is marked deleted, the flag is
+     * sticky — subsequent steps do not "un-delete" it.
+     */
+    mapResult(pos: Position, assoc?: Assoc): MapResult;
+    /**
+     * Maps a range. By convention, `from` is mapped with `assoc = -1`
+     * (inclusive-start) and `to` with `assoc = +1` (exclusive-end). The
+     * caller may override either bias.
+     *
+     * Returns `null` when both endpoints land in deleted content **and** the
+     * mapped range would collapse to length zero or negative — i.e. the
+     * range no longer covers any live content.
+     *
+     * The returned `from`/`to` may live in different blocks (e.g. after a
+     * `split` map). Callers that require an in-block range (decorations,
+     * inline selections) must detect and split accordingly.
+     */
+    mapRange(range: PositionRange, assocFrom?: Assoc, assocTo?: Assoc): PositionRange | null;
+}
+/**
+ * Maps an `(blockId, [from, to))` range through `mapping`, asserting the
+ * result lives in a single block.
+ *
+ * Returns `null` when the range no longer addresses live content in a single
+ * block:
+ *
+ * - the host block was removed;
+ * - the range was fully deleted (both endpoints flagged deleted and collapse);
+ * - the endpoints migrated to different blocks (range fragmented, e.g. a
+ *   `split` map placed `from` and `to` on opposite sides of the cut).
+ *
+ * Default biases are **conservative for step rebasing**: `assocFrom = +1`,
+ * `assocTo = -1`. An intervening insertion at either boundary therefore
+ * does NOT expand the rebased range to cover the new content — the user's
+ * original edit only addressed the original content, and the agent's
+ * intervening insertion should be preserved across an undo/redo. This is
+ * the opposite of {@link Mapping.mapRange}'s default biases, which model
+ * selections (inclusive-start, exclusive-end) where boundary insertions
+ * naturally extend the selection.
+ */
+export declare function mapInBlockRange(blockId: BlockId, from: number, to: number, mapping: Mapping, assocFrom?: Assoc, assocTo?: Assoc): MappedInBlockRange | null;
+/**
+ * Maps an `(blockId, offset)` point through `mapping`, returning the
+ * equivalent in-block position or `null` when the host block was removed.
+ *
+ * Convenience wrapper around {@link mapInBlockRange} for steps that carry a
+ * single offset (`insertText`, `insertInlineNode`, `splitBlock`).
+ */
+export declare function mapOffsetInBlock(blockId: BlockId, offset: number, mapping: Mapping, assoc?: Assoc): MappedInBlockRange | null;
+/**
+ * Rebases a child-index `(parentPath, index)` through `mapping`. The
+ * `index` is interpreted as the position of an **existing** child block:
+ * if an intervening edit removed exactly that child, the result is
+ * `null`. For an **insertion slot** (the target index of a future
+ * `insertNode`), use {@link mapInsertionIndex} — slots stay valid even
+ * when the block previously at that index is removed.
+ *
+ * Child-indices live in a coordinate space orthogonal to positions
+ * (`{blockId, offset}`): they describe a slot in a parent's child list,
+ * not a place inside text. Only two {@link StepMap} categories carry
+ * child-index-affecting information:
+ *
+ * - {@link ChildIndexShiftMap} (produced by `insertNode`): shifts
+ *   sibling indices `≥ fromIndex` by `delta` (always `+1` today).
+ * - {@link BlockRemovalMap} (produced by `removeNode`): removes the child
+ *   at `index` (the input index becomes invalid → `null`), and shifts
+ *   sibling indices `> index` down by `1`.
+ *
+ * Maps whose `parentPath` differs from the input pass through; all
+ * non-structural categories (`shift`, `split`, `merge`, `identity`) are
+ * no-ops here.
+ */
+export declare function mapChildIndex(parentPath: readonly BlockId[], index: number, mapping: Mapping): number | null;
+/**
+ * Rebases an **insertion slot** `(parentPath, index)` through `mapping`.
+ * An insertion slot lives in `[0, children.length]` (inclusive of the
+ * end) and represents "where to insert", not an existing block. Slots
+ * remain valid across intervening edits — even when the block previously
+ * at that index is removed — so this function never returns `null`.
+ *
+ * Difference from {@link mapChildIndex}: for a `BlockRemovalMap` with
+ * matching parent and `index === map.index`, this function keeps the
+ * slot (returning `map.index`, which is the same numeric position in the
+ * post-removal frame); {@link mapChildIndex} would return `null`.
+ * {@link ChildIndexShiftMap} handling is identical.
+ */
+export declare function mapInsertionIndex(parentPath: readonly BlockId[], index: number, mapping: Mapping): number;
+/**
+ * Returns the {@link StepMap} that undoes `map` in position space — i.e.
+ * composing `map` with `invertStepMap(map)` is content-preserving (though
+ * the composed position-mapping is *not* a true identity in our framework:
+ * positions interior to a delete-then-reinsert round-trip clamp to the
+ * deletion start during the deletion half and don't return on the insert
+ * half).
+ *
+ * Used by history to detect mutually-inverse stepmaps in the rebase chain
+ * and cancel them, sidestepping the round-trip clamping for cases where
+ * the rebase is a no-op in content terms.
+ *
+ * `BlockRemovalMap`'s inverse is {@link IDENTITY_MAP}: re-inserting a
+ * removed block subtree does not shift positions in *other* blocks, so the
+ * inverse direction is invisible to position-mapping. Callers that need to
+ * re-validate "did the block come back" must check the document instead.
+ */
+export declare function invertStepMap(map: StepMap): StepMap;
+/**
+ * Structural equality for {@link StepMap}s. Used by history to recognize
+ * cancelling pairs in the rebase chain ({@link invertStepMap}(a) ≡ b).
+ */
+export declare function stepMapsEqual(a: StepMap, b: StepMap): boolean;
+//# sourceMappingURL=Mapping.d.ts.map

package/dist/state/Mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mapping.d.ts","sourceRoot":"","sources":["../../src/state/Mapping.ts"],"names":[],"mappings":"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"}

package/dist/state/SelectionMapping.d.ts

@@ -0,0 +1,25 @@
+import { EditorSelection, Selection } from '../model/Selection.js';
+import { Mapping } from './Mapping.js';
+/**
+ * Maps a generic {@link EditorSelection} through a {@link Mapping}.
+ *
+ * @returns the mapped selection, or `null` if the selection became
+ *          structurally invalid (node-selection's node disappeared, or
+ *          gap-cursor's host block disappeared) and the caller must fall
+ *          back. For ordinary text selections this never returns `null` —
+ *          positions clamp to the start of removed content as part of
+ *          {@link Mapping.map}.
+ */
+export declare function mapSelection(sel: EditorSelection, mapping: Mapping): EditorSelection | null;
+/**
+ * Maps a text selection. For non-collapsed selections, anchor uses
+ * `assoc=-1` (sticky-left, inclusive-start) and head uses `assoc=+1`
+ * (sticky-right, exclusive-end). For *collapsed* selections (a cursor),
+ * both endpoints use the same `assoc=-1` so the cursor stays collapsed
+ * rather than being torn across a split boundary into two different
+ * blocks.
+ *
+ * Reference equality is preserved when neither endpoint moved.
+ */
+export declare function mapTextSelection(sel: Selection, mapping: Mapping): Selection;
+//# sourceMappingURL=SelectionMapping.d.ts.map

package/dist/state/SelectionMapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionMapping.d.ts","sourceRoot":"","sources":["../../src/state/SelectionMapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EACX,eAAe,EAIf,SAAS,EACT,MAAM,uBAAuB,CAAC;AAU/B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO,GAAG,eAAe,GAAG,IAAI,CAK3F;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,SAAS,CAU5E"}

package/dist/state/StepApplication.d.ts

@@ -1,5 +1,22 @@
 import { Document } from '../model/Document.js';
-import { Step } from './Transaction.js';
-/** Applies a single step to a document and returns the new document. */
-export declare function applyStep(doc: Document, step: Step): Document;
+import { AddMarkStep, DeleteTextStep, InsertInlineNodeStep, InsertNodeStep, InsertTextStep, MergeBlocksStep, RemoveInlineNodeStep, RemoveMarkStep, RemoveNodeStep, SetBlockTypeStep, SetInlineNodeAttrStep, SetNodeAttrStep, SplitBlockStep } from './Transaction.js';
+export declare function applyInsertText(doc: Document, step: InsertTextStep): Document;
+export declare function applyDeleteText(doc: Document, step: DeleteTextStep): Document;
+export declare function applySplitBlock(doc: Document, step: SplitBlockStep): Document;
+export declare function applyMergeBlocks(doc: Document, step: MergeBlocksStep): Document;
+export declare function applyAddMark(doc: Document, step: AddMarkStep): Document;
+export declare function applyRemoveMark(doc: Document, step: RemoveMarkStep): Document;
+/**
+ * Stored marks live on EditorState, not on the Document, so applying this
+ * step at the document level is a no-op. The state-level update happens in
+ * `EditorState.apply()`.
+ */
+export declare function applySetStoredMarks(doc: Document): Document;
+export declare function applyInsertInlineNode(doc: Document, step: InsertInlineNodeStep): Document;
+export declare function applyRemoveInlineNode(doc: Document, step: RemoveInlineNodeStep): Document;
+export declare function applySetInlineNodeAttr(doc: Document, step: SetInlineNodeAttrStep): Document;
+export declare function applySetBlockType(doc: Document, step: SetBlockTypeStep): Document;
+export declare function applyInsertNode(doc: Document, step: InsertNodeStep): Document;
+export declare function applyRemoveNode(doc: Document, step: RemoveNodeStep): Document;
+export declare function applySetNodeAttr(doc: Document, step: SetNodeAttrStep): Document;
 //# sourceMappingURL=StepApplication.d.ts.map

package/dist/state/StepApplication.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StepApplication.d.ts","sourceRoot":"","sources":["../../src/state/StepApplication.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGN,KAAK,QAAQ,EAQb,MAAM,sBAAsB,CAAC;AAa9B,OAAO,KAAK,EAcX,IAAI,EACJ,MAAM,kBAAkB,CAAC;AAE1B,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,GAAG,QAAQ,CA+B7D"}
+{"version":3,"file":"StepApplication.d.ts","sourceRoot":"","sources":["../../src/state/StepApplication.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAIN,KAAK,QAAQ,EAQb,MAAM,sBAAsB,CAAC;AAc9B,OAAO,KAAK,EACX,WAAW,EACX,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,eAAe,EACf,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,MAAM,kBAAkB,CAAC;AAE1B,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,cAAc,GAAG,QAAQ,CAM7E;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,cAAc,GAAG,QAAQ,CAI7E;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,cAAc,GAAG,QAAQ,CAsD7E;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,eAAe,GAAG,QAAQ,CAoC/E;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,GAAG,QAAQ,CAIvE;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,cAAc,GAAG,QAAQ,CAI7E;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,QAAQ,GAAG,QAAQ,CAE3D;AAID,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,oBAAoB,GAAG,QAAQ,CAIzF;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,oBAAoB,GAAG,QAAQ,CAIzF;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,qBAAqB,GAAG,QAAQ,CAO3F;AAsBD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,gBAAgB,GAAG,QAAQ,CASjF;AAID,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,cAAc,GAAG,QAAQ,CAa7E;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,cAAc,GAAG,QAAQ,CAa7E;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,eAAe,GAAG,QAAQ,CAQ/E"}

package/dist/state/StepHandlers.d.ts

@@ -0,0 +1,68 @@
+import { Document } from '../model/Document.js';
+import { Mapping, StepMap } from './Mapping.js';
+import { Step } from './Steps.js';
+import { Transaction } from './Transaction.js';
+/**
+ * Forward, inverse, position-mapping, and step-rebase behavior of one step
+ * subtype, co-located so a new step type is one registry entry.
+ *
+ * - `apply` / `invert` / `getMap` cover the existing step pipeline.
+ * - `map` rebases the step itself through a {@link Mapping} describing
+ *   intervening changes; returns `null` when the step can no longer be
+ *   applied meaningfully (block removed, range fragmented, range fully
+ *   eaten). See {@link StepMapping.ts} for per-step semantics.
+ *
+ * `getMap` and `map` both receive the document at the step's "current"
+ * frame: `getMap` against the pre-apply doc, `map` against the doc that
+ * the rebased step will be applied to. The latter is needed to re-snapshot
+ * inverse-payload fields (`deletedText`, `previousAttrs`, etc.) so the
+ * rebased step inverts correctly on redo.
+ */
+export interface StepHandler<S extends Step> {
+    readonly apply: (doc: Document, step: S) => Document;
+    readonly invert: (step: S) => Step;
+    readonly getMap: (doc: Document, step: S) => StepMap;
+    readonly map: (step: S, mapping: Mapping, doc: Document) => Step | null;
+}
+/** Applies a single step to a document and returns the new document. */
+export declare function applyStep(doc: Document, step: Step): Document;
+/** Returns the inverse of a step, used for undo/redo. */
+export declare function invertStep(step: Step): Step;
+/**
+ * Returns the position-space {@link StepMap} for a step, computed against
+ * the document state **before** the step was applied.
+ */
+export declare function getStepMap(doc: Document, step: Step): StepMap;
+/**
+ * Rebases a step through a {@link Mapping} describing intervening edits in
+ * position space, returning either the rebased step or `null` when the
+ * step can no longer be applied meaningfully (block removed, range fully
+ * eaten, range fragmented across blocks, structural ancestor migrated).
+ *
+ * `doc` must be the document at the frame the rebased step will run
+ * against — `map` re-snapshots inverse-payload fields (`deletedText`,
+ * `previousAttrs`, …) from it so the rebased step inverts correctly on
+ * redo.
+ *
+ * Callers (e.g. {@link HistoryManager.undo}) treat a `null` as a signal to
+ * abandon the entire undo/redo group rather than apply a partial rebase
+ * that would silently corrupt the document.
+ */
+export declare function mapStep(step: Step, mapping: Mapping, doc: Document): Step | null;
+/**
+ * Inverts an entire transaction (reverses step order and swaps selections).
+ *
+ * The returned transaction's `mapping` is {@link Mapping.empty}: producing a
+ * faithful mapping for inverted steps requires the pre-apply document at
+ * each inverse step (e.g. `removeNode` needs to walk the subtree, which is
+ * only present in the forward step's payload, not its inverse). Callers
+ * that need a real mapping for the inverted transaction should accumulate
+ * step maps via {@link getStepMap} as they apply each inverse step.
+ *
+ * `forwardStepMaps` is set to identity placeholders for the same reason —
+ * the inverse-step forward effect is only computable against the document
+ * state at each inverse, which the caller (e.g. `HistoryManager.undo`)
+ * tracks while walking.
+ */
+export declare function invertTransaction(tr: Transaction): Transaction;
+//# sourceMappingURL=StepHandlers.d.ts.map

package/dist/state/StepHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepHandlers.d.ts","sourceRoot":"","sources":["../../src/state/StepHandlers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAgB,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAkEnE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,IAAI;IAC1C,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,KAAK,QAAQ,CAAC;IACrD,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IACrD,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI,CAAC;CACxE;AA4GD,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,GAAG,QAAQ,CAE7D;AAED,yDAAyD;AACzD,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAE3C;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAE7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAGhF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,WAAW,GAAG,WAAW,CAc9D"}

package/dist/state/StepInversion.d.ts

@@ -1,7 +1,24 @@
-import { Step } from './Steps.js';
+import { Mark } from '../model/Document.js';
+import { AddMarkStep, DeleteTextStep, InsertInlineNodeStep, InsertNodeStep, InsertTextStep, MergeBlocksStep, RemoveInlineNodeStep, RemoveMarkStep, RemoveNodeStep, SetBlockTypeStep, SetInlineNodeAttrStep, SetNodeAttrStep, SetStoredMarksStep, SplitBlockStep, Step } from './Steps.js';
 import { Transaction } from './Transaction.js';
-/** Inverts a single step for undo. */
-export declare function invertStep(step: Step): Step;
-/** Inverts an entire transaction (reverses step order and swaps selections). */
-export declare function invertTransaction(tr: Transaction): Transaction;
+export declare function invertInsertText(step: InsertTextStep): Step;
+export declare function invertDeleteText(step: DeleteTextStep): Step;
+export declare function invertSplitBlock(step: SplitBlockStep): Step;
+export declare function invertMergeBlocks(step: MergeBlocksStep): Step;
+export declare function invertAddMark(step: AddMarkStep): Step;
+export declare function invertRemoveMark(step: RemoveMarkStep): Step;
+export declare function invertSetStoredMarks(step: SetStoredMarksStep): Step;
+export declare function invertSetBlockType(step: SetBlockTypeStep): Step;
+export declare function invertInsertNode(step: InsertNodeStep): Step;
+export declare function invertRemoveNode(step: RemoveNodeStep): Step;
+export declare function invertSetNodeAttr(step: SetNodeAttrStep): Step;
+export declare function invertInsertInlineNode(step: InsertInlineNodeStep): Step;
+export declare function invertRemoveInlineNode(step: RemoveInlineNodeStep): Step;
+export declare function invertSetInlineNodeAttr(step: SetInlineNodeAttrStep): Step;
+/**
+ * Walks the transaction's steps to find the storedMarks value that was
+ * active before the transaction ran, falling back to the post-state if
+ * no `setStoredMarks` step was recorded.
+ */
+export declare function deriveStoredMarksBefore(tr: Transaction): readonly Mark[] | null;
 //# sourceMappingURL=StepInversion.d.ts.map

package/dist/state/StepInversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StepInversion.d.ts","sourceRoot":"","sources":["../../src/state/StepInversion.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AASpD,sCAAsC;AACtC,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAwH3C;AAWD,gFAAgF;AAChF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,WAAW,GAAG,WAAW,CAW9D"}
+{"version":3,"file":"StepInversion.d.ts","sourceRoot":"","sources":["../../src/state/StepInversion.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,KAAK,EACX,WAAW,EACX,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,eAAe,EACf,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,IAAI,EACJ,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AASpD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAW3D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAU3D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAU3D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAU7D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CASrD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAS3D;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAMnE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAU/D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAO3D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAO3D;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAO7D;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAQvE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAQvE;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,CASzE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,WAAW,GAAG,SAAS,IAAI,EAAE,GAAG,IAAI,CAO/E"}

package/dist/state/StepMapping.d.ts

@@ -0,0 +1,18 @@
+import { Document } from '../model/Document.js';
+import { Mapping } from './Mapping.js';
+import { AddMarkStep, DeleteTextStep, InsertInlineNodeStep, InsertNodeStep, InsertTextStep, MergeBlocksStep, RemoveInlineNodeStep, RemoveMarkStep, RemoveNodeStep, SetBlockTypeStep, SetInlineNodeAttrStep, SetNodeAttrStep, SetStoredMarksStep, SplitBlockStep, Step } from './Steps.js';
+export declare function mapInsertText(step: InsertTextStep, mapping: Mapping, _doc: Document): Step | null;
+export declare function mapDeleteText(step: DeleteTextStep, mapping: Mapping, doc: Document): Step | null;
+export declare function mapInsertInlineNode(step: InsertInlineNodeStep, mapping: Mapping, _doc: Document): Step | null;
+export declare function mapRemoveInlineNode(step: RemoveInlineNodeStep, mapping: Mapping, doc: Document): Step | null;
+export declare function mapSplitBlock(step: SplitBlockStep, mapping: Mapping, _doc: Document): Step | null;
+export declare function mapMergeBlocks(step: MergeBlocksStep, mapping: Mapping, doc: Document): Step | null;
+export declare function mapAddMark(step: AddMarkStep, mapping: Mapping, _doc: Document): Step | null;
+export declare function mapRemoveMark(step: RemoveMarkStep, mapping: Mapping, _doc: Document): Step | null;
+export declare function mapSetStoredMarks(step: SetStoredMarksStep, _mapping: Mapping, _doc: Document): Step | null;
+export declare function mapSetBlockType(step: SetBlockTypeStep, mapping: Mapping, doc: Document): Step | null;
+export declare function mapSetNodeAttr(step: SetNodeAttrStep, mapping: Mapping, doc: Document): Step | null;
+export declare function mapSetInlineNodeAttr(step: SetInlineNodeAttrStep, mapping: Mapping, doc: Document): Step | null;
+export declare function mapInsertNode(step: InsertNodeStep, mapping: Mapping, _doc: Document): Step | null;
+export declare function mapRemoveNode(step: RemoveNodeStep, mapping: Mapping, doc: Document): Step | null;
+//# sourceMappingURL=StepMapping.d.ts.map

package/dist/state/StepMapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepMapping.d.ts","sourceRoot":"","sources":["../../src/state/StepMapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAa,QAAQ,EAAc,MAAM,sBAAsB,CAAC;AAW5E,OAAO,EAEN,KAAK,OAAO,EAKZ,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EACX,WAAW,EACX,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,eAAe,EACf,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,IAAI,EACJ,MAAM,YAAY,CAAC;AAuDpB,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAajG;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CA2BhG;AAED,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,QAAQ,GACZ,IAAI,GAAG,IAAI,CAWb;AAED,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,QAAQ,GACX,IAAI,GAAG,IAAI,CA6Bb;AAID,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAajG;AAED,wBAAgB,cAAc,CAC7B,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,QAAQ,GACX,IAAI,GAAG,IAAI,CAoCb;AAID,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAc3F;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAcjG;AAID,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,kBAAkB,EACxB,QAAQ,EAAE,OAAO,EACjB,IAAI,EAAE,QAAQ,GACZ,IAAI,GAAG,IAAI,CAGb;AAED,wBAAgB,eAAe,CAC9B,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,QAAQ,GACX,IAAI,GAAG,IAAI,CA6Bb;AAED,wBAAgB,cAAc,CAC7B,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,QAAQ,GACX,IAAI,GAAG,IAAI,CAWb;AAED,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,QAAQ,GACX,IAAI,GAAG,IAAI,CAoBb;AAID,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAajG;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAiChG"}