@portabletext/editor 6.3.2 → 6.5.0

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

@@ -1,8 +1,8 @@
 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, PortableTextListBlock, 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 { 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 { ActorRef, ActorRefFrom, EventObject, Snapshot } from "xstate";
-import * as react8 from "react";
+import * as react4 from "react";
 import React$1, { BaseSyntheticEvent, ClipboardEvent as ClipboardEvent$1, FocusEvent, JSX, PropsWithChildren, ReactElement, RefObject, TextareaHTMLAttributes } from "react";
 import { Patch, Patch as Patch$1 } from "@portabletext/patches";
 type MIMEType = `${string}/${string}`;
@@ -111,157 +111,61 @@ type ChildPath = [{
  */
 type EditorSchema = Schema;
 /**
- * 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: Descendant[];
-  selection: Selection$1;
-  operations: Operation[];
-  marks: EditorMarks | null;
-  dirtyPaths: Path$1[];
-  dirtyPathKeys: Set<string>;
-  flushing: boolean;
-  normalizing: boolean;
-  batchingDirtyPaths: boolean;
-  pathRefs: Set<PathRef>;
-  pointRefs: Set<PointRef>;
-  rangeRefs: Set<RangeRef>;
-  apply: (operation: Operation) => void;
-  createSpan: () => Text$1;
-  getDirtyPaths: (operation: Operation) => Path$1[];
-  isElementReadOnly: (element: Element$1) => boolean;
-  isInline: (element: Element$1) => boolean;
-  isSelectable: (element: Element$1) => boolean;
-  normalizeNode: (entry: NodeEntry, 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 = ExtendedType<'Editor', BaseEditor>;
-type BaseSelection = Range | null;
-type Selection$1 = ExtendedType<'Selection', BaseSelection>;
-type EditorMarks = Omit<Text$1, 'text'>;
-interface EditorInterface {
-  isElementReadOnly: (editor: Editor$1, element: Element$1) => boolean;
-  isInline: (editor: Editor$1, value: Element$1) => boolean;
-  isSelectable: (editor: Editor$1, element: Element$1) => boolean;
-}
-declare const Editor$1: EditorInterface;
-/**
- * `Element` objects are a type of node in a Slate document that contain other
- * element nodes or text nodes. They can be either "blocks" or "inlines"
- * depending on the Slate editor's configuration.
- */
-interface BaseElement {
-  children: Descendant[];
-}
-type Element$1 = ExtendedType<'Element', BaseElement>;
-interface ElementInterface {
-  /**
-   * Check if a value implements the 'Ancestor' interface.
-   */
-  isAncestor: (value: any, schema: EditorSchema) => value is Ancestor;
-  /**
-   * Check if a value implements the `Element` interface.
-   */
-  isElement: (value: any, schema: EditorSchema) => value is Element$1;
-}
-declare const Element$1: ElementInterface;
-/**
- * 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.
+ * `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 Location = Path$1 | Point | Range;
+type Path$1 = number[];
+type Node$1 = PortableTextTextBlock | PortableTextObject | PortableTextSpan;
+type TextDirection = 'forward' | 'backward';
 /**
- * Extendable Custom Types Interface
+ * `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.
  */
-type ExtendableTypes = 'Editor' | 'Element' | 'ObjectNode' | 'Text' | 'Selection' | 'Range' | 'Point' | 'Operation' | 'InsertNodeOperation' | 'InsertTextOperation' | 'RemoveNodeOperation' | 'RemoveTextOperation' | 'SetNodeOperation' | 'SetSelectionOperation';
-interface CustomTypes {
-  [key: string]: unknown;
+interface Point {
+  path: number[];
+  offset: number;
 }
-type ExtendedType<K$1 extends ExtendableTypes, B> = unknown extends CustomTypes[K$1] ? B : CustomTypes[K$1];
 /**
- * `ObjectNode` represents a node with semantic content but no children or text.
- * Block objects and inline objects are ObjectNodes in the tree.
+ * `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 BaseObjectNode {
-  _type: string;
-  _key: string;
-  [key: string]: unknown;
+interface Range {
+  anchor: Point;
+  focus: Point;
 }
-type ObjectNode = ExtendedType<'ObjectNode', BaseObjectNode>;
-type Node$1 = Editor$1 | Element$1 | ObjectNode | Text$1;
-/**
- * The `Descendant` union type represents nodes that are descendants in the
- * tree. It is returned as a convenience in certain cases to narrow a value
- * further than the more generic `Node` union.
- */
-type Descendant = Element$1 | ObjectNode | Text$1;
-/**
- * The `Ancestor` union type represents nodes that are ancestors in the tree.
- * It is returned as a convenience in certain cases to narrow a value further
- * than the more generic `Node` union.
- */
-type Ancestor = Editor$1 | Element$1;
-/**
- * `NodeEntry` objects are returned when iterating over the nodes in a Slate
- * document tree. They consist of the node and its `Path` relative to the root
- * node in the document.
- */
-type NodeEntry<T extends Node$1 = Node$1> = [T, Path$1];
-type BaseInsertNodeOperation = {
+type InsertNodeOperation = {
   type: 'insert_node';
   path: Path$1;
   node: Node$1;
 };
-type InsertNodeOperation = ExtendedType<'InsertNodeOperation', BaseInsertNodeOperation>;
-type BaseInsertTextOperation = {
+type InsertTextOperation = {
   type: 'insert_text';
   path: Path$1;
   offset: number;
   text: string;
 };
-type InsertTextOperation = ExtendedType<'InsertTextOperation', BaseInsertTextOperation>;
-type BaseRemoveNodeOperation = {
+type RemoveNodeOperation = {
   type: 'remove_node';
   path: Path$1;
   node: Node$1;
 };
-type RemoveNodeOperation = ExtendedType<'RemoveNodeOperation', BaseRemoveNodeOperation>;
-type BaseRemoveTextOperation = {
+type RemoveTextOperation = {
   type: 'remove_text';
   path: Path$1;
   offset: number;
   text: string;
 };
-type RemoveTextOperation = ExtendedType<'RemoveTextOperation', BaseRemoveTextOperation>;
-type BaseSetNodeOperation = {
+type SetNodeOperation = {
   type: 'set_node';
   path: Path$1;
   properties: Partial<Node$1>;
   newProperties: Partial<Node$1>;
 };
-type SetNodeOperation = ExtendedType<'SetNodeOperation', BaseSetNodeOperation>;
-type BaseSetSelectionOperation = {
+type SetSelectionOperation = {
   type: 'set_selection';
   properties: null;
   newProperties: Range;
@@ -274,34 +178,19 @@ type BaseSetSelectionOperation = {
   properties: Range;
   newProperties: null;
 };
-type SetSelectionOperation = ExtendedType<'SetSelectionOperation', BaseSetSelectionOperation>;
-type NodeOperation = InsertNodeOperation | RemoveNodeOperation | SetNodeOperation;
-type SelectionOperation = SetSelectionOperation;
-type TextOperation = InsertTextOperation | RemoveTextOperation;
+type Operation = InsertNodeOperation | RemoveNodeOperation | SetNodeOperation | SetSelectionOperation | InsertTextOperation | RemoveTextOperation;
+type DecoratedRange = Range & {
+  rangeDecoration: RangeDecoration;
+};
 /**
- * `Operation` objects define the low-level instructions that Slate editors use
- * to apply changes to their internal state. Representing all changes as
- * operations is what allows Slate editors to easily implement history,
- * collaboration, and other features.
+ * 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 BaseOperation = NodeOperation | SelectionOperation | TextOperation;
-type Operation = ExtendedType<'Operation', BaseOperation>;
-interface OperationInterface {
-  /**
-   * Check if a value is an `Operation` object.
-   */
-  isOperation: (value: any) => value is Operation;
-  /**
-   * Check if a value is a list of `Operation` objects.
-   */
-  isOperationList: (value: any) => value is Operation[];
-  /**
-   * Invert an operation, returning a new operation that will exactly undo the
-   * original when applied.
-   */
-  inverse: (op: Operation) => Operation;
-}
-declare const Operation: OperationInterface;
+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
@@ -313,118 +202,9 @@ interface PathRef {
   unref(): Path$1 | null;
 }
 interface PathRefInterface {
-  /**
-   * Transform the path ref's current value by an operation.
-   */
   transform: (ref: PathRef, op: Operation) => void;
 }
 declare const PathRef: PathRefInterface;
-/**
- * `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[];
-interface PathAncestorsOptions {
-  reverse?: boolean;
-}
-interface PathLevelsOptions {
-  reverse?: boolean;
-}
-interface PathInterface {
-  /**
-   * Get a list of ancestor paths for a given path.
-   *
-   * The paths are sorted from shallowest to deepest ancestor. However, if the
-   * `reverse: true` option is passed, they are reversed.
-   */
-  ancestors: (path: Path$1, options?: PathAncestorsOptions) => Path$1[];
-  /**
-   * Get the common ancestor path of two paths.
-   */
-  common: (path: Path$1, another: Path$1) => Path$1;
-  /**
-   * Compare a path to another, returning an integer indicating whether the path
-   * was before, at, or after the other.
-   *
-   * Note: Two paths of unequal length can still receive a `0` result if one is
-   * directly above or below the other. If you want exact matching, use
-   * [[Path.equals]] instead.
-   */
-  compare: (path: Path$1, another: Path$1) => -1 | 0 | 1;
-  /**
-   * Check if a path ends before one of the indexes in another.
-   */
-  endsBefore: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is exactly equal to another.
-   */
-  equals: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if the path of previous sibling node exists
-   */
-  hasPrevious: (path: Path$1) => boolean;
-  /**
-   * Check if a path is after another.
-   */
-  isAfter: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is an ancestor of another.
-   */
-  isAncestor: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is before another.
-   */
-  isBefore: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is equal to or an ancestor of another.
-   */
-  isCommon: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is a descendant of another.
-   */
-  isDescendant: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check is a value implements the `Path` interface.
-   */
-  isPath: (value: any) => value is Path$1;
-  /**
-   * Check if a path is a sibling of another.
-   */
-  isSibling: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Get a list of paths at every level down to a path. Note: this is the same
-   * as `Path.ancestors`, but including the path itself.
-   *
-   * The paths are sorted from shallowest to deepest. However, if the `reverse:
-   * true` option is passed, they are reversed.
-   */
-  levels: (path: Path$1, options?: PathLevelsOptions) => Path$1[];
-  /**
-   * Given a path, get the path to the next sibling node.
-   */
-  next: (path: Path$1) => Path$1;
-  /**
-   * Returns whether this operation can affect paths or not. Used as an
-   * optimization when updating dirty paths during normalization.
-   */
-  operationCanTransformPath: (operation: Operation) => operation is InsertNodeOperation | RemoveNodeOperation;
-  /**
-   * Given a path, return a new path referring to the parent node above it.
-   */
-  parent: (path: Path$1) => Path$1;
-  /**
-   * Given a path, get the path to the previous sibling node.
-   */
-  previous: (path: Path$1) => Path$1;
-  /**
-   * Transform a path by an operation.
-   */
-  transform: (path: Path$1, operation: Operation) => Path$1 | null;
-}
-declare const Path$1: PathInterface;
-type RangeDirection = TextDirection | 'outward' | 'inward';
-type TextDirection = 'forward' | 'backward';
 /**
  * `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
@@ -436,59 +216,9 @@ interface PointRef {
   unref(): Point | null;
 }
 interface PointRefInterface {
-  /**
-   * Transform the point ref's current value by an operation.
-   */
   transform: (ref: PointRef, op: Operation) => void;
 }
 declare const PointRef: PointRefInterface;
-/**
- * `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 BasePoint {
-  path: Path$1;
-  offset: number;
-}
-type Point = ExtendedType<'Point', BasePoint>;
-interface PointTransformOptions {
-  affinity?: TextDirection | null;
-}
-interface PointInterface {
-  /**
-   * Compare a point to another, returning an integer indicating whether the
-   * point was before, at, or after the other.
-   */
-  compare: (point: Point, another: Point) => -1 | 0 | 1;
-  /**
-   * Check if a point is after another.
-   */
-  isAfter: (point: Point, another: Point) => boolean;
-  /**
-   * Check if a point is before another.
-   */
-  isBefore: (point: Point, another: Point) => boolean;
-  /**
-   * Check if a point is exactly equal to another.
-   */
-  equals: (point: Point, another: Point) => boolean;
-  /**
-   * Check if a value implements the `Point` interface.
-   */
-  isPoint: (value: any) => value is Point;
-  /**
-   * Transform a point by an operation.
-   */
-  transform: (point: Point, op: Operation, options?: PointTransformOptions) => Point | null;
-}
-declare const Point: PointInterface;
-/**
- * `PointEntry` objects are returned when iterating over `Point` objects that
- * belong to a range.
- */
-type PointEntry = [Point, 'anchor' | 'focus'];
 /**
  * `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
@@ -499,140 +229,50 @@ interface RangeRef {
   affinity: 'forward' | 'backward' | 'outward' | 'inward' | null;
   unref(): Range | null;
 }
-interface RangeRefInterface {
-  /**
-   * Transform the range ref's current value by an operation.
-   */
-  transform: (ref: RangeRef, op: Operation) => void;
-}
-declare const RangeRef: RangeRefInterface;
-/**
- * `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 BaseRange {
-  anchor: Point;
-  focus: Point;
-}
-type Range = ExtendedType<'Range', BaseRange>;
-interface RangeEdgesOptions {
-  reverse?: boolean;
-}
-interface RangeTransformOptions {
-  affinity?: RangeDirection | null;
-}
-interface RangeInterface {
-  /**
-   * Get the start and end points of a range, in the order in which they appear
-   * in the document.
-   */
-  edges: (range: Range, options?: RangeEdgesOptions) => [Point, Point];
-  /**
-   * Get the end point of a range.
-   */
-  end: (range: Range) => Point;
-  /**
-   * Check if a range is exactly equal to another.
-   */
-  equals: (range: Range, another: Range) => boolean;
-  /**
-   * Check if a range includes a path, a point or part of another range.
-   */
-  includes: (range: Range, target: Path$1 | Point | Range) => boolean;
-  /**
-   * Get the intersection of a range with another.
-   */
-  intersection: (range: Range, another: Range) => Range | null;
-  /**
-   * Check if a range is backward, meaning that its anchor point appears in the
-   * document _after_ its focus point.
-   */
-  isBackward: (range: Range) => boolean;
-  /**
-   * Check if a range is collapsed, meaning that both its anchor and focus
-   * points refer to the exact same position in the document.
-   */
-  isCollapsed: (range: Range) => boolean;
-  /**
-   * Check if a range is expanded.
-   *
-   * This is the opposite of [[Range.isCollapsed]] and is provided for legibility.
-   */
-  isExpanded: (range: Range) => boolean;
-  /**
-   * Check if a range is forward.
-   *
-   * This is the opposite of [[Range.isBackward]] and is provided for legibility.
-   */
-  isForward: (range: Range) => boolean;
-  /**
-   * Check if a value implements the [[Range]] interface.
-   */
-  isRange: (value: any) => value is Range;
-  /**
-   * Iterate through all of the point entries in a range.
-   */
-  points: (range: Range) => Generator<PointEntry, void, undefined>;
-  /**
-   * Get the start point of a range.
-   */
-  start: (range: Range) => Point;
-  /**
-   * Transform a range by an operation.
-   */
-  transform: (range: Range, op: Operation, options?: RangeTransformOptions) => Range | null;
-}
-declare const Range: RangeInterface;
 /**
- * `Text` objects represent the nodes that contain the actual text content of a
- * Slate document along with any formatting properties. They are always leaf
- * nodes in the document tree as they cannot contain any children.
+ * 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 BaseText {
-  text: string;
-}
-type Text$1 = ExtendedType<'Text', BaseText>;
-interface LeafPosition {
-  start: number;
-  end: number;
-  isFirst?: true;
-  isLast?: true;
-}
-interface TextEqualsOptions {
-  loose?: boolean;
-}
-type DecoratedRange$1 = Range & {
-  /**
-   * Customize how another decoration is merged into a text node. If not specified, `Object.assign` would be used.
-   * It is useful for overlapping decorations with the same key but different values.
-   */
-  merge?: (leaf: Text$1, decoration: object) => void;
-};
-interface TextInterface {
-  /**
-   * Check if two text nodes are equal.
-   *
-   * When loose is set, the text is not compared. This is
-   * used to check whether sibling text nodes can be merged.
-   */
-  equals: (text: Text$1, another: Text$1, options?: TextEqualsOptions) => boolean;
-  /**
-   * Check if a value implements the `Text` interface.
-   */
-  isText: (value: any, schema: EditorSchema) => value is Text$1;
-  /**
-   * Get the leaves for a text node given decorations.
-   */
-  decorations: (node: Text$1, decorations: DecoratedRange$1[]) => {
-    leaf: Text$1;
-    position?: LeafPosition;
-  }[];
+interface BaseEditor {
+  children: PortableTextBlock[];
+  selection: Selection$1;
+  operations: Operation[];
+  marks: EditorMarks | null;
+  dirtyPaths: Path$1[];
+  dirtyPathKeys: Set<string>;
+  flushing: boolean;
+  normalizing: boolean;
+  batchingDirtyPaths: boolean;
+  pathRefs: Set<PathRef>;
+  pointRefs: Set<PointRef>;
+  rangeRefs: Set<RangeRef>;
+  apply: (operation: Operation) => void;
+  createSpan: () => PortableTextSpan;
+  getDirtyPaths: (operation: Operation) => Path$1[];
+  isElementReadOnly: (element: PortableTextTextBlock | PortableTextObject) => boolean;
+  isInline: (element: PortableTextTextBlock | PortableTextObject) => boolean;
+  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;
 }
-declare const Text$1: TextInterface;
-type DecoratedRange = BaseRange & {
-  rangeDecoration: RangeDecoration;
-};
+type Editor$1 = BaseEditor & ReactEditor & PortableTextSlateEditor;
+type Selection$1 = Range | null;
+type EditorMarks = Omit<PortableTextSpan, 'text'>;
 type StringDiff = {
   start: number;
   end: number;
@@ -688,11 +328,10 @@ interface DOMEditor extends BaseEditor {
   domPlaceholder: string;
   domPlaceholderElement: HTMLElement | null;
   keyToElement: WeakMap<Key, HTMLElement>;
-  nodeToIndex: WeakMap<Node$1, number>;
-  nodeToParent: WeakMap<Node$1, Ancestor>;
-  elementToNode: WeakMap<HTMLElement, Node$1>;
-  nodeToElement: WeakMap<Node$1, HTMLElement>;
-  nodeToKey: WeakMap<Node$1, Key>;
+  nodeToIndex: WeakMap<Editor$1 | Node$1, number>;
+  nodeToParent: WeakMap<Editor$1 | Node$1, Editor$1 | Node$1>;
+  elementToNode: WeakMap<HTMLElement, Editor$1 | Node$1>;
+  nodeToKey: WeakMap<Editor$1 | Node$1, Key>;
   readOnly: boolean;
   focused: boolean;
   composing: boolean;
@@ -701,8 +340,8 @@ interface DOMEditor extends BaseEditor {
     operation?: Operation;
   }) => void) | null;
   scheduleFlush: (() => void) | null;
-  pendingInsertionMarks: Partial<Text$1> | null;
-  userMarks: Partial<Text$1> | null;
+  pendingInsertionMarks: EditorMarks | null;
+  userMarks: EditorMarks | null;
   pendingDiffs: TextDiff[];
   pendingAction: Action | null;
   pendingSelection: Range | null;
@@ -724,11 +363,11 @@ interface DOMEditorInterface {
   /**
    * Find a key for a Slate node.
    */
-  findKey: (editor: Editor$1, node: Node$1) => Key;
+  findKey: (editor: Editor$1, node: Editor$1 | Node$1) => Key;
   /**
    * Find the path of Slate node.
    */
-  findPath: (editor: Editor$1, node: Node$1) => Path$1;
+  findPath: (editor: Editor$1, node: Editor$1 | Node$1) => Path$1;
   /**
    * Focus the editor.
    */
@@ -776,7 +415,7 @@ interface DOMEditorInterface {
   /**
    * Find the native DOM element from a Slate node.
    */
-  toDOMNode: (editor: Editor$1, node: Node$1) => HTMLElement;
+  toDOMNode: (editor: Editor$1, node: Editor$1 | Node$1) => HTMLElement;
   /**
    * Find a native DOM selection point from a Slate point.
    */
@@ -793,7 +432,7 @@ interface DOMEditorInterface {
   /**
    * Find a Slate node from a native DOM `element`.
    */
-  toSlateNode: (editor: Editor$1, domNode: DOMNode) => Node$1;
+  toSlateNode: (editor: Editor$1, domNode: DOMNode) => Editor$1 | Node$1;
   /**
    * Find a Slate point from a DOM selection's `domNode` and `domOffset`.
    */
@@ -821,24 +460,6 @@ declare const DOMEditor: DOMEditorInterface;
 interface ReactEditor extends DOMEditor {}
 interface ReactEditorInterface extends DOMEditorInterface {}
 declare const ReactEditor: ReactEditorInterface;
-interface ObjectElement {
-  _type: string;
-  _key: string;
-  children: Descendant[];
-  [key: string]: unknown;
-}
-interface SlateTextBlock extends Omit<PortableTextTextBlock, 'children'> {
-  children: Descendant[];
-}
-declare module '../slate/index' {
-  interface CustomTypes {
-    Editor: BaseEditor & ReactEditor & PortableTextSlateEditor;
-    Element: SlateTextBlock | ObjectElement;
-    ObjectNode: ObjectElement;
-    Text: PortableTextSpan;
-  }
-}
-//# sourceMappingURL=slate.d.ts.map
 type HistoryItem = {
   operations: Operation[];
   timestamp: Date;
@@ -856,10 +477,6 @@ type RemotePatch = {
 interface PortableTextSlateEditor extends ReactEditor {
   _key: 'editor';
   _type: 'editor';
-  isTextBlock: (value: unknown) => value is PortableTextTextBlock;
-  isTextSpan: (value: unknown) => value is PortableTextSpan;
-  isListBlock: (value: unknown) => value is PortableTextListBlock;
-  isObjectNode: (value: unknown) => boolean;
   schema: EditorSchema;
   decoratedRanges: Array<DecoratedRange>;
   decoratorState: Record<string, boolean | undefined>;
@@ -936,15 +553,11 @@ type PatchEvent = {
   type: 'patch';
   patch: Patch;
 };
-type SlateEditor = {
-  instance: PortableTextSlateEditor;
-  initialValue: Array<Descendant>;
-};
 type InternalEditor = Editor & {
   _internal: {
     editable: EditableAPI;
     editorActor: EditorActor;
-    slateEditor: SlateEditor;
+    slateEditor: PortableTextSlateEditor;
   };
 };
 /**
@@ -1386,7 +999,7 @@ type PortableTextEditableProps = Omit<TextareaHTMLAttributes<HTMLDivElement>, 'o
  * ```
  * @group Components
  */
-declare const PortableTextEditable: react8.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react8.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
+declare const PortableTextEditable: react4.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react4.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
 /** @beta */
 interface EditableAPIDeleteOptions {
   mode?: 'blocks' | 'children' | 'selected';
@@ -2022,7 +1635,7 @@ declare const editorMachine: xstate73.StateMachine<{
   initialValue?: Array<PortableTextBlock>;
 }, xstate73.NonReducibleUnknown, InternalPatchEvent | MutationEvent | PatchesEvent | {
   type: "blurred";
-  event: react8.FocusEvent<HTMLDivElement, Element>;
+  event: react4.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "done loading";
 } | {
@@ -2034,7 +1647,7 @@ declare const editorMachine: xstate73.StateMachine<{
   data: unknown;
 } | {
   type: "focused";
-  event: react8.FocusEvent<HTMLDivElement, Element>;
+  event: react4.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "invalid value";
   resolution: InvalidValueResolution | null;