@portabletext/editor 6.6.4 → 7.0.1

package/lib/_chunks-dts/behavior.types.action.d.ts

@@ -1,6 +1,7 @@
+import { A as ChildPath, D as Path$1, M as Path, O as AnnotationPath, _ as RegistrableNode, a as Containers, d as ResolvedContainers, g as InlineObjectConfig, i as EditorSchema, k as BlockPath, p as BlockObjectConfig, r as Node$1, x as TextBlockConfig, y as SpanConfig } from "./resolve-containers.js";
 import * as _portabletext_schema6 from "@portabletext/schema";
-import { AnnotationDefinition, AnnotationSchemaType, AnnotationSchemaType as AnnotationSchemaType$1, BaseDefinition, BlockObjectDefinition, BlockObjectSchemaType, BlockObjectSchemaType as BlockObjectSchemaType$1, DecoratorDefinition, DecoratorSchemaType, DecoratorSchemaType as DecoratorSchemaType$1, FieldDefinition, InlineObjectDefinition, InlineObjectSchemaType, InlineObjectSchemaType as InlineObjectSchemaType$1, ListDefinition, ListSchemaType, ListSchemaType as ListSchemaType$1, PortableTextBlock, PortableTextBlock as PortableTextBlock$1, PortableTextChild, PortableTextChild as PortableTextChild$1, PortableTextObject, PortableTextObject as PortableTextObject$1, PortableTextSpan, PortableTextSpan as PortableTextSpan$1, PortableTextTextBlock, PortableTextTextBlock as PortableTextTextBlock$1, Schema, SchemaDefinition, SchemaDefinition as SchemaDefinition$1, StyleDefinition, StyleSchemaType, StyleSchemaType as StyleSchemaType$1, TypedObject, defineSchema } from "@portabletext/schema";
-import * as xstate73 from "xstate";
+import { AnnotationDefinition, AnnotationSchemaType, AnnotationSchemaType as AnnotationSchemaType$1, BaseDefinition, BlockObjectDefinition, BlockObjectSchemaType, BlockObjectSchemaType as BlockObjectSchemaType$1, DecoratorDefinition, DecoratorSchemaType, DecoratorSchemaType as DecoratorSchemaType$1, FieldDefinition as FieldDefinition$1, InlineObjectDefinition, InlineObjectSchemaType, InlineObjectSchemaType as InlineObjectSchemaType$1, ListDefinition, ListSchemaType, ListSchemaType as ListSchemaType$1, PortableTextBlock, PortableTextBlock as PortableTextBlock$1, PortableTextChild, PortableTextChild as PortableTextChild$1, PortableTextObject, PortableTextObject as PortableTextObject$1, PortableTextSpan, PortableTextSpan as PortableTextSpan$1, PortableTextTextBlock, PortableTextTextBlock as PortableTextTextBlock$1, Schema, SchemaDefinition, SchemaDefinition as SchemaDefinition$1, StyleDefinition, StyleSchemaType, StyleSchemaType as StyleSchemaType$1, TypedObject, defineSchema } from "@portabletext/schema";
+import * as xstate37 from "xstate";
 import { ActorRef, ActorRefFrom, EventObject, Snapshot } from "xstate";
 import * as react4 from "react";
 import React$1, { BaseSyntheticEvent, ClipboardEvent as ClipboardEvent$1, FocusEvent, JSX, PropsWithChildren, ReactElement, RefObject, TextareaHTMLAttributes } from "react";
@@ -58,470 +59,6 @@ type Deserializer<TMIMEType extends MIMEType> = ({
   snapshot: EditorSnapshot;
   event: PickFromUnion<ConverterEvent<TMIMEType>, 'type', 'deserialize'>;
 }) => PickFromUnion<ConverterEvent<TMIMEType>, 'type', 'deserialization.success' | 'deserialization.failure'>;
