@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/state/plugin.d.ts

@@ -0,0 +1,232 @@
+import { AnySchema } from "../model/schema.js";
+import "../model.js";
+import { EditorProps, EditorView } from "../view/view.js";
+import { EditorState, EditorStateConfig } from "./state.js";
+import { Transaction } from "./transaction.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+/**
+ * A value, or an Effect producing it. Plugin hooks may return either:
+ * plain values keep simple plugins simple, while Effects let plugins use
+ * services (reflected in the plugin's `R` type) and fail with typed
+ * errors (`E`).
+ *
+ * Note that a hook result is treated as an Effect whenever
+ * `Effect.isEffect` is true for it, so a plugin whose state is itself
+ * an Effect must wrap it in `Effect.succeed`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type MaybeEffect<A, E = never, R = never> = A | Effect.Effect<A, E, R>;
+/**
+ * The editor view type, as passed to commands (which may be called
+ * without a view, hence `undefined`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type EditorViewLike = EditorView<any, any, any> | undefined;
+/**
+ * The props a plugin adds to the editor view: the view's `EditorProps`.
+ * Function-valued props are bound to the plugin instance.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PluginProps<Sc extends AnySchema = AnySchema, E = never, R = never> = EditorProps<Sc, R, E, Plugin<any, Sc, never, never>>;
+/**
+ * A stateful object that can be installed in an editor by a plugin's
+ * `view` hook.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface PluginView<Sc extends AnySchema = AnySchema> {
+  /** Called whenever the view's state is updated. */
+  readonly update?: ((view: EditorView<Sc, any, any>, prevState: EditorState<Sc, any, any>) => void) | undefined;
+  /** Called when the view is destroyed or receives a state with different plugins. */
+  readonly destroy?: (() => void) | undefined;
+}
+/**
+ * A plugin spec may provide a state field (under its `state` property)
+ * of this type, which describes the state it wants to keep. Functions
+ * provided here are always called with the plugin instance as their
+ * `this` binding, and may return either a plain value or an Effect.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface StateField<PState, Sc extends AnySchema = AnySchema, E = never, R = never> {
+  /**
+   * Initialize the value of the field. `config` will be the object
+   * passed to `EditorState.create`. Note that `instance` is a
+   * half-initialized state instance, and will not have values for
+   * plugin fields initialized after this one.
+   */
+  readonly init: (config: EditorStateConfig<Sc>, instance: EditorState<Sc, any, any>) => MaybeEffect<PState, E, R>;
+  /**
+   * Apply the given transaction to this state field, producing a new
+   * field value. Note that the `newState` argument is again a partially
+   * constructed state does not yet contain the state from plugins coming
+   * after this one.
+   */
+  readonly apply: (tr: Transaction<Sc>, value: PState, oldState: EditorState<Sc, any, any>, newState: EditorState<Sc, any, any>) => MaybeEffect<PState, E, R>;
+  /**
+   * Convert this field to JSON. Optional, can be left off to disable
+   * JSON serialization for the field.
+   */
+  readonly toJSON?: ((value: PState) => unknown) | undefined;
+  /**
+   * Deserialize the JSON representation of this field. Note that the
+   * `state` argument is again a half-initialized state.
+   */
+  readonly fromJSON?: ((config: EditorStateConfig<Sc>, value: unknown, state: EditorState<Sc, any, any>) => MaybeEffect<PState, E, R>) | undefined;
+}
+/**
+ * This is the type passed to the `Plugin` constructor. It provides a
+ * definition for a plugin.
+ *
+ * The hooks that run while creating or updating states (`state.init`,
+ * `state.apply`, `state.fromJSON`, `filterTransaction` and
+ * `appendTransaction`) may return Effects; their error and requirement
+ * types become the plugin's `E` and `R`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface PluginSpec<PState = any, Sc extends AnySchema = AnySchema, E = never, R = never> {
+  /**
+   * The view props added by this plugin. Props that are functions will
+   * be bound to have the plugin instance as their `this` binding.
+   */
+  readonly props?: PluginProps<Sc, E, R> | undefined;
+  /**
+   * Allows a plugin to define a state field, an extra slot in the state
+   * object in which it can keep its own data.
+   */
+  readonly state?: StateField<PState, Sc, E, R> | undefined;
+  /**
+   * Can be used to make this a keyed plugin. You can have only one
+   * plugin with a given key in a given state, but it is possible to
+   * access the plugin's configuration and state through the key,
+   * without having access to the plugin instance object.
+   */
+  readonly key?: PluginKey<PState> | undefined;
+  /**
+   * When the plugin needs to interact with the editor view, or set
+   * something up in the DOM, use this field. The function will be
+   * called when the plugin's state is associated with an editor view.
+   */
+  readonly view?: ((view: EditorView<Sc, any, any>) => PluginView<Sc>) | undefined;
+  /**
+   * When present, this will be called before a transaction is applied
+   * by the state, allowing the plugin to cancel it (by returning
+   * false).
+   */
+  readonly filterTransaction?: ((tr: Transaction<Sc>, state: EditorState<Sc, any, any>) => MaybeEffect<boolean, E, R>) | undefined;
+  /**
+   * Allows the plugin to append another transaction to be applied after
+   * the given array of transactions. When another plugin appends a
+   * transaction after this was called, it is called again with the new
+   * state and new transactions—but only the new transactions, i.e. it
+   * won't be passed transactions that it already saw.
+   */
+  readonly appendTransaction?: ((transactions: ReadonlyArray<Transaction<Sc>>, oldState: EditorState<Sc, any, any>, newState: EditorState<Sc, any, any>) => MaybeEffect<Transaction<Sc> | null | undefined | void, E, R>) | undefined;
+  /**
+   * Additional properties are allowed on plugin specs, which can be
+   * read via `Plugin.spec`.
+   */
+  readonly [key: string]: unknown;
+}
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+export declare const PluginTypeId: unique symbol;
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+export type PluginTypeId = typeof PluginTypeId;
+/**
+ * Plugins bundle functionality that can be added to an editor. They are
+ * part of the editor state and may influence that state and the view
+ * that contains it.
+ *
+ * The type parameters are the plugin's state type, the schema it works
+ * with, and the errors (`E`) and requirements (`R`) of its effectful
+ * hooks, which are inferred from the spec:
+ *
+ * ```ts skip-type-checking
+ * const counter = new Plugin({
+ *   state: {
+ *     init: () => 0,
+ *     apply: (_tr, n) => Effect.map(Clock.currentTimeMillis, () => n + 1)
+ *   }
+ * }) // Plugin<number, AnySchema, never, never>
+ * ```
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Plugin<PState = any, Sc extends AnySchema = AnySchema, E = never, R = never> {
+  /** The plugin's spec object. */
+  readonly spec: PluginSpec<PState, Sc, E, R>;
+  readonly [PluginTypeId]: {
+    readonly _PState: (_: never) => PState;
+    readonly _E: (_: never) => E;
+    readonly _R: (_: never) => R;
+  };
+  /** The props exported by this plugin. */
+  readonly props: PluginProps<Sc, E, R>;
+  /** @internal */
+  readonly key: string;
+  /** Create a plugin. */
+  constructor(
+  /** The plugin's spec object. */
+  spec: PluginSpec<PState, Sc, E, R>);
+  /** Extract the plugin's state field from an editor state. */
+  getState(state: EditorState<any, any, any>): Option.Option<PState>;
+}
+/**
+ * Any plugin.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type AnyPlugin = Plugin<any, any, any, any>;
+/**
+ * The union of the error types of the given plugins.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type PluginErrors<P extends ReadonlyArray<AnyPlugin>> = P[number] extends (infer X) ? X extends Plugin<any, any, infer E, any> ? E : never : never;
+/**
+ * The union of the requirements of the given plugins.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type PluginRequirements<P extends ReadonlyArray<AnyPlugin>> = P[number] extends (infer X) ? X extends Plugin<any, any, any, infer R> ? R : never : never;
+/** @internal */
+export declare const getField: <A>(state: EditorState<any, any, any>, key: string) => Option.Option<A>;
+/**
+ * A key is used to tag plugins in a way that makes it possible to find
+ * them, given an editor state. Assigning a key does mean only one plugin
+ * of that type can be active in a state.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class PluginKey<PState = any> {
+  /** @internal */
+  readonly key: string;
+  /** Create a plugin key. */
+  constructor(name?: string);
+  /** Get the active plugin with this key, if any, from an editor state. */
+  get(state: EditorState<any, any, any>): Option.Option<Plugin<PState, any, any, any>>;
+  /** Get the plugin's state from an editor state. */
+  getState(state: EditorState<any, any, any>): Option.Option<PState>;
+}

