@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/state/selection.js

@@ -0,0 +1,486 @@
+import { attempt } from "../internal/attempt.js";
+import { Fragment } from "../model/fragment.js";
+import { JSONError, isModelError } from "../model/errors.js";
+import { Slice } from "../model/replace.js";
+import { ReplaceAroundStep, ReplaceStep } from "../transform/replace_step.js";
+import { SelectionError, isStateFailure } from "./errors.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as S from "effect/Schema";
+import * as SchemaGetter from "effect/SchemaGetter";
+import * as SchemaIssue from "effect/SchemaIssue";
+// src/state/selection.ts
+/**
+* Editor selections.
+*
+* @since 0.1.0
+*/
+const isPositionOrSelectionError = (u) => isModelError(u) || u instanceof SelectionError;
+const classesById = Object.create(null);
+/**
+* Superclass for editor selections. Every selection type should extend
+* this. Should not be instantiated directly.
+*
+* @since 0.1.0
+* @category models
+*/
+var Selection = class Selection {
+	/**
+	* Initialize a selection with the head and anchor and ranges. If no
+	* ranges are given, constructs a single range across `$anchor` and
+	* `$head`.
+	*/
+	constructor($anchor, $head, ranges) {
+		this.$anchor = $anchor;
+		this.$head = $head;
+		this.ranges = ranges || [new SelectionRange($anchor.min($head), $anchor.max($head))];
+	}
+	/** The selection's anchor, as an unresolved position. */
+	get anchor() {
+		return this.$anchor.pos;
+	}
+	/** The selection's head. */
+	get head() {
+		return this.$head.pos;
+	}
+	/** The lower bound of the selection's main range. */
+	get from() {
+		return this.$from.pos;
+	}
+	/** The upper bound of the selection's main range. */
+	get to() {
+		return this.$to.pos;
+	}
+	/** The resolved lower bound of the selection's main range. */
+	get $from() {
+		return this.ranges[0].$from;
+	}
+	/** The resolved upper bound of the selection's main range. */
+	get $to() {
+		return this.ranges[0].$to;
+	}
+	/** Indicates whether the selection contains any content. */
+	get empty() {
+		const ranges = this.ranges;
+		for (let i = 0; i < ranges.length; i++) if (ranges[i].$from.pos !== ranges[i].$to.pos) return false;
+		return true;
+	}
+	/**
+	* 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() {
+		return true;
+	}
+	/** Get the content of this selection as a slice. */
+	content() {
+		return this.$from.doc.sliceUnsafe(this.from, this.to, true);
+	}
+	/**
+	* Replace the selection with a slice or, if no slice is given, delete
+	* the selection. Will append to the given transaction.
+	*/
+	replace(tr, content = Slice.empty) {
+		let lastNode = content.content.content[content.content.childCount - 1];
+		let lastParent = null;
+		for (let i = 0; i < content.openEnd; i++) {
+			lastParent = lastNode;
+			lastNode = lastNode.content.content[lastNode.childCount - 1];
+		}
+		const mapFrom = tr.steps.length, ranges = this.ranges;
+		for (let i = 0; i < ranges.length; i++) {
+			const { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
+			tr.replaceRangeUnsafe(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
+			if (i === 0) selectionToInsertionEnd(tr, mapFrom, (lastNode ? lastNode.isInline : lastParent && lastParent.isTextblock) ? -1 : 1);
+		}
+	}
+	/** Replace the selection with the given node, appending the changes to the given transaction. */
+	replaceWith(tr, node) {
+		const mapFrom = tr.steps.length, ranges = this.ranges;
+		for (let i = 0; i < ranges.length; i++) {
+			const { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
+			const from = mapping.map($from.pos), to = mapping.map($to.pos);
+			if (i) tr.deleteRangeUnsafe(from, to);
+			else {
+				tr.replaceRangeWithUnsafe(from, to, node);
+				selectionToInsertionEnd(tr, mapFrom, node.isInline ? -1 : 1);
+			}
+		}
+	}
+	/**
+	* 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($pos, dir, textOnly = false) {
+		return Option.fromNullishOr(Selection.findFromOrNull($pos, dir, textOnly));
+	}
+	/** @internal */
+	static findFromOrNull($pos, dir, textOnly = false) {
+		const inner = $pos.parent.inlineContent ? new TextSelection($pos) : findSelectionIn($pos.node(0), $pos.parent, $pos.pos, $pos.index(), dir, textOnly);
+		if (inner) return inner;
+		for (let depth = $pos.depth - 1; depth >= 0; depth--) {
+			const found = dir < 0 ? findSelectionIn($pos.node(0), $pos.node(depth), $pos.beforeUnsafe(depth + 1), $pos.index(depth), dir, textOnly) : findSelectionIn($pos.node(0), $pos.node(depth), $pos.afterUnsafe(depth + 1), $pos.index(depth) + 1, dir, textOnly);
+			if (found) return found;
+		}
+		return 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($pos, bias = 1) {
+		return this.findFromOrNull($pos, bias) || this.findFromOrNull($pos, -bias) || new AllSelection($pos.node(0));
+	}
+	/**
+	* 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(doc) {
+		return findSelectionIn(doc, doc, 0, 0, 1) || new AllSelection(doc);
+	}
+	/** Find the cursor or leaf node selection closest to the end of the given document. */
+	static atEnd(doc) {
+		return findSelectionIn(doc, doc, doc.content.size, doc.childCount, -1) || new AllSelection(doc);
+	}
+	/**
+	* Deserialize the JSON representation of a selection. Dispatches to
+	* the selection class registered (with `jsonID`) for the JSON's
+	* `type`.
+	*/
+	static fromJSON(doc, json) {
+		return attempt(() => Selection.fromJSONUnsafe(doc, json), (u) => isModelError(u) || isStateFailure(u));
+	}
+	/** Like `fromJSON`, but throws on invalid input. */
+	static fromJSONUnsafe(doc, json) {
+		if (!json || typeof json !== "object" || !json.type) throw new JSONError({ message: "Invalid input for Selection.fromJSON" });
+		const cls = classesById[json.type];
+		if (!cls) throw new JSONError({ message: `No selection type ${json.type} defined` });
+		return cls.fromJSONUnsafe(doc, json);
+	}
+	/**
+	* 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(id, selectionClass) {
+		if (id in classesById) throw new SelectionError({ message: "Duplicate use of selection JSON ID " + id });
+		classesById[id] = selectionClass;
+		const proto = selectionClass.prototype;
+		if (proto) proto.jsonID = id;
+		return selectionClass;
+	}
+	/**
+	* 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() {
+		return TextSelection.between(this.$anchor, this.$head).getBookmark();
+	}
+};
+/**
+* Represents a selected range in a document.
+*
+* @since 0.1.0
+* @category models
+*/
+var SelectionRange = class {
+	/** Create a range. */
+	constructor($from, $to) {
+		this.$from = $from;
+		this.$to = $to;
+	}
+};
+let warnedAboutTextSelection = false;
+function checkTextSelection($pos) {
+	if (!warnedAboutTextSelection && !$pos.parent.inlineContent) {
+		warnedAboutTextSelection = true;
+		console["warn"]("TextSelection endpoint not pointing into a node with inline content (" + $pos.parent.type.name + ")");
+	}
+}
+/**
+* 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
+*/
+var TextSelection = class TextSelection extends Selection {
+	/** Construct a text selection between the given points. */
+	constructor($anchor, $head = $anchor) {
+		checkTextSelection($anchor);
+		checkTextSelection($head);
+		super($anchor, $head);
+	}
+	/** Returns a resolved position if this is a cursor selection (an empty text selection). */
+	get $cursor() {
+		return Option.fromNullishOr(this.$cursorOrNull);
+	}
+	/** @internal */
+	get $cursorOrNull() {
+		return this.$anchor.pos === this.$head.pos ? this.$head : null;
+	}
+	map(doc, mapping) {
+		const $head = doc.resolveUnsafe(mapping.map(this.head));
+		if (!$head.parent.inlineContent) return Selection.near($head);
+		const $anchor = doc.resolveUnsafe(mapping.map(this.anchor));
+		return new TextSelection($anchor.parent.inlineContent ? $anchor : $head, $head);
+	}
+	replace(tr, content = Slice.empty) {
+		super.replace(tr, content);
+		if (content === Slice.empty) {
+			const marks = this.$from.marksAcrossOrNull(this.$to);
+			if (marks) tr.ensureMarks(marks);
+		}
+	}
+	eq(other) {
+		return other instanceof TextSelection && other.anchor === this.anchor && other.head === this.head;
+	}
+	getBookmark() {
+		return new TextBookmark(this.anchor, this.head);
+	}
+	toJSON() {
+		return {
+			type: "text",
+			anchor: this.anchor,
+			head: this.head
+		};
+	}
+	/** @internal */
+	static fromJSONUnsafe(doc, json) {
+		if (typeof json.anchor !== "number" || typeof json.head !== "number") throw new JSONError({ message: "Invalid input for TextSelection.fromJSON" });
+		return new TextSelection(doc.resolveUnsafe(json.anchor), doc.resolveUnsafe(json.head));
+	}
+	/** Create a text selection from non-resolved positions. */
+	static create(doc, anchor, head = anchor) {
+		return attempt(() => TextSelection.createUnsafe(doc, anchor, head), isModelError);
+	}
+	/** Like `create`, but throws a `PositionError` for positions outside of the document. */
+	static createUnsafe(doc, anchor, head = anchor) {
+		const $anchor = doc.resolveUnsafe(anchor);
+		return new TextSelection($anchor, head === anchor ? $anchor : doc.resolveUnsafe(head));
+	}
+	/**
+	* 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($anchor, $head, bias) {
+		const dPos = $anchor.pos - $head.pos;
+		if (!bias || dPos) bias = dPos >= 0 ? 1 : -1;
+		if (!$head.parent.inlineContent) {
+			const found = Selection.findFromOrNull($head, bias, true) || Selection.findFromOrNull($head, -bias, true);
+			if (found) $head = found.$head;
+			else return Selection.near($head, bias);
+		}
+		if (!$anchor.parent.inlineContent) {
+			if (dPos === 0) $anchor = $head;
+			else {
+				$anchor = (Selection.findFromOrNull($anchor, -bias, true) || Selection.findFromOrNull($anchor, bias, true)).$anchor;
+				if ($anchor.pos < $head.pos !== dPos < 0) $anchor = $head;
+			}
+		}
+		return new TextSelection($anchor, $head);
+	}
+};
+Selection.jsonID("text", TextSelection);
+var TextBookmark = class TextBookmark {
+	constructor(anchor, head) {
+		this.anchor = anchor;
+		this.head = head;
+	}
+	map(mapping) {
+		return new TextBookmark(mapping.map(this.anchor), mapping.map(this.head));
+	}
+	resolve(doc) {
+		return TextSelection.between(doc.resolveUnsafe(this.anchor), doc.resolveUnsafe(this.head));
+	}
+};
+/**
+* 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
+*/
+var NodeSelection = class NodeSelection extends Selection {
+	/**
+	* Create a node selection. Does not verify the validity of its
+	* argument beyond requiring a node after `$pos` (throwing a
+	* `SelectionError` otherwise).
+	*/
+	constructor($pos) {
+		const node = $pos.nodeAfterOrNull;
+		if (!node) throw new SelectionError({ message: "No node after position " + $pos.pos + " for NodeSelection" });
+		const $end = $pos.node(0).resolveUnsafe($pos.pos + node.nodeSize);
+		super($pos, $end);
+		this.node = node;
+	}
+	get visible() {
+		return false;
+	}
+	map(doc, mapping) {
+		const { deleted, pos } = mapping.mapResult(this.anchor);
+		const $pos = doc.resolveUnsafe(pos);
+		if (deleted) return Selection.near($pos);
+		return new NodeSelection($pos);
+	}
+	content() {
+		return new Slice(Fragment.from(this.node), 0, 0);
+	}
+	eq(other) {
+		return other instanceof NodeSelection && other.anchor === this.anchor;
+	}
+	toJSON() {
+		return {
+			type: "node",
+			anchor: this.anchor
+		};
+	}
+	getBookmark() {
+		return new NodeBookmark(this.anchor);
+	}
+	/** @internal */
+	static fromJSONUnsafe(doc, json) {
+		if (typeof json.anchor !== "number") throw new JSONError({ message: "Invalid input for NodeSelection.fromJSON" });
+		return new NodeSelection(doc.resolveUnsafe(json.anchor));
+	}
+	/** Create a node selection from a non-resolved position. */
+	static create(doc, from) {
+		return attempt(() => NodeSelection.createUnsafe(doc, from), isPositionOrSelectionError);
+	}
+	/** Like `create`, but throws for invalid positions. */
+	static createUnsafe(doc, from) {
+		return new NodeSelection(doc.resolveUnsafe(from));
+	}
+	/** Determines whether the given node may be selected as a node selection. */
+	static isSelectable(node) {
+		return !node.isText && node.type.spec.selectable !== false;
+	}
+};
+Selection.jsonID("node", NodeSelection);
+var NodeBookmark = class NodeBookmark {
+	constructor(anchor) {
+		this.anchor = anchor;
+	}
+	map(mapping) {
+		const { deleted, pos } = mapping.mapResult(this.anchor);
+		return deleted ? new TextBookmark(pos, pos) : new NodeBookmark(pos);
+	}
+	resolve(doc) {
+		const $pos = doc.resolveUnsafe(this.anchor), node = $pos.nodeAfterOrNull;
+		if (node && NodeSelection.isSelectable(node)) return new NodeSelection($pos);
+		return Selection.near($pos);
+	}
+};
+/**
+* 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
+*/
+var AllSelection = class AllSelection extends Selection {
+	/** Create an all-selection over the given document. */
+	constructor(doc) {
+		super(doc.resolveUnsafe(0), doc.resolveUnsafe(doc.content.size));
+	}
+	replace(tr, content = Slice.empty) {
+		if (content === Slice.empty) {
+			tr.deleteUnsafe(0, tr.doc.content.size);
+			const sel = Selection.atStart(tr.doc);
+			if (!sel.eq(tr.selection)) tr.setSelectionUnsafe(sel);
+		} else super.replace(tr, content);
+	}
+	toJSON() {
+		return { type: "all" };
+	}
+	/** @internal */
+	static fromJSONUnsafe(doc) {
+		return new AllSelection(doc);
+	}
+	map(doc) {
+		return new AllSelection(doc);
+	}
+	eq(other) {
+		return other instanceof AllSelection;
+	}
+	getBookmark() {
+		return AllBookmark;
+	}
+};
+Selection.jsonID("all", AllSelection);
+const AllBookmark = {
+	map() {
+		return this;
+	},
+	resolve(doc) {
+		return new AllSelection(doc);
+	}
+};
+function findSelectionIn(doc, node, pos, index, dir, text = false) {
+	if (node.inlineContent) return TextSelection.createUnsafe(doc, pos);
+	for (let i = index - (dir > 0 ? 0 : 1); dir > 0 ? i < node.childCount : i >= 0; i += dir) {
+		const child = node.content.content[i];
+		if (!child.isAtom) {
+			const inner = findSelectionIn(doc, child, pos + dir, dir < 0 ? child.childCount : 0, dir, text);
+			if (inner) return inner;
+		} else if (!text && NodeSelection.isSelectable(child)) return NodeSelection.createUnsafe(doc, pos - (dir < 0 ? child.nodeSize : 0));
+		pos += child.nodeSize * dir;
+	}
+	return null;
+}
+function selectionToInsertionEnd(tr, startLen, bias) {
+	const last = tr.steps.length - 1;
+	if (last < startLen) return;
+	const step = tr.steps[last];
+	if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) return;
+	const map = tr.mapping.maps[last];
+	let end;
+	map.forEach((_from, _to, _newFrom, newTo) => {
+		if (end == null) end = newTo;
+	});
+	tr.setSelectionUnsafe(Selection.near(tr.doc.resolveUnsafe(end), bias));
+}
+const SelectionJSONSchema = S.declare((u) => typeof u === "object" && u !== null && typeof u.type === "string", { title: "SelectionJSON" });
+/**
+* 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
+*/
+const SelectionFromJSON = (doc) => {
+	const target = S.declare((u) => u instanceof Selection && u.$anchor.doc === doc, { title: "Selection" });
+	return SelectionJSONSchema.pipe(S.decodeTo(target, {
+		decode: SchemaGetter.transformEffect((json) => Effect.suspend(() => {
+			try {
+				return Effect.succeed(Selection.fromJSONUnsafe(doc, json));
+			} catch (e) {
+				return Effect.fail(new SchemaIssue.InvalidValue({ message: Predicate.hasProperty(e, "message") ? String(e.message) : String(e) }, json));
+			}
+		})),
+		encode: SchemaGetter.transform((selection) => selection.toJSON())
+	}));
+};
+export { AllSelection, NodeSelection, Selection, SelectionFromJSON, SelectionRange, TextSelection };

package/dist/state/state.d.ts

@@ -0,0 +1,212 @@
+import { ModelError } from "../model/errors.js";
+import { AnySchema } from "../model/schema.js";
+import { Mark, MarkJSON } from "../model/mark.js";
+import { Node, NodeJSON } from "../model/node.js";
+import "../model.js";
+import { SelectionError, StateError } from "./errors.js";
+import { AnyPlugin, Plugin, PluginErrors, PluginRequirements, StateField } from "./plugin.js";
+import { Selection, SelectionJSON } from "./selection.js";
+import { Transaction } from "./transaction.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+/**
+ * The type of object passed to `EditorState.create`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface EditorStateConfig<Sc extends AnySchema = AnySchema, P extends ReadonlyArray<AnyPlugin> = ReadonlyArray<AnyPlugin>> {
+  /** The schema to use (only relevant if no `doc` is specified). */
+  readonly schema?: Sc | undefined;
+  /** The starting document. Either this or `schema` _must_ be provided. */
+  readonly doc?: Node<Sc> | undefined;
+  /** A valid selection in the document. */
+  readonly selection?: Selection<Sc> | undefined;
+  /** The initial set of stored marks. */
+  readonly storedMarks?: ReadonlyArray<Mark<Sc>> | null | undefined;
+  /** The plugins that should be active in this state. */
+  readonly plugins?: P | undefined;
+}
+/**
+ * The JSON representation of an editor state (see `EditorState.toJSON`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface EditorStateJSON {
+  readonly doc: NodeJSON;
+  readonly selection: SelectionJSON;
+  readonly storedMarks?: ReadonlyArray<MarkJSON>;
+  readonly [field: string]: unknown;
+}
+/**
+ * The result of `EditorState.applyTransaction`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ApplyResult<Sc extends AnySchema, R, E> {
+  readonly state: EditorState<Sc, R, E>;
+  readonly transactions: ReadonlyArray<Transaction<Sc>>;
+}
+interface FieldDesc {
+  readonly name: string;
+  readonly self: unknown;
+  readonly init: StateField<any, any, any, any>["init"];
+  readonly apply: StateField<any, any, any, any>["apply"];
+}
+/**
+ * Object wrapping the part of a state object that stays the same across
+ * transactions. Stored in the state's `config` property.
+ *
+ * @internal
+ */
+export declare class Configuration<Sc extends AnySchema> {
+  readonly schema: Sc;
+  readonly fields: Array<FieldDesc>;
+  readonly plugins: Array<AnyPlugin>;
+  readonly pluginsByKey: Record<string, AnyPlugin>;
+  constructor(schema: Sc, plugins?: ReadonlyArray<AnyPlugin>);
+}
+/** Marker returned by the synchronous fast path when a hook returned an Effect. */
+declare const NeedsEffect: unique symbol;
+/**
+ * Run an effect synchronously, throwing its (first) failure or defect.
+ *
+ * @internal
+ */
+export declare const runSyncUnsafe: <A, E>(effect: Effect.Effect<A, E>) => A;
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+export declare const EditorStateTypeId: unique symbol;
+/**
+ * @since 0.1.0
+ * @category symbols
+ */
+export type EditorStateTypeId = typeof EditorStateTypeId;
+/**
+ * The state of an editor is represented by an object of this type. A
+ * state is a persistent data structure—it isn't updated, but rather a
+ * new state value is computed from an old one using the `apply` method.
+ *
+ * A state holds a number of built-in fields, and plugins can define
+ * additional fields.
+ *
+ * `R` and `E` are the unions of the requirements and errors of the
+ * state's plugins: applying a transaction runs the plugins' hooks, so
+ * `apply` returns an `Effect<EditorState<Sc, R, E>, E | StateError, R>`.
+ * States whose plugins require no services (`R = never`) can also be
+ * updated synchronously with `applyUnsafe`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class EditorState<Sc extends AnySchema = AnySchema, R = never, E = never> {
+  /** @internal */
+  readonly config: Configuration<Sc>;
+  /** @internal */
+  readonly slots: Record<string, any>;
+  readonly [EditorStateTypeId]: {
+    readonly _R: (_: never) => R;
+    readonly _E: (_: never) => E;
+  };
+  /** @internal */
+  constructor(
+  /** @internal */
+  config: Configuration<Sc>,
+  /** @internal */
+  slots?: Record<string, any>);
+  /** The current document. */
+  get doc(): Node<Sc>;
+  /** The selection. */
+  get selection(): Selection<Sc>;
+  /** A set of marks to apply to the next input. `None` when no explicit marks have been set. */
+  get storedMarks(): Option.Option<ReadonlyArray<Mark<Sc>>>;
+  /** @internal */
+  get storedMarksOrNull(): ReadonlyArray<Mark<Sc>> | null;
+  /** @internal */
+  get scrollToSelection(): number;
+  /** The schema of the state's document. */
+  get schema(): Sc;
+  /** The plugins that are active in this state. */
+  get plugins(): ReadonlyArray<Plugin<any, Sc, E, R>>;
+  /** Create a new transaction from this state. */
+  get tr(): Transaction<Sc>;
+  /** Apply the given transaction to produce a new state. */
+  apply(tr: Transaction<Sc>): Effect.Effect<EditorState<Sc, R, E>, E | StateError, R>;
+  /**
+   * Like `apply`, but runs synchronously, throwing failures. Only
+   * available for states whose plugins require no services; fails with
+   * a defect (thrown) when a plugin hook is asynchronous.
+   */
+  applyUnsafe(this: EditorState<Sc, never, E>, tr: Transaction<Sc>): EditorState<Sc, never, E>;
+  /** @internal */
+  filterTransaction(tr: Transaction<Sc>, ignore?: number): Effect.Effect<boolean, E, R>;
+  /**
+   * Verbose variant of `apply` that returns the precise transactions
+   * that were applied (which might be influenced by the transaction
+   * hooks of plugins) along with the new state.
+   */
+  applyTransaction(rootTr: Transaction<Sc>): Effect.Effect<ApplyResult<Sc, R, E>, E | StateError, R>;
+  /** @internal */
+  applyTransactionSync(rootTr: Transaction<Sc>): ApplyResult<Sc, R, E> | typeof NeedsEffect;
+  /** @internal */
+  filterTransactionSync(tr: Transaction<Sc>, ignore?: number): boolean | typeof NeedsEffect;
+  /** @internal */
+  applyInnerSync(tr: Transaction<Sc>): EditorState<Sc, R, E> | typeof NeedsEffect;
+  /** @internal */
+  applyTransactionEffect(rootTr: Transaction<Sc>): Effect.Effect<ApplyResult<Sc, R, E>, E | StateError, R>;
+  /** Like `applyTransaction`, but runs synchronously (see `applyUnsafe`). */
+  applyTransactionUnsafe(this: EditorState<Sc, never, E>, rootTr: Transaction<Sc>): ApplyResult<Sc, never, E>;
+  /** @internal */
+  applyInner(tr: Transaction<Sc>): Effect.Effect<EditorState<Sc, R, E>, E | StateError, R>;
+  /**
+   * Create a new state based on this one, but with an adjusted set of
+   * active plugins. State fields that exist in both sets of plugins are
+   * kept unchanged. Those that no longer exist are dropped, and those
+   * that are new are initialized using their `init` method, passing in
+   * the new configuration object.
+   */
+  reconfigure<const P extends ReadonlyArray<AnyPlugin> = readonly []>(config: {
+    readonly plugins?: P | undefined;
+  }): Effect.Effect<EditorState<Sc, PluginRequirements<P>, PluginErrors<P>>, PluginErrors<P> | StateError, PluginRequirements<P>>;
+  /** Like `reconfigure`, but runs synchronously (see `applyUnsafe`). */
+  reconfigureUnsafe<const P extends ReadonlyArray<Plugin<any, any, any, never>> = readonly []>(config: {
+    readonly plugins?: P | undefined;
+  }): EditorState<Sc, never, PluginErrors<P>>;
+  /**
+   * Serialize this state to JSON. If you want to serialize the state of
+   * plugins, pass an object mapping property names to use in the
+   * resulting JSON object to plugin objects. The argument may also be a
+   * string or number, in which case it is ignored, to support the way
+   * `JSON.stringify` calls `toJSON` methods. Throws a `StateError` when
+   * a plugin is mapped to the reserved `doc` or `selection` fields.
+   */
+  toJSON(pluginFields?: Record<string, AnyPlugin> | string | number): EditorStateJSON;
+  /** Create a new state. */
+  static create<Sc extends AnySchema, const P extends ReadonlyArray<AnyPlugin> = readonly []>(config: EditorStateConfig<Sc, P>): Effect.Effect<EditorState<Sc, PluginRequirements<P>, PluginErrors<P>>, PluginErrors<P> | StateError, PluginRequirements<P>>;
+  /**
+   * Like `create`, but runs synchronously. Only available when the
+   * plugins require no services; throws on failure.
+   */
+  static createUnsafe<Sc extends AnySchema, const P extends ReadonlyArray<Plugin<any, any, any, never>> = readonly []>(config: EditorStateConfig<Sc, P>): EditorState<Sc, never, PluginErrors<P>>;
+  /**
+   * Deserialize a JSON representation of a state. `config` should have
+   * at least a `schema` field, and should contain an array of plugins to
+   * initialize the state with. `pluginFields` can be used to deserialize
+   * the state of plugins, by associating plugin instances with the
+   * property names they use in the JSON object.
+   */
+  static fromJSON<Sc extends AnySchema, const P extends ReadonlyArray<AnyPlugin> = readonly []>(config: {
+    readonly schema: Sc;
+    readonly plugins?: P | undefined;
+  }, json: unknown, pluginFields?: Record<string, AnyPlugin>): Effect.Effect<EditorState<Sc, PluginRequirements<P>, PluginErrors<P>>, PluginErrors<P> | StateError | SelectionError | ModelError, PluginRequirements<P>>;
+  /** Like `fromJSON`, but runs synchronously (see `createUnsafe`). */
+  static fromJSONUnsafe<Sc extends AnySchema, const P extends ReadonlyArray<Plugin<any, any, any, never>> = readonly []>(config: {
+    readonly schema: Sc;
+    readonly plugins?: P | undefined;
+  }, json: unknown, pluginFields?: Record<string, AnyPlugin>): EditorState<Sc, never, PluginErrors<P>>;
+}
+export {};