-/**
- * A segment in a path that identifies an element by its `_key` property.
- * @public
- */
-interface KeyedSegment {
-  _key: string;
-}
-/**
- * A tuple representing a range selection, e.g., `[0, 5]` or `['', 3]`.
- * @public
- */
-type IndexTuple = [number | '', number | ''];
-/**
- * A single segment in a path. Can be:
- * - A string (property name)
- * - A number (array index)
- * - A KeyedSegment (object with `_key`)
- * - An IndexTuple (range selection)
- * @public
- */
-type PathSegment = string | number | KeyedSegment | IndexTuple;
-/**
- * A path is an array of path segments that describes a location in a document.
- * @public
- */
-type Path = PathSegment[];
-/**
- * @public
- */
-type BlockPath = [{
-  _key: string;
-}];
-/**
- * @public
- */
-type AnnotationPath = [{
-  _key: string;
-}, 'markDefs', {
-  _key: string;
-}];
-/**
- * @public
- */
-type ChildPath = [{
-  _key: string;
-}, 'children', {
-  _key: string;
-}];
-/**
- * @public
- */
-type EditorSchema = Schema;
-/**
- * `Path` arrays are a list of indexes that describe a node's exact position in
- * a Slate node tree. Although they are usually relative to the root `Editor`
- * object, they can be relative to any `Node` object.
- */
-type Path$1 = number[];
-type Node$1 = PortableTextTextBlock | PortableTextObject | PortableTextSpan;
-type TextDirection = 'forward' | 'backward';
-/**
- * `Point` objects refer to a specific location in a text node in a Slate
- * document. Its path refers to the location of the node in the tree, and its
- * offset refers to the distance into the node's string of text. Points can
- * only refer to `Text` nodes.
- */
-interface Point {
-  path: number[];
-  offset: number;
-}
-/**
- * `Range` objects are a set of points that refer to a specific span of a Slate
- * document. They can define a span inside a single node or a can span across
- * multiple nodes.
- */
-interface Range {
-  anchor: Point;
-  focus: Point;
-}
-type InsertNodeOperation = {
-  type: 'insert_node';
-  path: Path$1;
-  node: Node$1;
-};
-type InsertTextOperation = {
-  type: 'insert_text';
-  path: Path$1;
-  offset: number;
-  text: string;
-};
-type RemoveNodeOperation = {
-  type: 'remove_node';
-  path: Path$1;
-  node: Node$1;
-};
-type RemoveTextOperation = {
-  type: 'remove_text';
-  path: Path$1;
-  offset: number;
-  text: string;
-};
-type SetNodeOperation = {
-  type: 'set_node';
-  path: Path$1;
-  properties: Partial<Node$1>;
-  newProperties: Partial<Node$1>;
-};
-type SetSelectionOperation = {
-  type: 'set_selection';
-  properties: null;
-  newProperties: Range;
-} | {
-  type: 'set_selection';
-  properties: Partial<Range>;
-  newProperties: Partial<Range>;
-} | {
-  type: 'set_selection';
-  properties: Range;
-  newProperties: null;
-};
-type Operation = InsertNodeOperation | RemoveNodeOperation | SetNodeOperation | SetSelectionOperation | InsertTextOperation | RemoveTextOperation;
-type DecoratedRange = Range & {
-  rangeDecoration: RangeDecoration;
-};
-/**
- * The `Location` interface is a union of the ways to refer to a specific
- * location in a Slate document: paths, points or ranges.
- *
- * Methods will often accept a `Location` instead of requiring only a `Path`,
- * `Point` or `Range`. This eliminates the need for developers to manage
- * converting between the different interfaces in their own code base.
- */
-type Location = Path$1 | Point | Range;
-/**
- * `PathRef` objects keep a specific path in a document synced over time as new
- * operations are applied to the editor. You can access their `current` property
- * at any time for the up-to-date path value.
- */
-interface PathRef {
-  current: Path$1 | null;
-  affinity: 'forward' | 'backward' | null;
-  unref(): Path$1 | null;
-}
-interface PathRefInterface {
-  transform: (ref: PathRef, op: Operation) => void;
-}
-declare const PathRef: PathRefInterface;
-/**
- * `PointRef` objects keep a specific point in a document synced over time as new
- * operations are applied to the editor. You can access their `current` property
- * at any time for the up-to-date point value.
- */
-interface PointRef {
-  current: Point | null;
-  affinity: TextDirection | null;
-  unref(): Point | null;
-}
-interface PointRefInterface {
-  transform: (ref: PointRef, op: Operation) => void;
-}
-declare const PointRef: PointRefInterface;
-/**
- * `RangeRef` objects keep a specific range in a document synced over time as new
- * operations are applied to the editor. You can access their `current` property
- * at any time for the up-to-date range value.
- */
-interface RangeRef {
-  current: Range | null;
-  affinity: 'forward' | 'backward' | 'outward' | 'inward' | null;
-  unref(): Range | null;
-}
-/**
- * The `Editor` interface stores all the state of a Slate editor. It is extended
- * by plugins that wish to add their own helpers and implement new behaviors.
- */
-interface BaseEditor {
-  children: PortableTextBlock[];
-  readonly value: PortableTextBlock[];
-  selection: Selection$1;
-  operations: Operation[];
-  marks: EditorMarks | null;
-  dirtyPaths: Path$1[];
-  dirtyPathKeys: Set<string>;
-  flushing: boolean;
-  normalizing: boolean;
-  pathRefs: Set<PathRef>;
-  pointRefs: Set<PointRef>;
-  rangeRefs: Set<RangeRef>;
-  apply: (operation: Operation) => void;
-  normalizeNode: (entry: [Editor$1 | Node$1, Path$1], options?: {
-    operation?: Operation;
-  }) => void;
-  onChange: (options?: {
-    operation?: Operation;
-  }) => void;
-  shouldNormalize: ({
-    iteration,
-    dirtyPaths,
-    operation
-  }: {
-    iteration: number;
-    initialDirtyPathsLength: number;
-    dirtyPaths: Path$1[];
-    operation?: Operation;
-  }) => boolean;
-  select: (target: Location) => void;
-  setSelection: (props: Partial<Range>) => void;
-}
-type Editor$1 = BaseEditor & ReactEditor & PortableTextSlateEditor;
-type Selection$1 = Range | null;
-type EditorMarks = Omit<PortableTextSpan, 'text'>;
-type StringDiff = {
-  start: number;
-  end: number;
-  text: string;
-};
-type TextDiff = {
-  id: number;
-  path: Path$1;
-  diff: StringDiff;
-};
-/**
- * Types.
- */
-type DOMNode = globalThis.Node;
-type DOMRange = globalThis.Range;
-type DOMSelection = globalThis.Selection;
-type DOMStaticRange = globalThis.StaticRange;
-declare global {
-  interface Window {
-    Selection: (typeof Selection)['constructor'];
-    DataTransfer: (typeof DataTransfer)['constructor'];
-    Node: (typeof Node)['constructor'];
-  }
-}
-type DOMPoint = [Node, number];
-type Action = {
-  at?: Point | Range;
-  run: () => void;
-};
-/**
- * A DOM-specific version of the `Editor` interface.
- */
-interface DOMEditor extends BaseEditor {
-  hasEditableTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
-  hasRange: (editor: Editor$1, range: Range) => boolean;
-  hasSelectableTarget: (editor: Editor$1, target: EventTarget | null) => boolean;
-  hasTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
-  isTargetInsideNonReadonlyVoid: (editor: Editor$1, target: EventTarget | null) => boolean;
-  isNodeMapDirty: boolean;
-  domWindow: Window | null;
-  domElement: HTMLElement | null;
-  domPlaceholder: string;
-  domPlaceholderElement: HTMLElement | null;
-  readOnly: boolean;
-  focused: boolean;
-  composing: boolean;
-  userSelection: RangeRef | null;
-  onContextChange: ((options?: {
-    operation?: Operation;
-  }) => void) | null;
-  scheduleFlush: (() => void) | null;
-  pendingInsertionMarks: EditorMarks | null;
-  userMarks: EditorMarks | null;
-  pendingDiffs: TextDiff[];
-  pendingAction: Action | null;
-  pendingSelection: Range | null;
-  forceRender: (() => void) | null;
-}
-interface DOMEditorInterface {
-  /**
-   * Blur the editor.
-   */
-  blur: (editor: Editor$1) => void;
-  /**
-   * Find the DOM node that implements DocumentOrShadowRoot for the editor.
-   */
-  findDocumentOrShadowRoot: (editor: Editor$1) => Document | ShadowRoot;
-  /**
-   * Focus the editor.
-   */
-  focus: (editor: Editor$1, options?: {
-    retries: number;
-  }) => void;
-  /**
-   * Return the host window of the current editor.
-   */
-  getWindow: (editor: Editor$1) => Window;
-  /**
-   * Check if a DOM node is within the editor.
-   */
-  hasDOMNode: (editor: Editor$1, target: DOMNode, options?: {
-    editable?: boolean;
-  }) => boolean;
-  /**
-   * Check if the target is editable and in the editor.
-   */
-  hasEditableTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
-  /**
-   *
-   */
-  hasRange: (editor: Editor$1, range: Range) => boolean;
-  /**
-   * Check if the target can be selectable
-   */
-  hasSelectableTarget: (editor: Editor$1, target: EventTarget | null) => boolean;
-  /**
-   * Check if the target is in the editor.
-   */
-  hasTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
-  /**
-   * Check if the user is currently composing inside the editor.
-   */
-  isComposing: (editor: Editor$1) => boolean;
-  /**
-   * Check if the editor is focused.
-   */
-  isFocused: (editor: Editor$1) => boolean;
-  /**
-   * Check if the target is inside void and in an non-readonly editor.
-   */
-  isTargetInsideNonReadonlyVoid: (editor: Editor$1, target: EventTarget | null) => boolean;
-  /**
-   * Find a native DOM selection point from a Slate point.
-   */
-  toDOMPoint: (editor: Editor$1, point: Point) => DOMPoint;
-  /**
-   * Find a native DOM range from a Slate `range`.
-   *
-   * Notice: the returned range will always be ordinal regardless of the direction of Slate `range` due to DOM API limit.
-   *
-   * there is no way to create a reverse DOM Range using Range.setStart/setEnd
-   * according to https://dom.spec.whatwg.org/#concept-range-bp-set.
-   */
-  toDOMRange: (editor: Editor$1, range: Range) => DOMRange;
-  /**
-   * Find a Slate point from a DOM selection's `domNode` and `domOffset`.
-   */
-  toSlatePoint: <T extends boolean>(editor: Editor$1, domPoint: DOMPoint, options: {
-    exactMatch: boolean;
-    suppressThrow: T;
-    /**
-     * The direction to search for Slate leaf nodes if `domPoint` is
-     * non-editable and non-void.
-     */
-    searchDirection?: 'forward' | 'backward';
-  }) => T extends true ? Point | null : Point;
-  /**
-   * Find a Slate range from a DOM range or selection.
-   */
-  toSlateRange: <T extends boolean>(editor: Editor$1, domRange: DOMRange | DOMStaticRange | DOMSelection, options: {
-    exactMatch: boolean;
-    suppressThrow: T;
-  }) => T extends true ? Range | null : Range;
-}
-declare const DOMEditor: DOMEditorInterface;
-/**
- * A React and DOM-specific version of the `Editor` interface.
- */
-interface ReactEditor extends DOMEditor {}
-interface ReactEditorInterface extends DOMEditorInterface {}
-declare const ReactEditor: ReactEditorInterface;
-type HistoryItem = {
-  operations: Operation[];
-  timestamp: Date;
-};
-interface History {
-  redos: HistoryItem[];
-  undos: HistoryItem[];
-}
-type RemotePatch = {
-  patch: Patch;
-  time: Date;
-  snapshot: PortableTextBlock[] | undefined;
-  previousSnapshot: PortableTextBlock[] | undefined;
-};
-interface PortableTextSlateEditor extends ReactEditor {
-  _key: 'editor';
-  _type: 'editor';
-  schema: EditorSchema;
-  keyGenerator: () => string;
-  editableTypes: Set<string>;
-  decoratedRanges: Array<DecoratedRange>;
-  decoratorState: Record<string, boolean | undefined>;
-  blockIndexMap: Map<string, number>;
-  history: History;
-  lastSelection: EditorSelection;
-  lastSlateSelection: Range | null;
-  listIndexMap: Map<string, number>;
-  remotePatches: Array<RemotePatch>;
-  undoStepId: string | undefined;
-  isDeferringMutations: boolean;
-  isNormalizingNode: boolean;
-  isPatching: boolean;
-  isPerformingBehaviorOperation: boolean;
-  isProcessingRemoteChanges: boolean;
-  isRedoing: boolean;
-  isUndoing: boolean;
-  withHistory: boolean;
-}
-/**
- * @public
- */
-type EditorEmittedEvent = {
-  type: 'blurred';
-  event: FocusEvent<HTMLDivElement, Element>;
-} | {
-  /**
-   * @deprecated Will be removed in the next major version
-   */
-  type: 'done loading';
-} | {
-  type: 'editable';
-} | ErrorEvent | {
-  type: 'focused';
-  event: FocusEvent<HTMLDivElement, Element>;
-} | {
-  type: 'invalid value';
-  resolution: InvalidValueResolution | null;
-  value: Array<PortableTextBlock> | undefined;
-} | {
-  /**
-   * @deprecated Will be removed in the next major version
-   */
-  type: 'loading';
-} | MutationEvent | PatchEvent | {
-  type: 'read only';
-} | {
-  type: 'ready';
-} | {
-  type: 'selection';
-  selection: EditorSelection;
-} | {
-  type: 'value changed';
-  value: Array<PortableTextBlock> | undefined;
-};
-/**
- * @deprecated The event is no longer emitted
- */
-type ErrorEvent = {
-  type: 'error';
-  name: string;
-  description: string;
-  data: unknown;
-};
-/**
- * @public
- */
-type MutationEvent = {
-  type: 'mutation';
-  patches: Array<Patch>;
-  value: Array<PortableTextBlock> | undefined;
-};
-type PatchEvent = {
-  type: 'patch';
-  patch: Patch;
-};
-type InternalEditor = Editor & {
-  _internal: {
-    editable: EditableAPI;
-    editorActor: EditorActor;
-    slateEditor: PortableTextSlateEditor;
-  };
-};
 /**
  * @public
  * @deprecated Use `useEditor()` instead
@@ -544,13 +81,10 @@ declare class PortableTextEditor {
    * A lookup table for all the relevant schema types for this portable text type.
    */
   schemaTypes: Schema;