package/dist/state/plugin.js

@@ -0,0 +1,82 @@
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+// src/state/plugin.ts
+function bindProps(obj, self, target) {
+	for (const prop in obj) {
+		let val = obj[prop];
+		if (Predicate.isFunction(val)) val = val.bind(self);
+		else if (prop === "handleDOMEvents") val = bindProps(val, self, {});
+		target[prop] = val;
+	}
+	return target;
+}
+const keys = Object.create(null);
+function createKey(name) {
+	if (name in keys) return name + "$" + ++keys[name];
+	keys[name] = 0;
+	return name + "$";
+}
+/**
+* @since 0.1.0
+* @category symbols
+*/
+const PluginTypeId = Symbol.for("effect-richtext/state/Plugin");
+/**
+* Plugins bundle functionality that can be added to an editor. They are
+* part of the editor state and may influence that state and the view
+* that contains it.
+*
+* The type parameters are the plugin's state type, the schema it works
+* with, and the errors (`E`) and requirements (`R`) of its effectful
+* hooks, which are inferred from the spec:
+*
+* ```ts skip-type-checking
+* const counter = new Plugin({
+*   state: {
+*     init: () => 0,
+*     apply: (_tr, n) => Effect.map(Clock.currentTimeMillis, () => n + 1)
+*   }
+* }) // Plugin<number, AnySchema, never, never>
+* ```
+*
+* @since 0.1.0
+* @category models
+*/
+var Plugin = class {
+	/** Create a plugin. */
+	constructor(spec) {
+		this.spec = spec;
+		this.props = {};
+		if (spec.props) bindProps(spec.props, this, this.props);
+		this.key = spec.key ? spec.key.key : createKey("plugin");
+	}
+	/** Extract the plugin's state field from an editor state. */
+	getState(state) {
+		return getField(state, this.key);
+	}
+};
+/** @internal */
+const getField = (state, key) => Object.prototype.hasOwnProperty.call(state.slots, key) ? Option.some(state.slots[key]) : Option.none();
+/**
+* A key is used to tag plugins in a way that makes it possible to find
+* them, given an editor state. Assigning a key does mean only one plugin
+* of that type can be active in a state.
+*
+* @since 0.1.0
+* @category models
+*/
+var PluginKey = class {
+	/** Create a plugin key. */
+	constructor(name = "key") {
+		this.key = createKey(name);
+	}
+	/** Get the active plugin with this key, if any, from an editor state. */
+	get(state) {
+		return Option.fromUndefinedOr(state.config.pluginsByKey[this.key]);
+	}
+	/** Get the plugin's state from an editor state. */
+	getState(state) {
+		return getField(state, this.key);
+	}
+};
+export { Plugin, PluginKey, PluginTypeId, getField };

