slate 0.56.1 → 0.57.3

package/dist/transforms/index.d.ts

@@ -0,0 +1,108 @@
+export declare const Transforms: {
+    delete(editor: import("..").Editor, options?: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        distance?: number | undefined;
+        unit?: "character" | "word" | "line" | "block" | undefined;
+        reverse?: boolean | undefined;
+        hanging?: boolean | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    insertFragment(editor: import("..").Editor, fragment: import("..").Node[], options?: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        hanging?: boolean | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    insertText(editor: import("..").Editor, text: string, options?: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    collapse(editor: import("..").Editor, options?: {
+        edge?: "anchor" | "focus" | "start" | "end" | undefined;
+    }): void;
+    deselect(editor: import("..").Editor): void;
+    move(editor: import("..").Editor, options?: {
+        distance?: number | undefined;
+        unit?: "offset" | "character" | "word" | "line" | undefined;
+        reverse?: boolean | undefined;
+        edge?: "anchor" | "focus" | "start" | "end" | undefined;
+    }): void;
+    select(editor: import("..").Editor, target: import("..").Location): void;
+    setPoint(editor: import("..").Editor, props: Partial<import("..").Point>, options: {
+        edge?: "anchor" | "focus" | "start" | "end" | undefined;
+    }): void;
+    setSelection(editor: import("..").Editor, props: Partial<import("..").Range>): void;
+    insertNodes(editor: import("..").Editor, nodes: import("..").Editor | import("..").Element | import("..").Text | import("..").Node[], options?: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        match?: ((node: import("..").Node) => boolean) | undefined;
+        mode?: "highest" | "lowest" | undefined;
+        hanging?: boolean | undefined;
+        select?: boolean | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    liftNodes(editor: import("..").Editor, options?: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        match?: ((node: import("..").Node) => boolean) | undefined;
+        mode?: "highest" | "lowest" | "all" | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    mergeNodes(editor: import("..").Editor, options?: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        match?: ((node: import("..").Node) => boolean) | undefined;
+        mode?: "highest" | "lowest" | undefined;
+        hanging?: boolean | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    moveNodes(editor: import("..").Editor, options: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        match?: ((node: import("..").Node) => boolean) | undefined;
+        mode?: "highest" | "lowest" | "all" | undefined;
+        to: import("..").Path;
+        voids?: boolean | undefined;
+    }): void;
+    removeNodes(editor: import("..").Editor, options?: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        match?: ((node: import("..").Node) => boolean) | undefined;
+        mode?: "highest" | "lowest" | undefined;
+        hanging?: boolean | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    setNodes(editor: import("..").Editor, props: Partial<import("..").Editor> | Partial<import("..").Element> | Partial<import("..").Text>, options?: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        match?: ((node: import("..").Node) => boolean) | undefined;
+        mode?: "highest" | "lowest" | "all" | undefined;
+        hanging?: boolean | undefined;
+        split?: boolean | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    splitNodes(editor: import("..").Editor, options?: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        match?: ((node: import("..").Node) => boolean) | undefined;
+        mode?: "highest" | "lowest" | undefined;
+        always?: boolean | undefined;
+        height?: number | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    unsetNodes(editor: import("..").Editor, props: string | string[], options?: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        match?: ((node: import("..").Node) => boolean) | undefined;
+        mode?: "highest" | "lowest" | "all" | undefined;
+        split?: boolean | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    unwrapNodes(editor: import("..").Editor, options: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        match?: ((node: import("..").Node) => boolean) | undefined;
+        mode?: "highest" | "lowest" | "all" | undefined;
+        split?: boolean | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    wrapNodes(editor: import("..").Editor, element: import("..").Element, options?: {
+        at?: import("..").Path | import("..").Point | import("..").Range | undefined;
+        match?: ((node: import("..").Node) => boolean) | undefined;
+        mode?: "highest" | "lowest" | "all" | undefined;
+        split?: boolean | undefined;
+        voids?: boolean | undefined;
+    }): void;
+    transform(editor: import("..").Editor, op: import("..").Operation): void;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/transforms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../packages/slate/src/transforms/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKtB,CAAA"}

package/dist/{interfaces/editor/transforms → transforms}/node.d.ts

@@ -1,4 +1,4 @@
-import { Editor, Element, Node, Path, Point, Range, Text } from '../../..';
+import { Editor, Element, Node, Path, Point, Range, Text } from '..';
 export declare const NodeTransforms: {
     /**
      * Insert nodes at a specific location in the Editor.

package/dist/transforms/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../packages/slate/src/transforms/node.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,OAAO,EAEP,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,KAAK,EACL,IAAI,EAEL,MAAM,IAAI,CAAA;AAEX,eAAO,MAAM,cAAc;IACzB;;OAEG;;;;;;;;;IAmHH;;;OAGG;;;;;;;IA4DH;;;OAGG;;;;;;;;IAyIH;;OAEG;;;;;;;;IAgDH;;OAEG;;;;;;;;IA4CH;;OAEG;;;;;;;;;IAiGH;;OAEG;;;;;;;;;IA8HH;;OAEG;;;;;;;;IA0BH;;;OAGG;;;;;;;;IAwDH;;;OAGG;;;;;;;;CA+FJ,CAAA"}

package/dist/{interfaces/editor/transforms → transforms}/selection.d.ts

@@ -1,4 +1,4 @@
-import { Editor, Location, Point, Range } from '../../..';
+import { Editor, Location, Point, Range } from '..';
 export declare const SelectionTransforms: {
     /**
      * Collapse the selection.

package/dist/transforms/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../packages/slate/src/transforms/selection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAc,MAAM,IAAI,CAAA;AAE/D,eAAO,MAAM,mBAAmB;IAC9B;;OAEG;;;;IA0BH;;OAEG;;IAcH;;OAEG;;;;;;;IAsDH;;OAEG;;IA0BH;;OAEG;;;;IAgCH;;OAEG;;CAkCJ,CAAA"}

package/dist/{interfaces/editor/transforms → transforms}/text.d.ts

@@ -1,4 +1,4 @@
-import { Editor, Node, Path, Point, Range } from '../../..';
+import { Editor, Node, Path, Point, Range } from '..';
 export declare const TextTransforms: {
     /**
      * Delete content in the editor.

package/dist/transforms/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../packages/slate/src/transforms/text.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAGN,IAAI,EAEJ,IAAI,EAEJ,KAAK,EACL,KAAK,EAEN,MAAM,IAAI,CAAA;AAEX,eAAO,MAAM,cAAc;IACzB;;OAEG;;;;;;;;;IA0KH;;OAEG;;;;;;IAqNH;;OAEG;;;;;CA+CJ,CAAA"}

package/dist/utils/string.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Constants for string distance checking.
+ */
+/**
+ * Get the distance to the end of the first character in a string of text.
+ */
+export declare const getCharacterDistance: (text: string) => number;
+/**
+ * Get the distance to the end of the first word in a string of text.
+ */
+export declare const getWordDistance: (text: string) => number;
+//# sourceMappingURL=string.d.ts.map

package/dist/utils/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../packages/slate/src/utils/string.ts"],"names":[],"mappings":"AAAA;;GAEG;AASH;;GAEG;AAEH,eAAO,MAAM,oBAAoB,0BAuEhC,CAAA;AAED;;GAEG;AAEH,eAAO,MAAM,eAAe,0BAwB3B,CAAA"}

package/dist/utils/weak-maps.d.ts

@@ -0,0 +1,8 @@
+import { Editor, Path, PathRef, PointRef, RangeRef } from '..';
+export declare const DIRTY_PATHS: WeakMap<Editor, Path[]>;
+export declare const FLUSHING: WeakMap<Editor, boolean>;
+export declare const NORMALIZING: WeakMap<Editor, boolean>;
+export declare const PATH_REFS: WeakMap<Editor, Set<PathRef>>;
+export declare const POINT_REFS: WeakMap<Editor, Set<PointRef>>;
+export declare const RANGE_REFS: WeakMap<Editor, Set<RangeRef>>;
+//# sourceMappingURL=weak-maps.d.ts.map

package/dist/utils/weak-maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weak-maps.d.ts","sourceRoot":"","sources":["../packages/slate/src/utils/weak-maps.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAA;AAE9D,eAAO,MAAM,WAAW,EAAE,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,CAAiB,CAAA;AACjE,eAAO,MAAM,QAAQ,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAiB,CAAA;AAC/D,eAAO,MAAM,WAAW,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAiB,CAAA;AAClE,eAAO,MAAM,SAAS,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,CAAiB,CAAA;AACrE,eAAO,MAAM,UAAU,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAiB,CAAA;AACvE,eAAO,MAAM,UAAU,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAiB,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "slate",
   "description": "A completely customizable framework for building rich text editors.",
-  "version": "0.56.1",
+  "version": "0.57.3",
   "license": "MIT",
   "repository": "git://github.com/ianstormtaylor/slate.git",
   "main": "dist/index.js",
@@ -41,5 +41,5 @@
     "wysiwyg",
     "wysiwym"
   ],
-  "gitHead": "c2d7905e19d2112b1412d16322605c3f0585de44"
+  "gitHead": "036ee664aff6b4eb1f43b0790c96a3984beb954a"
 }

package/dist/interfaces/command.d.ts

@@ -1,91 +0,0 @@
-import { Node } from '..';
-/**
- * `Command` objects represent an action that a user is taking on the editor.
- * They capture the semantic "intent" of a user while they edit a document.
- */
-export interface Command {
-    type: string;
-    [key: string]: any;
-}
-export declare const Command: {
-    /**
-     * Check if a value is a `Command` object.
-     */
-    isCommand(value: any): value is Command;
-};
-/**
- * The `AddMarkCommand` adds properties to the text nodes in the selection.
- */
-export interface AddMarkCommand {
-    type: 'add_mark';
-    key: string;
-    value: any;
-}
-/**
- * The `DeleteBackwardCommand` delete's content backward, meaning before the
- * current selection, by a specific `unit` of distance.
- */
-export interface DeleteBackwardCommand {
-    type: 'delete_backward';
-    unit: 'character' | 'word' | 'line' | 'block';
-}
-/**
- * The `DeleteForwardCommand` delete's content forward, meaning after the
- * current selection, by a specific `unit` of distance.
- */
-export interface DeleteForwardCommand {
-    type: 'delete_forward';
-    unit: 'character' | 'word' | 'line' | 'block';
-}
-/**
- * The `DeleteFragmentCommand` delete's the content of the current selection.
- */
-export interface DeleteFragmentCommand {
-    type: 'delete_fragment';
-}
-/**
- * The `InsertBreakCommand` breaks a block in two at the current selection.
- */
-export interface InsertBreakCommand {
-    type: 'insert_break';
-}
-/**
- * The `InsertFragmentCommand` inserts a list of nodes at the current selection.
- */
-export interface InsertFragmentCommand {
-    type: 'insert_fragment';
-    fragment: Node[];
-}
-/**
- * The `InsertNodeCommand` inserts a node at the current selection.
- */
-export interface InsertNodeCommand {
-    type: 'insert_node';
-    node: Node;
-}
-/**
- * The `InsertTextCommand` inserts a string of text at the current selection.
- */
-export interface InsertTextCommand {
-    type: 'insert_text';
-    text: string;
-}
-/**
- * The `RemoveMarkCommand` removes properties from text nodes in the selection.
- */
-export interface RemoveMarkCommand {
-    type: 'remove_mark';
-    key: string;
-}
-/**
- * The `CoreCommand` union is a set of all of the commands that are recognized
- * by Slate's "core" out of the box.
- */
-export declare type CoreCommand = AddMarkCommand | DeleteBackwardCommand | DeleteForwardCommand | DeleteFragmentCommand | InsertBreakCommand | InsertFragmentCommand | InsertNodeCommand | InsertTextCommand | RemoveMarkCommand;
-export declare const CoreCommand: {
-    /**
-     * Check if a value is a `CoreCommand` object.
-     */
-    isCoreCommand(value: any): value is CoreCommand;
-};
-//# sourceMappingURL=command.d.ts.map

package/dist/interfaces/command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../packages/slate/src/interfaces/command.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAA;AAEzB;;;GAGG;AAEH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB;AAED,eAAO,MAAM,OAAO;IAClB;;OAEG;;CAKJ,CAAA;AAED;;GAEG;AAEH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,GAAG,CAAA;CACX;AAED;;;GAGG;AAEH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,iBAAiB,CAAA;IACvB,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;CAC9C;AAED;;;GAGG;AAEH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,gBAAgB,CAAA;IACtB,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;CAC9C;AAED;;GAEG;AAEH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,iBAAiB,CAAA;CACxB;AAED;;GAEG;AAEH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,cAAc,CAAA;CACrB;AAED;;GAEG;AAEH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,iBAAiB,CAAA;IACvB,QAAQ,EAAE,IAAI,EAAE,CAAA;CACjB;AAED;;GAEG;AAEH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,aAAa,CAAA;IACnB,IAAI,EAAE,IAAI,CAAA;CACX;AAED;;GAEG;AAEH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,aAAa,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;GAEG;AAEH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,aAAa,CAAA;IACnB,GAAG,EAAE,MAAM,CAAA;CACZ;AAED;;;GAGG;AAEH,oBAAY,WAAW,GACnB,cAAc,GACd,qBAAqB,GACrB,oBAAoB,GACpB,qBAAqB,GACrB,kBAAkB,GAClB,qBAAqB,GACrB,iBAAiB,GACjB,iBAAiB,GACjB,iBAAiB,CAAA;AAErB,eAAO,MAAM,WAAW;IACtB;;OAEG;;CA4BJ,CAAA"}

package/dist/interfaces/editor/index.d.ts

@@ -1,235 +0,0 @@
-import { Command, Element, Operation, Range, Node, NodeEntry } from '../..';
-/**
- * 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.
- */
-export interface Editor {
-    children: Node[];
-    selection: Range | null;
-    operations: Operation[];
-    marks: Record<string, any> | null;
-    apply: (operation: Operation) => void;
-    exec: (command: Command) => void;
-    isInline: (element: Element) => boolean;
-    isVoid: (element: Element) => boolean;
-    normalizeNode: (entry: NodeEntry) => void;
-    onChange: () => void;
-    [key: string]: any;
-}
-export declare const Editor: {
-    delete(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        distance?: number | undefined;
-        unit?: "character" | "word" | "line" | "block" | undefined;
-        reverse?: boolean | undefined;
-        hanging?: boolean | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    insertFragment(editor: Editor, fragment: Node[], options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        hanging?: boolean | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    insertText(editor: Editor, text: string, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    collapse(editor: Editor, options?: {
-        edge?: "start" | "end" | "anchor" | "focus" | undefined;
-    }): void;
-    deselect(editor: Editor): void;
-    move(editor: Editor, options?: {
-        distance?: number | undefined;
-        unit?: "offset" | "character" | "word" | "line" | undefined;
-        reverse?: boolean | undefined;
-        edge?: "start" | "end" | "anchor" | "focus" | undefined;
-    }): void;
-    select(editor: Editor, target: import("../location").Location): void;
-    setPoint(editor: Editor, props: Partial<import("../point").Point>, options: {
-        edge?: "start" | "end" | "anchor" | "focus" | undefined;
-    }): void;
-    setSelection(editor: Editor, props: Partial<Range>): void;
-    unhangRange(editor: Editor, range: Range, options?: {
-        voids?: boolean | undefined;
-    }): Range;
-    insertNodes(editor: Editor, nodes: Editor | Element | import("../text").Text | Node[], options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | undefined;
-        mode?: "highest" | "lowest" | undefined;
-        hanging?: boolean | undefined;
-        select?: boolean | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    liftNodes(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | undefined;
-        mode?: "highest" | "lowest" | "all" | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    mergeNodes(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | undefined;
-        mode?: "highest" | "lowest" | undefined;
-        hanging?: boolean | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    moveNodes(editor: Editor, options: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | undefined;
-        mode?: "highest" | "lowest" | "all" | undefined;
-        to: import("../path").Path;
-        voids?: boolean | undefined;
-    }): void;
-    removeNodes(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | undefined;
-        mode?: "highest" | "lowest" | undefined;
-        hanging?: boolean | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    setNodes(editor: Editor, props: Partial<Editor> | Partial<Element> | Partial<import("../text").Text>, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | undefined;
-        mode?: "highest" | "lowest" | "all" | undefined;
-        hanging?: boolean | undefined;
-        split?: boolean | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    splitNodes(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | undefined;
-        mode?: "highest" | "lowest" | undefined;
-        always?: boolean | undefined;
-        height?: number | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    unsetNodes(editor: Editor, props: string | string[], options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | undefined;
-        mode?: "highest" | "lowest" | "all" | undefined;
-        split?: boolean | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    unwrapNodes(editor: Editor, options: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | undefined;
-        mode?: "highest" | "lowest" | "all" | undefined;
-        split?: boolean | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    wrapNodes(editor: Editor, element: Element, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | undefined;
-        mode?: "highest" | "lowest" | "all" | undefined;
-        split?: boolean | undefined;
-        voids?: boolean | undefined;
-    }): void;
-    above<T extends import("../node").Ancestor>(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | ((node: Node) => node is T) | undefined;
-        mode?: "highest" | "lowest" | undefined;
-        voids?: boolean | undefined;
-    }): NodeEntry<T> | undefined;
-    after(editor: Editor, at: import("../location").Location, options?: {
-        distance?: number | undefined;
-        unit?: "offset" | "character" | "word" | "line" | "block" | undefined;
-    }): import("../point").Point | undefined;
-    before(editor: Editor, at: import("../location").Location, options?: {
-        distance?: number | undefined;
-        unit?: "offset" | "character" | "word" | "line" | "block" | undefined;
-    }): import("../point").Point | undefined;
-    edges(editor: Editor, at: import("../location").Location): [import("../point").Point, import("../point").Point];
-    end(editor: Editor, at: import("../location").Location): import("../point").Point;
-    first(editor: Editor, at: import("../location").Location): NodeEntry<Node>;
-    fragment(editor: Editor, at: import("../location").Location): import("../node").Descendant[];
-    isEnd(editor: Editor, point: import("../point").Point, at: import("../location").Location): boolean;
-    isEdge(editor: Editor, point: import("../point").Point, at: import("../location").Location): boolean;
-    isStart(editor: Editor, point: import("../point").Point, at: import("../location").Location): boolean;
-    last(editor: Editor, at: import("../location").Location): NodeEntry<Node>;
-    leaf(editor: Editor, at: import("../location").Location, options?: {
-        depth?: number | undefined;
-        edge?: "start" | "end" | undefined;
-    }): NodeEntry<import("../text").Text>;
-    levels<T_1 extends Node>(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | ((node: Node) => node is T_1) | undefined;
-        reverse?: boolean | undefined;
-        voids?: boolean | undefined;
-    }): Iterable<NodeEntry<T_1>>;
-    next<T_2 extends Node>(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | ((node: Node) => node is T_2) | undefined;
-        mode?: "highest" | "lowest" | "all" | undefined;
-        voids?: boolean | undefined;
-    }): NodeEntry<T_2> | undefined;
-    node(editor: Editor, at: import("../location").Location, options?: {
-        depth?: number | undefined;
-        edge?: "start" | "end" | undefined;
-    }): NodeEntry<Node>;
-    nodes<T_3 extends Node>(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | import("../location").Span | undefined;
-        match?: ((node: Node) => boolean) | ((node: Node) => node is T_3) | undefined;
-        mode?: "highest" | "lowest" | "all" | undefined;
-        universal?: boolean | undefined;
-        reverse?: boolean | undefined;
-        voids?: boolean | undefined;
-    }): Iterable<NodeEntry<T_3>>;
-    parent(editor: Editor, at: import("../location").Location, options?: {
-        depth?: number | undefined;
-        edge?: "start" | "end" | undefined;
-    }): NodeEntry<import("../node").Ancestor>;
-    path(editor: Editor, at: import("../location").Location, options?: {
-        depth?: number | undefined;
-        edge?: "start" | "end" | undefined;
-    }): import("../path").Path;
-    point(editor: Editor, at: import("../location").Location, options?: {
-        edge?: "start" | "end" | undefined;
-    }): import("../point").Point;
-    positions(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        unit?: "offset" | "character" | "word" | "line" | "block" | undefined;
-        reverse?: boolean | undefined;
-    }): Iterable<import("../point").Point>;
-    previous<T_4 extends Node>(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        match?: ((node: Node) => boolean) | ((node: Node) => node is T_4) | undefined;
-        mode?: "highest" | "lowest" | "all" | undefined;
-        voids?: boolean | undefined;
-    }): NodeEntry<T_4> | undefined;
-    range(editor: Editor, at: import("../location").Location, to?: Range | import("../path").Path | import("../point").Point | undefined): Range;
-    start(editor: Editor, at: import("../location").Location): import("../point").Point;
-    string(editor: Editor, at: import("../location").Location): string;
-    void(editor: Editor, options?: {
-        at?: Range | import("../path").Path | import("../point").Point | undefined;
-        mode?: "highest" | "lowest" | undefined;
-        voids?: boolean | undefined;
-    }): NodeEntry<Element> | undefined;
-    normalize(editor: Editor, options?: {
-        force?: boolean | undefined;
-    }): void;
-    transform(editor: Editor, op: Operation): void;
-    isBlock(editor: Editor, value: any): value is Element;
-    isEditor(value: any): value is Editor;
-    isInline(editor: Editor, value: any): value is Element;
-    isNormalizing(editor: Editor): boolean;
-    isVoid(editor: Editor, value: any): value is Element;
-    marks(editor: Editor): Record<string, any> | null;
-    pathRef(editor: Editor, path: import("../path").Path, options?: {
-        affinity?: "backward" | "forward" | null | undefined;
-    }): import("../path-ref").PathRef;
-    pathRefs(editor: Editor): Set<import("../path-ref").PathRef>;
-    pointRef(editor: Editor, point: import("../point").Point, options?: {
-        affinity?: "backward" | "forward" | null | undefined;
-    }): import("../point-ref").PointRef;
-    pointRefs(editor: Editor): Set<import("../point-ref").PointRef>;
-    rangeRef(editor: Editor, range: Range, options?: {
-        affinity?: "backward" | "forward" | "outward" | "inward" | null | undefined;
-    }): import("../range-ref").RangeRef;
-    rangeRefs(editor: Editor): Set<import("../range-ref").RangeRef>;
-    withoutNormalizing(editor: Editor, fn: () => void): void;
-    hasBlocks(editor: Editor, element: Element): boolean;
-    hasInlines(editor: Editor, element: Element): boolean;
-    hasTexts(editor: Editor, element: Element): boolean;
-    isEmpty(editor: Editor, element: Element): boolean;
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/interfaces/editor/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../packages/slate/src/interfaces/editor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAW3E;;;GAGG;AAEH,MAAM,WAAW,MAAM;IACrB,QAAQ,EAAE,IAAI,EAAE,CAAA;IAChB,SAAS,EAAE,KAAK,GAAG,IAAI,CAAA;IACvB,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAA;IACjC,KAAK,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,IAAI,CAAA;IACrC,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IAChC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAA;IACvC,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAA;IACrC,aAAa,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAA;IACzC,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB;AAED,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASlB,CAAA"}

package/dist/interfaces/editor/queries/element.d.ts

@@ -1,20 +0,0 @@
-import { Editor, Element } from '../../..';
-export declare const ElementQueries: {
-    /**
-     * Check if a node has block children.
-     */
-    hasBlocks(editor: Editor, element: Element): boolean;
-    /**
-     * Check if a node has inline and text children.
-     */
-    hasInlines(editor: Editor, element: Element): boolean;
-    /**
-     * Check if a node has text children.
-     */
-    hasTexts(editor: Editor, element: Element): boolean;
-    /**
-     * Check if an element is empty, accounting for void nodes.
-     */
-    isEmpty(editor: Editor, element: Element): boolean;
-};
-//# sourceMappingURL=element.d.ts.map

package/dist/interfaces/editor/queries/element.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"element.d.ts","sourceRoot":"","sources":["../../../packages/slate/src/interfaces/editor/queries/element.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAQ,MAAM,UAAU,CAAA;AAEhD,eAAO,MAAM,cAAc;IACzB;;OAEG;;IAMH;;OAEG;;IAQH;;OAEG;;IAMH;;OAEG;;CAaJ,CAAA"}

package/dist/interfaces/editor/queries/general.d.ts

@@ -1,69 +0,0 @@
-import { Editor, Path, Point, PathRef, PointRef, Element, Range, RangeRef } from '../../..';
-export declare const NORMALIZING: WeakMap<Editor, boolean>;
-export declare const PATH_REFS: WeakMap<Editor, Set<PathRef>>;
-export declare const POINT_REFS: WeakMap<Editor, Set<PointRef>>;
-export declare const RANGE_REFS: WeakMap<Editor, Set<RangeRef>>;
-export declare const GeneralQueries: {
-    /**
-     * Check if a value is a block `Element` object.
-     */
-    isBlock(editor: Editor, value: any): value is Element;
-    /**
-     * Check if a value is an `Editor` object.
-     */
-    isEditor(value: any): value is Editor;
-    /**
-     * Check if a value is an inline `Element` object.
-     */
-    isInline(editor: Editor, value: any): value is Element;
-    /**
-     * Check if the editor is currently normalizing after each operation.
-     */
-    isNormalizing(editor: Editor): boolean;
-    /**
-     * Check if a value is a void `Element` object.
-     */
-    isVoid(editor: Editor, value: any): value is Element;
-    /**
-     * Get the marks that would be added to text at the current selection.
-     */
-    marks(editor: Editor): Record<string, any> | null;
-    /**
-     * Create a mutable ref for a `Path` object, which will stay in sync as new
-     * operations are applied to the editor.
-     */
-    pathRef(editor: Editor, path: Path, options?: {
-        affinity?: "backward" | "forward" | null | undefined;
-    }): PathRef;
-    /**
-     * Get the set of currently tracked path refs of the editor.
-     */
-    pathRefs(editor: Editor): Set<PathRef>;
-    /**
-     * Create a mutable ref for a `Point` object, which will stay in sync as new
-     * operations are applied to the editor.
-     */
-    pointRef(editor: Editor, point: Point, options?: {
-        affinity?: "backward" | "forward" | null | undefined;
-    }): PointRef;
-    /**
-     * Get the set of currently tracked point refs of the editor.
-     */
-    pointRefs(editor: Editor): Set<PointRef>;
-    /**
-     * Create a mutable ref for a `Range` object, which will stay in sync as new
-     * operations are applied to the editor.
-     */
-    rangeRef(editor: Editor, range: Range, options?: {
-        affinity?: "backward" | "forward" | "outward" | "inward" | null | undefined;
-    }): RangeRef;
-    /**
-     * Get the set of currently tracked range refs of the editor.
-     */
-    rangeRefs(editor: Editor): Set<RangeRef>;
-    /**
-     * Call a function, deferring normalization until after it completes.
-     */
-    withoutNormalizing(editor: Editor, fn: () => void): void;
-};
-//# sourceMappingURL=general.d.ts.map

package/dist/interfaces/editor/queries/general.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"general.d.ts","sourceRoot":"","sources":["../../../packages/slate/src/interfaces/editor/queries/general.ts"],"names":[],"mappings":"AACA,OAAO,EACL,MAAM,EAEN,IAAI,EACJ,KAAK,EAEL,OAAO,EACP,QAAQ,EACR,OAAO,EAEP,KAAK,EACL,QAAQ,EAET,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,WAAW,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAiB,CAAA;AAClE,eAAO,MAAM,SAAS,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,CAAiB,CAAA;AACrE,eAAO,MAAM,UAAU,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAiB,CAAA;AACvE,eAAO,MAAM,UAAU,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAiB,CAAA;AAEvE,eAAO,MAAM,cAAc;IACzB;;OAEG;;IAMH;;OAEG;;IAkBH;;OAEG;;IAMH;;OAEG;;IAOH;;OAEG;;IAMH;;OAEG;;IAiDH;;;OAGG;;;;IA2BH;;OAEG;;IAaH;;;OAGG;;;;IA2BH;;OAEG;;IAaH;;;OAGG;;;;IA2BH;;OAEG;;IAaH;;OAEG;;CASJ,CAAA"}