-  /**
-   * The editor instance
-   */
-  private editor;
   private editable;
   constructor(config: {
-    editor: InternalEditor;
+    editable: EditableAPI;
+    editorActor: EditorActor;
   });
   setEditable: (editable: EditableAPI) => void;
   /**
@@ -1190,31 +724,409 @@ interface RangeDecorationOnMovedDetails {
  * @alpha */
 interface RangeDecoration {
   /**
-   * A component for rendering the range decoration.
-   * The component will receive the children (text) of the range decoration as its children.
+   * A component for rendering the range decoration.
+   * The component will receive the children (text) of the range decoration as its children.
+   *
+   * @example
+   * ```ts
+   * (rangeComponentProps: PropsWithChildren) => (
+   *    <SearchResultHighlight>
+   *      {rangeComponentProps.children}
+   *    </SearchResultHighlight>
+   *  )
+   * ```
+   */
+  component: (props: PropsWithChildren) => ReactElement<any>;
+  /**
+   * The editor content selection range
+   */
+  selection: EditorSelection;
+  /**
+   * A optional callback that will be called when the range decoration potentially moves according to user edits.
+   */
+  onMoved?: (details: RangeDecorationOnMovedDetails) => void;
+  /**
+   * A custom payload that can be set on the range decoration
+   */
+  payload?: Record<string, unknown>;
+}
+type TextDirection = 'forward' | 'backward';
+/**
+ * `Point` objects refer to a specific location in a text node in a Slate
+ * document. Its path refers to the location of the node in the tree, and its
+ * offset refers to the distance into the node's string of text. Points can
+ * only refer to `Text` nodes.
+ */
+interface Point {
+  path: Path$1;
+  offset: number;
+}
+/**
+ * `Range` objects are a set of points that refer to a specific span of a Slate
+ * document. They can define a span inside a single node or a can span across
+ * multiple nodes.
+ */
+interface Range {
+  anchor: Point;
+  focus: Point;
+}
+type InsertOperation = {
+  type: 'insert';
+  path: Path$1;
+  node: Node$1;
+  position: 'before' | 'after';
+  inverse?: UnsetOperationData;
+};
+type InsertTextOperation = {
+  type: 'insert_text';
+  path: Path$1;
+  offset: number;
+  text: string;
+};
+type RemoveTextOperation = {
+  type: 'remove_text';
+  path: Path$1;
+  offset: number;
+  text: string;
+};
+/**
+ * Data for a `set` inverse (no nested inverse field).
+ */
+type SetOperationData = {
+  type: 'set';
+  path: Path$1;
+  value: unknown;
+};
+/**
+ * Data for an `insert` inverse (no nested inverse field).
+ */
+type InsertOperationData = {
+  type: 'insert';
+  path: Path$1;
+  node: Node$1;
+  position: 'before' | 'after';
+};
+/**
+ * Data for an `unset` inverse (no nested inverse field).
+ */
+type UnsetOperationData = {
+  type: 'unset';
+  path: Path$1;
+};
+/**
+ * Set a property on a node. The path is `[...nodePath, propertyName]`.
+ *
+ * When `inverse` is provided, the operation can be undone. Remote operations
+ * (applied via `withRemoteChanges`) skip the history plugin and do not need
+ * inverse data.
+ */
+type SetOperation = {
+  type: 'set';
+  path: Path$1;
+  value: unknown;
+  inverse?: SetOperationData | UnsetOperationData;
+};
+/**
+ * Remove a property from a node, or remove a node from its parent.
+ *
+ * Property removal: path is `[...nodePath, propertyName]` (last segment is a string).
+ * Node removal: path is `[...parentPath, arrayFieldName, {_key: nodeKey}]`
+ * (last segment is a keyed segment pointing to the node to remove).
+ */
+type UnsetOperation = {
+  type: 'unset';
+  path: Path$1;
+  inverse?: SetOperationData | InsertOperationData;
+};
+type SetSelectionOperation = {
+  type: 'set_selection';
+  properties: null;
+  newProperties: Range;
+} | {
+  type: 'set_selection';
+  properties: Partial<Range>;
+  newProperties: Partial<Range>;
+} | {
+  type: 'set_selection';
+  properties: Range;
+  newProperties: null;
+};
+type Operation = InsertOperation | SetOperation | UnsetOperation | SetSelectionOperation | InsertTextOperation | RemoveTextOperation;
+type DecoratedRange = Range & {
+  rangeDecoration: RangeDecoration;
+};
+/**
+ * The `Location` interface is a union of the ways to refer to a specific
+ * location in a Slate document: paths, points or ranges.
+ *
+ * Methods will often accept a `Location` instead of requiring only a `Path`,
+ * `Point` or `Range`. This eliminates the need for developers to manage
+ * converting between the different interfaces in their own code base.
+ */
+type Location = Path$1 | Point | Range;
+/**
+ * `PathRef` objects keep a specific path in a document synced over time as new
+ * operations are applied to the editor. You can access their `current` property
+ * at any time for the up-to-date path value.
+ */
+interface PathRef {
+  current: Path$1 | null;
+  affinity: 'forward' | 'backward' | null;
+  unref(): Path$1 | null;
+}
+interface PathRefInterface {
+  transform: (ref: PathRef, op: Operation) => void;
+}
+declare const PathRef: PathRefInterface;
+/**
+ * `PointRef` objects keep a specific point in a document synced over time as new
+ * operations are applied to the editor. You can access their `current` property
+ * at any time for the up-to-date point value.
+ */
+interface PointRef {
+  current: Point | null;
+  affinity: TextDirection | null;
+  unref(): Point | null;
+}
+interface PointRefInterface {
+  transform: (ref: PointRef, op: Operation) => void;
+}
+declare const PointRef: PointRefInterface;
+/**
+ * `RangeRef` objects keep a specific range in a document synced over time as new
+ * operations are applied to the editor. You can access their `current` property
+ * at any time for the up-to-date range value.
+ */
+interface RangeRef {
+  current: Range | null;
+  affinity: 'forward' | 'backward' | 'outward' | 'inward' | null;
+  unref(): Range | null;
+}
+/**
+ * The `Editor` interface stores all the state of a Slate editor. It is extended
+ * by plugins that wish to add their own helpers and implement new behaviors.
+ */
+interface BaseEditor {
+  children: PortableTextBlock[];
+  readonly value: PortableTextBlock[];
+  selection: EditorSelection;
+  operations: Operation[];
+  dirtyPaths: Path$1[];
+  dirtyPathKeys: Set<string>;
+  flushing: boolean;
+  normalizing: boolean;
+  pathRefs: Set<PathRef>;
+  pointRefs: Set<PointRef>;
+  rangeRefs: Set<RangeRef>;
+  apply: (operation: Operation) => void;
+  normalizeNode: (entry: [Editor$1 | Node$1, Path$1], options?: {
+    operation?: Operation;
+  }) => void;
+  onChange: (options?: {
+    operation?: Operation;
+  }) => void;
+  shouldNormalize: ({
+    iteration,
+    dirtyPaths,
+    operation
+  }: {
+    iteration: number;
+    initialDirtyPathsLength: number;
+    dirtyPaths: Path$1[];
+    operation?: Operation;
+  }) => boolean;
+  select: (target: Location) => void;
+  setSelection: (props: Partial<Range>) => void;
+}
+type Editor$1 = BaseEditor & DOMEditor & PortableTextSlateEditor;
+type StringDiff = {
+  start: number;
+  end: number;
+  text: string;
+};
+type TextDiff = {
+  id: number;
+  path: Path$1;
+  diff: StringDiff;
+};
+/**
+ * Types.
+ */
+type DOMNode = globalThis.Node;
+type DOMRange = globalThis.Range;
+type DOMSelection = globalThis.Selection;
+type DOMStaticRange = globalThis.StaticRange;
+declare global {
+  interface Window {
+    Selection: (typeof Selection)['constructor'];
+    DataTransfer: (typeof DataTransfer)['constructor'];
+    Node: (typeof Node)['constructor'];
+  }
+}
+type DOMPoint = [Node, number];
+type Action = {
+  at?: Point | Range;
+  run: () => void;
+};
+/**
+ * A DOM-specific version of the `Editor` interface.
+ */
+interface DOMEditor extends BaseEditor {
+  hasEditableTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
+  hasRange: (editor: Editor$1, range: Range) => boolean;
+  hasSelectableTarget: (editor: Editor$1, target: EventTarget | null) => boolean;
+  hasTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
+  isTargetInsideNonReadonlyVoid: (editor: Editor$1, target: EventTarget | null) => boolean;
+  isNodeMapDirty: boolean;
+  domWindow: Window | null;
+  domElement: HTMLElement | null;
+  readOnly: boolean;
+  focused: boolean;
+  composing: boolean;
+  userSelection: RangeRef | null;
+  onContextChange: ((options?: {
+    operation?: Operation;
+  }) => void) | null;
+  scheduleFlush: (() => void) | null;
+  pendingDiffs: TextDiff[];
+  pendingAction: Action | null;
+  pendingSelection: Range | null;
+  forceRender: (() => void) | null;
+}
+interface DOMEditorInterface {
+  /**
+   * Blur the editor.
+   */
+  blur: (editor: Editor$1) => void;
+  /**
+   * Find the DOM node that implements DocumentOrShadowRoot for the editor.
+   */
+  findDocumentOrShadowRoot: (editor: Editor$1) => Document | ShadowRoot;
+  /**
+   * Focus the editor.
+   */
+  focus: (editor: Editor$1, options?: {
+    retries: number;
+  }) => void;
+  /**
+   * Return the host window of the current editor.
+   */
+  getWindow: (editor: Editor$1) => Window;
+  /**
+   * Check if a DOM node is within the editor.
+   */
+  hasDOMNode: (editor: Editor$1, target: DOMNode, options?: {
+    editable?: boolean;
+  }) => boolean;
+  /**
+   * Check if the target is editable and in the editor.
+   */
+  hasEditableTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
+  /**
    *
-   * @example
-   * ```ts
-   * (rangeComponentProps: PropsWithChildren) => (
-   *    <SearchResultHighlight>
-   *      {rangeComponentProps.children}
-   *    </SearchResultHighlight>
-   *  )
-   * ```
    */
-  component: (props: PropsWithChildren) => ReactElement<any>;
+  hasRange: (editor: Editor$1, range: Range) => boolean;
   /**
-   * The editor content selection range
+   * Check if the target can be selectable
    */
-  selection: EditorSelection;
+  hasSelectableTarget: (editor: Editor$1, target: EventTarget | null) => boolean;
   /**
-   * A optional callback that will be called when the range decoration potentially moves according to user edits.
+   * Check if the target is in the editor.
    */
-  onMoved?: (details: RangeDecorationOnMovedDetails) => void;
+  hasTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
   /**
-   * A custom payload that can be set on the range decoration
+   * Check if the target is inside void and in an non-readonly editor.
    */
-  payload?: Record<string, unknown>;
+  isTargetInsideNonReadonlyVoid: (editor: Editor$1, target: EventTarget | null) => boolean;
+  /**
+   * Find a native DOM selection point from a Slate point.
+   */
+  toDOMPoint: (editor: Editor$1, point: Point) => DOMPoint;
+  /**
+   * Find a native DOM range from a Slate `range`.
+   *
+   * Notice: the returned range will always be ordinal regardless of the direction of Slate `range` due to DOM API limit.
+   *
+   * there is no way to create a reverse DOM Range using Range.setStart/setEnd
+   * according to https://dom.spec.whatwg.org/#concept-range-bp-set.
+   */
+  toDOMRange: (editor: Editor$1, range: Range) => DOMRange;
+  /**
+   * Find a Slate point from a DOM selection's `domNode` and `domOffset`.
+   */
+  toSlatePoint: <T extends boolean>(editor: Editor$1, domPoint: DOMPoint, options: {
+    exactMatch: boolean;
+    suppressThrow: T;
+    /**
+     * The direction to search for Slate leaf nodes if `domPoint` is
+     * non-editable and non-void.
+     */
+    searchDirection?: 'forward' | 'backward';
+  }) => T extends true ? Point | null : Point;
+  /**
+   * Find a Slate range from a DOM range or selection.
+   */
+  toSlateRange: <T extends boolean>(editor: Editor$1, domRange: DOMRange | DOMStaticRange | DOMSelection, options: {
+    exactMatch: boolean;
+    suppressThrow: T;
+  }) => T extends true ? Range | null : Range;
+}
+declare const DOMEditor: DOMEditorInterface;
+type HistoryItem = {
+  operations: Operation[];
+  timestamp: Date;
+};
+interface History {
+  redos: HistoryItem[];
+  undos: HistoryItem[];
+}
+type RemotePatch = {
+  patch: Patch;
+  time: Date;
+  snapshot: PortableTextBlock[] | undefined;
+  previousSnapshot: PortableTextBlock[] | undefined;
+};
+interface PortableTextSlateEditor extends DOMEditor {
+  _key: 'editor';
+  _type: 'editor';
+  schema: EditorSchema;
+  keyGenerator: () => string;
+  containers: ResolvedContainers;
+  /**
+   * Narrow {@link Containers} projection of `containers`, exposed on the
+   * public `EditorContext.containers`. Maintained in sync with
+   * `containers` by the editor machine's register/unregister handlers.
+   */
+  publicContainers: Containers;
+  blockObjects: Map<string, BlockObjectConfig>;
+  inlineObjects: Map<string, InlineObjectConfig>;
+  spans: Map<string, SpanConfig>;
+  textBlocks: Map<string, TextBlockConfig>;
+  /**
+   * Snapshot-shaped view onto the editor's traversal state. Mirrors the
+   * shape of `EditorSnapshot.context`.
+   */
+  readonly context: {
+    schema: EditorSchema;
+    containers: Containers;
+    value: PortableTextBlock[];
+    keyGenerator: () => string;
+  };
+  decoratedRanges: Array<DecoratedRange>;
+  decoratorState: Record<string, boolean | undefined>;
+  blockIndexMap: Map<string, number>;
+  history: History;
+  listIndexMap: Map<string, number>;
+  remotePatches: Array<RemotePatch>;
+  undoStepId: string | undefined;
+  isDeferringMutations: boolean;
+  isNormalizingNode: boolean;
+  isPatching: boolean;
+  isPerformingBehaviorOperation: boolean;
+  isProcessingRemoteChanges: boolean;
+  isRedoing: boolean;
+  isUndoing: boolean;
+  withHistory: boolean;
 }
 /**
  * @public
@@ -1226,6 +1138,25 @@ type EditorContext = {
   schema: EditorSchema;
   selection: EditorSelection;
   value: Array<PortableTextBlock>;
+  /**
+   * Map of registered editable containers keyed by their bare
+   * block-object `_type` (e.g. `'callout'`, `'table'`).
+   *
+   * Each entry is a {@link RegisteredContainer} carrying `type`,
+   * the array `field` that holds the container's editable children,
+   * and (when present) the nested positional `of` registrations
+   * consulted by {@link resolveContainerAt}. The render callback is
+   * engine-internal and not surfaced here.
+   *
+   * Only top-level registrations appear as flat entries. A `_type`
+   * registered only inside a parent's `of` is reachable through that
+   * parent's `of`, not as a top-level entry. Use
+   * `resolveContainerAt(containers, value, path)` for position-aware
+   * resolution that handles both top-level and positional entries.
+   *
+   * @alpha
+   */
+  containers: Containers;
 };
 /**
  * @public
@@ -1282,6 +1213,63 @@ type Behavior<TBehaviorEventType extends '*' | `${BehaviorEventTypeNamespace}.*`
  *
  */
 declare function defineBehavior<TPayload extends Record<string, unknown>, TBehaviorEventType extends '*' | `${BehaviorEventTypeNamespace}.*` | BehaviorEvent['type'] = CustomBehaviorEvent['type'], TGuardResponse = true>(behavior: Behavior<TBehaviorEventType, TGuardResponse, ResolveBehaviorEvent<TBehaviorEventType, TPayload>>): Behavior;