package/dist/state/selection.d.ts

@@ -0,0 +1,297 @@
+import { ModelError, PositionError } from "../model/errors.js";
+import { ResolvedPos } from "../model/resolvedpos.js";
+import { Slice } from "../model/replace.js";
+import { AnySchema } from "../model/schema.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+import "../transform.js";
+import { Mappable } from "../transform/map.js";
+import { SelectionError } from "./errors.js";
+import { Transaction } from "./transaction.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as S from "effect/Schema";
+/**
+ * The JSON representation of a selection. It always includes the
+ * selection class's JSON id (see `Selection.jsonID`) under `type`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface SelectionJSON {
+  readonly type: string;
+  readonly [key: string]: unknown;
+}
+/**
+ * Something that can deserialize selections of a given type: usually
+ * the selection class itself, via a static `fromJSONUnsafe` method that
+ * throws a tagged error for invalid input.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface SelectionDeserializer {
+  readonly fromJSONUnsafe: (doc: Node<any>, json: any) => Selection<any>;
+}
+/**
+ * Superclass for editor selections. Every selection type should extend
+ * this. Should not be instantiated directly.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare abstract class Selection<Sc extends AnySchema = AnySchema> {
+  /**
+   * The resolved anchor of the selection (the side that stays in
+   * place when the selection is modified).
+   */
+  readonly $anchor: ResolvedPos<Sc>;
+  /**
+   * The resolved head of the selection (the side that moves when the
+   * selection is modified).
+   */
+  readonly $head: ResolvedPos<Sc>;
+  /** The ranges covered by the selection. */
+  readonly ranges: ReadonlyArray<SelectionRange<Sc>>;
+  /**
+   * Initialize a selection with the head and anchor and ranges. If no
+   * ranges are given, constructs a single range across `$anchor` and
+   * `$head`.
+   */
+  constructor(
+  /**
+   * The resolved anchor of the selection (the side that stays in
+   * place when the selection is modified).
+   */
+  $anchor: ResolvedPos<Sc>,
+  /**
+   * The resolved head of the selection (the side that moves when the
+   * selection is modified).
+   */
+  $head: ResolvedPos<Sc>, ranges?: ReadonlyArray<SelectionRange<Sc>>);
+  /** The selection's anchor, as an unresolved position. */
+  get anchor(): number;
+  /** The selection's head. */
+  get head(): number;
+  /** The lower bound of the selection's main range. */
+  get from(): number;
+  /** The upper bound of the selection's main range. */
+  get to(): number;
+  /** The resolved lower bound of the selection's main range. */
+  get $from(): ResolvedPos<Sc>;
+  /** The resolved upper bound of the selection's main range. */
+  get $to(): ResolvedPos<Sc>;
+  /** Indicates whether the selection contains any content. */
+  get empty(): boolean;
+  /**
+   * Controls whether, when a selection of this type is active in the
+   * browser, the selected range should be visible to the user.
+   * Defaults to `true`.
+   */
+  get visible(): boolean;
+  /** Test whether the selection is the same as another selection. */
+  abstract eq(selection: Selection<any>): boolean;
+  /**
+   * Map this selection through a mappable thing. `doc` should be the
+   * new document to which we are mapping.
+   */
+  abstract map(doc: Node<Sc>, mapping: Mappable): Selection<Sc>;
+  /** Get the content of this selection as a slice. */
+  content(): Slice<Sc>;
+  /**
+   * Replace the selection with a slice or, if no slice is given, delete
+   * the selection. Will append to the given transaction.
+   */
+  replace(tr: Transaction<Sc>, content?: Slice<Sc>): void;
+  /** Replace the selection with the given node, appending the changes to the given transaction. */
+  replaceWith(tr: Transaction<Sc>, node: Node<Sc>): void;
+  /**
+   * Convert the selection to a JSON representation. When implementing
+   * this for a custom selection class, make sure to give the object a
+   * `type` property whose value matches the ID under which you
+   * registered your class.
+   */
+  abstract toJSON(): SelectionJSON;
+  /**
+   * Find a valid cursor or leaf node selection starting at the given
+   * position and searching back if `dir` is negative, and forward if
+   * positive. When `textOnly` is true, only consider cursor selections.
+   * Will return `None` when no valid selection position is found.
+   */
+  static findFrom<Sc extends AnySchema>($pos: ResolvedPos<Sc>, dir: number, textOnly?: boolean): Option.Option<Selection<Sc>>;
+  /** @internal */
+  static findFromOrNull<Sc extends AnySchema>($pos: ResolvedPos<Sc>, dir: number, textOnly?: boolean): Selection<Sc> | null;
+  /**
+   * Find a valid cursor or leaf node selection near the given position.
+   * Searches forward first by default, but if `bias` is negative, it
+   * will search backwards first.
+   */
+  static near<Sc extends AnySchema>($pos: ResolvedPos<Sc>, bias?: number): Selection<Sc>;
+  /**
+   * Find the cursor or leaf node selection closest to the start of the
+   * given document. Will return an `AllSelection` if no valid position
+   * exists.
+   */
+  static atStart<Sc extends AnySchema>(doc: Node<Sc>): Selection<Sc>;
+  /** Find the cursor or leaf node selection closest to the end of the given document. */
+  static atEnd<Sc extends AnySchema>(doc: Node<Sc>): Selection<Sc>;
+  /**
+   * Deserialize the JSON representation of a selection. Dispatches to
+   * the selection class registered (with `jsonID`) for the JSON's
+   * `type`.
+   */
+  static fromJSON<Sc extends AnySchema>(doc: Node<Sc>, json: unknown): Effect.Effect<Selection<Sc>, ModelError | SelectionError>;
+  /** Like `fromJSON`, but throws on invalid input. */
+  static fromJSONUnsafe<Sc extends AnySchema>(doc: Node<Sc>, json: any): Selection<Sc>;
+  /**
+   * To be able to deserialize selections from JSON, custom selection
+   * classes must register themselves with an ID string, so that they
+   * can be disambiguated. Try to pick something that's unlikely to
+   * clash with classes from other modules. Throws a `SelectionError`
+   * when the ID is already in use.
+   */
+  static jsonID<C extends SelectionDeserializer>(id: string, selectionClass: C): C;
+  /**
+   * Get a bookmark for this selection, which is a value that can be
+   * mapped without having access to a current document, and later
+   * resolved to a real selection for a given document again. (This is
+   * used mostly by the history to track and restore old selections.)
+   * The default implementation of this method just converts the
+   * selection to a text selection and returns the bookmark for that.
+   */
+  getBookmark(): SelectionBookmark<Sc>;
+}
+/**
+ * A lightweight, document-independent representation of a selection.
+ * You can define a custom bookmark type for a custom selection class to
+ * make the history handle it well.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface SelectionBookmark<Sc extends AnySchema = AnySchema> {
+  /** Map the bookmark through a set of changes. */
+  readonly map: (mapping: Mappable) => SelectionBookmark<Sc>;
+  /**
+   * Resolve the bookmark to a real selection again. This may need to do
+   * some error checking and may fall back to a default (usually
+   * `TextSelection.between`) if mapping made the bookmark invalid.
+   */
+  readonly resolve: (doc: Node<Sc>) => Selection<Sc>;
+}
+/**
+ * Represents a selected range in a document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class SelectionRange<Sc extends AnySchema = AnySchema> {
+  /** The lower bound of the range. */
+  readonly $from: ResolvedPos<Sc>;
+  /** The upper bound of the range. */
+  readonly $to: ResolvedPos<Sc>;
+  /** Create a range. */
+  constructor(
+  /** The lower bound of the range. */
+  $from: ResolvedPos<Sc>,
+  /** The upper bound of the range. */
+  $to: ResolvedPos<Sc>);
+}
+/**
+ * A text selection represents a classical editor selection, with a head
+ * (the moving side) and anchor (immobile side), both of which point into
+ * textblock nodes. It can be empty (a regular cursor position).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class TextSelection<Sc extends AnySchema = AnySchema> extends Selection<Sc> {
+  /** Construct a text selection between the given points. */
+  constructor($anchor: ResolvedPos<Sc>, $head?: ResolvedPos<Sc>);
+  /** Returns a resolved position if this is a cursor selection (an empty text selection). */
+  get $cursor(): Option.Option<ResolvedPos<Sc>>;
+  /** @internal */
+  get $cursorOrNull(): ResolvedPos<Sc> | null;
+  map(doc: Node<Sc>, mapping: Mappable): Selection<Sc>;
+  replace(tr: Transaction<Sc>, content?: Slice<Sc>): void;
+  eq(other: Selection<any>): boolean;
+  getBookmark(): SelectionBookmark<Sc>;
+  toJSON(): SelectionJSON;
+  /** @internal */
+  static fromJSONUnsafe<Sc extends AnySchema>(doc: Node<Sc>, json: any): TextSelection<Sc>;
+  /** Create a text selection from non-resolved positions. */
+  static create<Sc extends AnySchema>(doc: Node<Sc>, anchor: number, head?: number): Effect.Effect<TextSelection<Sc>, PositionError>;
+  /** Like `create`, but throws a `PositionError` for positions outside of the document. */
+  static createUnsafe<Sc extends AnySchema>(doc: Node<Sc>, anchor: number, head?: number): TextSelection<Sc>;
+  /**
+   * Return a text selection that spans the given positions or, if they
+   * aren't text positions, find a text selection near them. `bias`
+   * determines whether the method searches forward (default) or
+   * backwards (negative number) first. Will fall back to calling
+   * `Selection.near` when the document doesn't contain a valid text
+   * position.
+   */
+  static between<Sc extends AnySchema>($anchor: ResolvedPos<Sc>, $head: ResolvedPos<Sc>, bias?: number): Selection<Sc>;
+}
+/**
+ * A node selection is a selection that points at a single node. All
+ * nodes marked selectable can be the target of a node selection. In
+ * such a selection, `from` and `to` point directly before and after the
+ * selected node, `anchor` equals `from`, and `head` equals `to`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class NodeSelection<Sc extends AnySchema = AnySchema> extends Selection<Sc> {
+  /** The selected node. */
+  readonly node: Node<Sc>;
+  /**
+   * Create a node selection. Does not verify the validity of its
+   * argument beyond requiring a node after `$pos` (throwing a
+   * `SelectionError` otherwise).
+   */
+  constructor($pos: ResolvedPos<Sc>);
+  get visible(): boolean;
+  map(doc: Node<Sc>, mapping: Mappable): Selection<Sc>;
+  content(): Slice<Sc>;
+  eq(other: Selection<any>): boolean;
+  toJSON(): SelectionJSON;
+  getBookmark(): SelectionBookmark<Sc>;
+  /** @internal */
+  static fromJSONUnsafe<Sc extends AnySchema>(doc: Node<Sc>, json: any): NodeSelection<Sc>;
+  /** Create a node selection from a non-resolved position. */
+  static create<Sc extends AnySchema>(doc: Node<Sc>, from: number): Effect.Effect<NodeSelection<Sc>, PositionError | SelectionError>;
+  /** Like `create`, but throws for invalid positions. */
+  static createUnsafe<Sc extends AnySchema>(doc: Node<Sc>, from: number): NodeSelection<Sc>;
+  /** Determines whether the given node may be selected as a node selection. */
+  static isSelectable(node: Node<any>): boolean;
+}
+/**
+ * A selection type that represents selecting the whole document (which
+ * can not necessarily be expressed with a text selection, when there
+ * are for example leaf block nodes at the start or end of the
+ * document).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class AllSelection<Sc extends AnySchema = AnySchema> extends Selection<Sc> {
+  /** Create an all-selection over the given document. */
+  constructor(doc: Node<Sc>);
+  replace(tr: Transaction<Sc>, content?: Slice<Sc>): void;
+  toJSON(): SelectionJSON;
+  /** @internal */
+  static fromJSONUnsafe<Sc extends AnySchema>(doc: Node<Sc>): AllSelection<Sc>;
+  map(doc: Node<Sc>): Selection<Sc>;
+  eq(other: Selection<any>): boolean;
+  getBookmark(): SelectionBookmark<Sc>;
+}
+/**
+ * An Effect `Schema` that decodes the JSON representation of a
+ * selection (using the `Selection.jsonID` registry) into a selection in
+ * the given document, and encodes selections back to JSON.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const SelectionFromJSON: <Sc extends AnySchema>(doc: Node<Sc>) => S.Codec<Selection<Sc>, SelectionJSON>;