+/**
+ * @public
+ */
+type EditorEmittedEvent = {
+  type: 'blurred';
+  event: FocusEvent<HTMLDivElement, Element>;
+} | {
+  /**
+   * @deprecated Will be removed in the next major version
+   */
+  type: 'done loading';
+} | {
+  type: 'editable';
+} | ErrorEvent | {
+  type: 'focused';
+  event: FocusEvent<HTMLDivElement, Element>;
+} | {
+  type: 'invalid value';
+  resolution: InvalidValueResolution | null;
+  value: Array<PortableTextBlock> | undefined;
+} | {
+  /**
+   * @deprecated Will be removed in the next major version
+   */
+  type: 'loading';
+} | MutationEvent | PatchEvent | {
+  type: 'read only';
+} | {
+  type: 'ready';
+} | {
+  type: 'selection';
+  selection: EditorSelection;
+} | {
+  type: 'value changed';
+  value: Array<PortableTextBlock> | undefined;
+};
+/**
+ * @deprecated The event is no longer emitted
+ */
+type ErrorEvent = {
+  type: 'error';
+  name: string;
+  description: string;
+  data: unknown;
+};
+/**
+ * @public
+ */
+type MutationEvent = {
+  type: 'mutation';
+  patches: Array<Patch>;
+  value: Array<PortableTextBlock> | undefined;
+};
+type PatchEvent = {
+  type: 'patch';
+  patch: Patch;
+};
 /**
  * @public
  */
@@ -1313,8 +1301,36 @@ type Editor = {
   registerBehavior: (config: {
     behavior: Behavior;
   }) => () => void;
+  /**
+   * Register a node renderer. The `node` argument is the result of one
+   * of the `defineX` factories (`defineContainer`, `defineTextBlock`,
+   * `defineSpan`, `defineBlockObject`, `defineInlineObject`). Returns
+   * a function that unregisters the node when called.
+   *
+   * @alpha
+   */
+  registerNode: (config: {
+    node: RegistrableNode;
+  }) => () => void;
   send: (event: EditorEvent) => void;
   on: ActorRef<Snapshot<unknown>, EventObject, EditorEmittedEvent>['on'];
+  /**
+   * Subscribe to editor state changes. The observer's `next` callback fires
+   * with the current `EditorSnapshot` on every relevant transition (selection
+   * updates, content mutations, behavior dispatch, configuration changes).
+   *
+   * The editor has no terminal state and no error path, so `error` and
+   * `complete` are part of the observable contract but never fire. They are
+   * kept for structural compatibility with `useSyncExternalStore`,
+   * `@xstate/react`'s `useSelector`, and other observer-shaped consumers.
+   */
+  subscribe(observer: {
+    next?: (snapshot: EditorSnapshot) => void;
+    error?: (err: unknown) => void;
+    complete?: () => void;
+  }): {
+    unsubscribe: () => void;
+  };
 };
 /**
  * @public
@@ -1448,10 +1464,15 @@ type EditorActor = ActorRefFrom<typeof editorMachine>;
 /**
  * @internal
  */
-declare const editorMachine: xstate73.StateMachine<{
+declare const editorMachine: xstate37.StateMachine<{
   behaviors: Set<BehaviorConfig>;
   behaviorsSorted: boolean;
-  converters: Set<Converter>;
+  blockObjects: Map<string, BlockObjectConfig>;
+  containers: ResolvedContainers;
+  converters: Array<Converter>;
+  inlineObjects: Map<string, InlineObjectConfig>;
+  spans: Map<string, SpanConfig>;
+  textBlocks: Map<string, TextBlockConfig>;
   keyGenerator: () => string;
   pendingEvents: Array<InternalPatchEvent | MutationEvent>;
   pendingIncomingPatchesEvents: Array<PatchesEvent>;
@@ -1504,57 +1525,72 @@ declare const editorMachine: xstate73.StateMachine<{
   type: "dragend";
 } | {
   type: "drop";
+} | {
+  type: "register";
+  node: RegistrableNode;
+} | {
+  type: "unregister";
+  node: RegistrableNode;
 } | {
   type: "add slate editor";
   editor: PortableTextSlateEditor;
 }, {}, never, {
+  type: "register";
+  params: xstate37.NonReducibleUnknown;
+} | {
+  type: "unregister";
+  params: xstate37.NonReducibleUnknown;
+} | {
   type: "add behavior to context";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "remove behavior from context";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "add slate editor to context";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
+} | {
+  type: "attach maps to slate editor";
+  params: unknown;
 } | {
   type: "emit patch event";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "emit mutation event";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "emit read only";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "emit editable";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "defer event";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "emit pending events";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "emit ready";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "clear pending events";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "discard conflicting pending patches";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "discard all pending events";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "defer incoming patches";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "emit pending incoming patches";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "clear pending incoming patches";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 } | {
   type: "handle blur";
   params: unknown;
@@ -1566,7 +1602,7 @@ declare const editorMachine: xstate73.StateMachine<{
   params: unknown;
 } | {
   type: "sort behaviors";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate37.NonReducibleUnknown;
 }, {
   type: "slate is busy";
   params: unknown;
@@ -1595,7 +1631,7 @@ declare const editorMachine: xstate73.StateMachine<{
   readOnly?: boolean;
   schema: EditorSchema;
   initialValue?: Array<PortableTextBlock>;
-}, xstate73.NonReducibleUnknown, InternalPatchEvent | MutationEvent | PatchesEvent | {
+}, xstate37.NonReducibleUnknown, InternalPatchEvent | MutationEvent | PatchesEvent | {
   type: "blurred";
   event: react4.FocusEvent<HTMLDivElement, Element>;
 } | {
@@ -1626,7 +1662,7 @@ declare const editorMachine: xstate73.StateMachine<{
 } | {
   type: "value changed";
   value: Array<PortableTextBlock> | undefined;
-}, xstate73.MetaObject, {
+}, xstate37.MetaObject, {
   id: "editor";
   states: {
     readonly 'edit mode': {
@@ -1681,9 +1717,16 @@ declare const editorMachine: xstate73.StateMachine<{
 type EventPosition = {
   block: 'start' | 'end';
   /**
-   * Did the event origin from the editor DOM node itself or from a child node?
+   * Did the event originate from the editor root DOM node itself, rather than
+   * from a block inside the editor?
    */
   isEditor: boolean;
+  /**
+   * Did the event originate from an editable container's DOM node itself (for
+   * example a code block or a table cell), rather than from a block inside the
+   * container?
+   */
+  isContainer: boolean;
   selection: NonNullable<EditorSelection>;
 };
 type TextBlockWithOptionalKey = Omit<PortableTextTextBlock, '_key'> & {
@@ -1725,7 +1768,7 @@ type ExternalBehaviorEvent = {
 /**************************************
  * Synthetic events
  **************************************/
-declare const syntheticBehaviorEventTypes: readonly ["annotation.add", "annotation.remove", "block.set", "block.unset", "child.set", "child.unset", "decorator.add", "decorator.remove", "delete", "history.redo", "history.undo", "insert.block", "insert.child", "insert.text", "move.backward", "move.block", "move.forward", "select"];
+declare const syntheticBehaviorEventTypes: readonly ["annotation.add", "annotation.remove", "block.set", "block.unset", "child.set", "child.unset", "decorator.add", "decorator.remove", "delete", "history.redo", "history.undo", "insert", "insert.block", "insert.child", "insert.text", "move.backward", "move.block", "move.forward", "remove.text", "select", "set", "unset"];
 type SyntheticBehaviorEventType = (typeof syntheticBehaviorEventTypes)[number] | (typeof abstractBehaviorEventTypes)[number];
 type SyntheticBehaviorEventNamespace = ExtractNamespace<SyntheticBehaviorEventType>;
 /**
@@ -1788,6 +1831,33 @@ type SyntheticBehaviorEvent = {
   type: StrictExtract<SyntheticBehaviorEventType, 'history.redo'>;
 } | {
   type: StrictExtract<SyntheticBehaviorEventType, 'history.undo'>;
+} | {
+  /**
+   * @alpha
+   *
+   * Primitive: insert a node into an array.
+   *
+   * The last segment of `at` resolves the insertion point:
+   * - A keyed `{_key}` segment inserts relative to that sibling.
+   * - A numeric index inserts relative to that slot.
+   *
+   * `position` ('before' or 'after') is always meaningful: `before: [2]`
+   * inserts at index 2, `after: [2]` inserts at index 3.
+   *
+   * @example
+   * ```ts
+   * raise({
+   *   type: 'insert',
+   *   at: [{_key: 'list'}, 'items', {_key: 'item3'}],
+   *   value: newItem,
+   *   position: 'after',
+   * })
+   * ```
+   */
+  type: StrictExtract<SyntheticBehaviorEventType, 'insert'>;
+  at: Path;
+  value: PortableTextTextBlock | PortableTextObject | PortableTextSpan;
+  position: 'before' | 'after';
 } | {
   type: StrictExtract<SyntheticBehaviorEventType, 'insert.block'>;
   block: BlockWithOptionalKey;
@@ -1798,7 +1868,33 @@ type SyntheticBehaviorEvent = {
   type: StrictExtract<SyntheticBehaviorEventType, 'insert.child'>;
   child: ChildWithOptionalKey;
 } | {
+  /**
+   * Inserts text into a span.
+   *
+   * Without `at`/`offset`, text is inserted at the current caret position.
+   * This is the form used by typing handlers.
+   *
+   * @alpha
+   * With `at` and `offset`, text is inserted at the explicit position.
+   * Recommended for plugin behaviors and collaborative-edit contexts.
+   *
+   * @example
+   * ```ts
+   * // Caret form
+   * raise({type: 'insert.text', text: 'x'})
+   *
+   * // Primitive form (@alpha)
+   * raise({
+   *   type: 'insert.text',
+   *   at: [{_key: 'b1'}, 'children', {_key: 's1'}],
+   *   offset: 5,
+   *   text: 'world',
+   * })
+   * ```
+   */
   type: StrictExtract<SyntheticBehaviorEventType, 'insert.text'>;
+  at?: Path;
+  offset?: number;
   text: string;
 } | {
   type: StrictExtract<SyntheticBehaviorEventType, 'move.backward'>;
@@ -1810,9 +1906,84 @@ type SyntheticBehaviorEvent = {
 } | {
   type: StrictExtract<SyntheticBehaviorEventType, 'move.forward'>;
   distance: number;
+} | {
+  /**
+   * @alpha
+   *
+   * Primitive: remove text from a span at the given offset.
+   *
+   * The `text` field carries the exact text being removed (matches the
+   * apply-layer shape so the inverse can be computed without re-reading
+   * the span).
+   *
+   * Recommended for collaborative-edit contexts (concurrent edits compose
+   * cleanly under operational transform).
+   *
+   * @example
+   * ```ts
+   * raise({
+   *   type: 'remove.text',
+   *   at: [{_key: 'b1'}, 'children', {_key: 's1'}],
+   *   offset: 5,
+   *   text: 'world',
+   * })
+   * ```
+   */
+  type: StrictExtract<SyntheticBehaviorEventType, 'remove.text'>;
+  at: Path;
+  offset: number;
+  text: string;
 } | {
   type: StrictExtract<SyntheticBehaviorEventType, 'select'>;
   at: EditorSelection;
+} | {
+  /**
+   * @alpha
+   *
+   * Primitive: set a property on a node, or replace a node wholesale.
+   *
+   * The last segment of `at` is the property name (a string) for property
+   * updates, OR a keyed/indexed segment for full-node replacement.
+   *
+   * Note: `set` on span text (`{at: [...spanPath, 'text'], value: '...'}`)
+   * is legal but not recommended in collaborative-edit contexts. Use
+   * `insert.text` and `remove.text` for text edits that compose under
+   * operational transform.
+   *
+   * @example
+   * ```ts
+   * // Set a block's style
+   * raise({type: 'set', at: [{_key: 'b1'}, 'style'], value: 'h1'})
+   *
+   * // Replace a block wholesale
+   * raise({type: 'set', at: [{_key: 'b1'}], value: newBlock})
+   * ```
+   */
+  type: StrictExtract<SyntheticBehaviorEventType, 'set'>;
+  at: Path;
+  value: unknown;
+} | {
+  /**
+   * @alpha
+   *
+   * Primitive: unset a property on an object, OR remove a node from an
+   * array.
+   *
+   * When the last segment of `at` is a string, the property is removed.
+   * When the last segment is a keyed `{_key}` segment or a numeric index,
+   * the node at that array position is removed.
+   *
+   * @example
+   * ```ts
+   * // Remove a property
+   * raise({type: 'unset', at: [{_key: 'b1'}, 'level']})
+   *
+   * // Remove a node from an array
+   * raise({type: 'unset', at: [{_key: 'list'}, 'items', {_key: 'item3'}]})
+   * ```
+   */
+  type: StrictExtract<SyntheticBehaviorEventType, 'unset'>;
+  at: Path;
 } | AbstractBehaviorEvent;
 /**
  * @beta
@@ -2275,5 +2446,5 @@ type BehaviorActionSet<TBehaviorEvent, TGuardResponse> = (payload: {
   event: TBehaviorEvent;
   dom: EditorDom;
 }, guardResponse: TGuardResponse) => Array<BehaviorAction>;
-export { BlockAnnotationRenderProps as $, PortableTextTextBlock$1 as A, MutationEvent as At, EditorSelector as B, ListDefinition as C, RenderStyleFunction as Ct, PortableTextChild$1 as D, HotkeyOptions as Dt, PortableTextBlock$1 as E, PortableTextEditableProps as Et, BlockOffset as F, KeyedSegment as Ft, EditorConfig as G, EditorProvider as H, useEditor as I, Path as It, defineBehavior as J, EditorEvent as K, defaultKeyGenerator as L, StyleDefinition as M, AnnotationPath as Mt, StyleSchemaType$1 as N, BlockPath as Nt, PortableTextObject$1 as O, PortableTextEditor as Ot, defineSchema as P, ChildPath as Pt, AddedAnnotationPaths as Q, usePortableTextEditorSelection as R, InlineObjectSchemaType$1 as S, RenderPlaceholderFunction as St, Patch$1 as T, PortableTextEditable as Tt, EditorProviderProps as U, useEditorSelector as V, Editor as W, EditorContext as X, BehaviorGuard as Y, EditorSnapshot as Z, BlockObjectSchemaType$1 as _, RenderBlockFunction as _t, forward as a, EditableAPIDeleteOptions as at, FieldDefinition as b, RenderEditableFunction as bt, CustomBehaviorEvent as c, InvalidValueResolution as ct, SyntheticBehaviorEvent as d, OnPasteResult as dt, BlockChildRenderProps as et, PatchesEvent as f, OnPasteResultOrPromise as ft, BlockObjectDefinition as g, RenderAnnotationFunction as gt, BaseDefinition as h, RangeDecorationOnMovedDetails as ht, execute as i, BlockStyleRenderProps as it, SchemaDefinition$1 as j, EditorSchema as jt, PortableTextSpan$1 as k, EditorEmittedEvent as kt, InsertPlacement as l, OnCopyFn as lt, AnnotationSchemaType$1 as m, RangeDecoration as mt, BehaviorActionSet as n, BlockListItemRenderProps as nt, raise as o, EditorSelection as ot, AnnotationDefinition as p, PasteData as pt, Behavior as q, effect as r, BlockRenderProps as rt, BehaviorEvent as s, EditorSelectionPoint as st, BehaviorAction as t, BlockDecoratorRenderProps as tt, NativeBehaviorEvent as u, OnPasteFn as ut, DecoratorDefinition as v, RenderChildFunction as vt, ListSchemaType$1 as w, ScrollSelectionIntoViewFunction as wt, InlineObjectDefinition as x, RenderListItemFunction as xt, DecoratorSchemaType$1 as y, RenderDecoratorFunction as yt, usePortableTextEditor as z };
+export { EditorSnapshot as $, PortableTextTextBlock$1 as A, PortableTextEditor as At, EditorSelector as B, ListDefinition as C, RenderListItemFunction as Ct, PortableTextChild$1 as D, PortableTextEditable as Dt, PortableTextBlock$1 as E, ScrollSelectionIntoViewFunction as Et, BlockOffset as F, EditorConfig as G, EditorProvider as H, useEditor as I, MutationEvent as J, EditorEvent as K, defaultKeyGenerator as L, StyleDefinition as M, StyleSchemaType$1 as N, PortableTextObject$1 as O, PortableTextEditableProps as Ot, defineSchema as P, EditorContext as Q, usePortableTextEditorSelection as R, InlineObjectSchemaType$1 as S, RenderEditableFunction as St, Patch$1 as T, RenderStyleFunction as Tt, EditorProviderProps as U, useEditorSelector as V, Editor as W, defineBehavior as X, Behavior as Y, BehaviorGuard as Z, BlockObjectSchemaType$1 as _, RangeDecorationOnMovedDetails as _t, forward as a, BlockRenderProps as at, FieldDefinition$1 as b, RenderChildFunction as bt, CustomBehaviorEvent as c, EditorSelection as ct, SyntheticBehaviorEvent as d, OnCopyFn as dt, AddedAnnotationPaths as et, PatchesEvent as f, OnPasteFn as ft, BlockObjectDefinition as g, RangeDecoration as gt, BaseDefinition as h, PasteData as ht, execute as i, BlockListItemRenderProps as it, SchemaDefinition$1 as j, PortableTextSpan$1 as k, HotkeyOptions as kt, InsertPlacement as l, EditorSelectionPoint as lt, AnnotationSchemaType$1 as m, OnPasteResultOrPromise as mt, BehaviorActionSet as n, BlockChildRenderProps as nt, raise as o, BlockStyleRenderProps as ot, AnnotationDefinition as p, OnPasteResult as pt, EditorEmittedEvent as q, effect as r, BlockDecoratorRenderProps as rt, BehaviorEvent as s, EditableAPIDeleteOptions as st, BehaviorAction as t, BlockAnnotationRenderProps as tt, NativeBehaviorEvent as u, InvalidValueResolution as ut, DecoratorDefinition as v, RenderAnnotationFunction as vt, ListSchemaType$1 as w, RenderPlaceholderFunction as wt, InlineObjectDefinition as x, RenderDecoratorFunction as xt, DecoratorSchemaType$1 as y, RenderBlockFunction as yt, usePortableTextEditor as z };
 //# sourceMappingURL=behavior.types.action.d.ts.map