@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/extensions/extension.js

@@ -0,0 +1,233 @@
+import { keymap } from "../keymap/keymap.js";
+import * as Arr from "effect/Array";
+import * as Order from "effect/Order";
+// src/extensions/extension.ts
+/**
+* Extensions: composable, strongly typed bundles of schema specs,
+* plugins, keymaps and commands.
+*
+* @since 0.1.0
+*/
+/**
+* Extension priorities. Within a merged extension, facets with a higher
+* priority come first: their node and mark specs come earlier in the
+* schema (which matters for the default node of a group and for parse
+* rule precedence), their plugins and keymaps come earlier in the
+* plugin list (so their key bindings and props take precedence), and
+* their commands win over commands with the same name. Facets with the
+* same priority keep their declaration order.
+*
+* @since 0.1.0
+* @category models
+*/
+const Priority = {
+	lowest: 0,
+	low: 1,
+	default: 2,
+	high: 3,
+	highest: 4
+};
+/**
+* @since 0.1.0
+* @category symbols
+*/
+const ExtensionTypeId = Symbol.for("effect-richtext/extensions/Extension");
+/**
+* An extension: a tree of facets (node and mark specs, plugins,
+* keymaps and commands), each with an optional priority. `T` records,
+* at the type level, what the extension contributes. Extensions are
+* immutable values; combine them with `union` and turn them into an
+* editor with `createEditor`.
+*
+* @since 0.1.0
+* @category models
+*/
+var Extension = class {
+	/** @internal */
+	constructor(spec, children, priority) {
+		this.spec = spec;
+		this.children = children;
+		this.priority = priority;
+	}
+};
+/**
+* Whether a value is an `Extension`.
+*
+* @since 0.1.0
+* @category guards
+*/
+const isExtension = (u) => u instanceof Extension;
+/**
+* Define an extension from node and mark specs, plugins, a keymap and
+* commands. Every field is optional; the types of all of them are
+* recorded in the extension's type.
+*
+* ```ts skip-type-checking
+* const bold = defineExtension({
+*   marks: { strong: { parseDOM: [{ tag: "strong" }], toDOM: () => ["strong", 0] } },
+*   commands: { toggleBold: () => (state, dispatch) => toggleMark(state.schema.marks.strong!)(state, dispatch) },
+*   keymap: { "Mod-b": (state, dispatch) => toggleMark(state.schema.marks.strong!)(state, dispatch) }
+* })
+* ```
+*
+* Throws a `KeymapError` when a key name in `keymap` is invalid.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const defineExtension = (spec) => {
+	const plugins = spec.plugins ? [...spec.plugins] : [];
+	if (spec.keymap) plugins.push(keymap(spec.keymap));
+	return new Extension({
+		nodes: spec.nodes,
+		marks: spec.marks,
+		plugins,
+		commands: spec.commands
+	}, [], void 0);
+};
+/**
+* Merge extensions. The result contributes everything its parts
+* contribute: node, mark and command types are intersected, `E` and `R`
+* are unions. At runtime facets are ordered by priority, then by
+* declaration order (depth first); including the same extension value
+* more than once only uses its first occurrence.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const union = (...extensions) => new Extension(void 0, extensions, void 0);
+/**
+* Give an extension (and every part of it that doesn't set its own
+* priority) a priority.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const withPriority = (extension, priority) => new Extension(void 0, [extension], priority);
+/**
+* Define an extension adding a single node spec.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const defineNodeSpec = (name, spec) => new Extension({ nodes: { [name]: spec } }, [], void 0);
+/**
+* Define an extension adding a single mark spec.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const defineMarkSpec = (name, spec) => new Extension({ marks: { [name]: spec } }, [], void 0);
+/**
+* Define an extension adding plugins: a plugin, an array of plugins, or
+* a function creating them from the editor's schema.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const definePlugin = (plugin) => new Extension({ plugins: [plugin] }, [], void 0);
+/**
+* Define an extension adding a keymap (see `keymap`). Throws a
+* `KeymapError` when a key name is invalid or bound twice.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const defineKeymap = (bindings) => defineExtension({ keymap: bindings });
+/**
+* Define an extension adding commands. Each command is given as a
+* function from the command's arguments to a `Command`; the argument
+* types become part of the editor's `commands`, `can()` and `chain()`
+* APIs.
+*
+* ```ts skip-type-checking
+* const ext = defineCommands({
+*   insertHello: (times: number) => (state, dispatch) => ...
+* })
+* ```
+*
+* For commands whose argument types depend on the final schema, declare
+* a `CommandSignature` and cast the extension (see `CommandsExtension`).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const defineCommands = (commands) => new Extension({ commands }, [], void 0);
+const mergeSpec = (base, over) => {
+	if (!base) return over;
+	const attrs = base.attrs || over.attrs ? {
+		...base.attrs,
+		...over.attrs
+	} : void 0;
+	const merged = {
+		...base,
+		...over
+	};
+	return attrs ? {
+		...merged,
+		attrs
+	} : merged;
+};
+const byPriorityDesc = (a, b) => Order.Number(b.priority, a.priority);
+/**
+* Flatten an extension tree. Facets are sorted by priority (highest
+* first), keeping declaration order for equal priorities. Node and mark
+* specs with the same name are shallow-merged (attributes merged), with
+* the higher-priority spec winning, at the position of the first
+* occurrence; for commands with the same name the higher-priority one
+* wins.
+*
+* @internal
+*/
+const flatten = (extension) => {
+	const collected = [];
+	const seen = /* @__PURE__ */ new WeakSet();
+	const visit = (ext, inherited) => {
+		if (seen.has(ext)) return;
+		seen.add(ext);
+		const priority = ext.priority ?? inherited;
+		if (ext.spec) collected.push({
+			spec: ext.spec,
+			priority
+		});
+		for (const child of ext.children) visit(child, priority);
+	};
+	visit(extension, Priority.default);
+	const facets = Arr.sort(collected, byPriorityDesc);
+	const nodes = {};
+	const marks = {};
+	const plugins = [];
+	const commands = {};
+	for (const { spec } of facets) {
+		for (const name in spec.nodes) if (!(name in nodes)) nodes[name] = void 0;
+		for (const name in spec.marks) if (!(name in marks)) marks[name] = void 0;
+		if (spec.plugins) plugins.push(...spec.plugins);
+		for (const name in spec.commands) if (!(name in commands)) commands[name] = spec.commands[name];
+	}
+	for (let i = facets.length - 1; i >= 0; i--) {
+		const spec = facets[i].spec;
+		for (const name in spec.nodes) nodes[name] = mergeSpec(nodes[name], spec.nodes[name]);
+		for (const name in spec.marks) marks[name] = mergeSpec(marks[name], spec.marks[name]);
+	}
+	return {
+		nodes,
+		marks,
+		plugins,
+		commands
+	};
+};
+/**
+* Resolve plugin inputs against a schema.
+*
+* @internal
+*/
+const resolvePlugins = (inputs, schema) => {
+	const result = [];
+	const add = (input) => {
+		if (Array.isArray(input)) result.push(...input);
+		else result.push(input);
+	};
+	for (const input of inputs) add(typeof input === "function" ? input(schema) : input);
+	return result;
+};
+export { Extension, ExtensionTypeId, Priority, defineCommands, defineExtension, defineKeymap, defineMarkSpec, defineNodeSpec, definePlugin, flatten, isExtension, resolvePlugins, union, withPriority };

package/dist/extensions.d.ts

@@ -0,0 +1,4 @@
+import { BaseCommands, ListCommands, NodeTypeCommand, ToggleMarkCommand, defineBaseCommands, defineBaseKeymap, defineBasicExtension, defineBlockquote, defineCode, defineCodeBlock, defineDoc, defineEm, defineHardBreak, defineHeading, defineHistory, defineHorizontalRule, defineImage, defineLink, defineList, defineParagraph, defineStrong, defineText } from "./extensions/defaults.js";
+import { CanCommands, ChainRun, ChainedCommands, CommandFn, CreateEditorError, Editor, EditorCommands, EditorContent, EditorOptions, EditorTypeId, MarkBuilder, MarkBuilders, MountProps, NodeBuilder, NodeBuilders, NodeChild, SchemaOf, createEditor, createEditorUnsafe } from "./extensions/editor.js";
+import { AnyExtension, CommandArgsOf, CommandCreator, CommandCreators, CommandSignature, CommandType, CommandTypes, CommandsError, CommandsExtension, CommandsRequirements, EmptyTypes, Extension, ExtensionCommands, ExtensionMarks, ExtensionNodes, ExtensionSpec, ExtensionTypeId, ExtensionTypes, MergeTypes, PluginInput, Priority, SpecTypes, TypesOf, defineCommands, defineExtension, defineKeymap, defineMarkSpec, defineNodeSpec, definePlugin, isExtension, union, withPriority } from "./extensions/extension.js";
+export { type AnyExtension, BaseCommands, CanCommands, ChainRun, ChainedCommands, type CommandArgsOf, type CommandCreator, type CommandCreators, CommandFn, type CommandSignature, type CommandType, type CommandTypes, type CommandsError, type CommandsExtension, type CommandsRequirements, CreateEditorError, Editor, EditorCommands, EditorContent, EditorOptions, EditorTypeId, type EmptyTypes, Extension, type ExtensionCommands, type ExtensionMarks, type ExtensionNodes, type ExtensionSpec, ExtensionTypeId, type ExtensionTypes, ListCommands, MarkBuilder, MarkBuilders, type MergeTypes, MountProps, NodeBuilder, NodeBuilders, NodeChild, NodeTypeCommand, type PluginInput, Priority, SchemaOf, type SpecTypes, ToggleMarkCommand, type TypesOf, createEditor, createEditorUnsafe, defineBaseCommands, defineBaseKeymap, defineBasicExtension, defineBlockquote, defineCode, defineCodeBlock, defineCommands, defineDoc, defineEm, defineExtension, defineHardBreak, defineHeading, defineHistory, defineHorizontalRule, defineImage, defineKeymap, defineLink, defineList, defineMarkSpec, defineNodeSpec, defineParagraph, definePlugin, defineStrong, defineText, isExtension, union, withPriority };

package/dist/extensions.js

@@ -0,0 +1,4 @@
+import { defineBaseCommands, defineBaseKeymap, defineBasicExtension, defineBlockquote, defineCode, defineCodeBlock, defineDoc, defineEm, defineHardBreak, defineHeading, defineHistory, defineHorizontalRule, defineImage, defineLink, defineList, defineParagraph, defineStrong, defineText } from "./extensions/defaults.js";
+import { Editor, EditorTypeId, createEditor, createEditorUnsafe } from "./extensions/editor.js";
+import { Extension, ExtensionTypeId, Priority, defineCommands, defineExtension, defineKeymap, defineMarkSpec, defineNodeSpec, definePlugin, isExtension, union, withPriority } from "./extensions/extension.js";
+export { Editor, EditorTypeId, Extension, ExtensionTypeId, Priority, createEditor, createEditorUnsafe, defineBaseCommands, defineBaseKeymap, defineBasicExtension, defineBlockquote, defineCode, defineCodeBlock, defineCommands, defineDoc, defineEm, defineExtension, defineHardBreak, defineHeading, defineHistory, defineHorizontalRule, defineImage, defineKeymap, defineLink, defineList, defineMarkSpec, defineNodeSpec, defineParagraph, definePlugin, defineStrong, defineText, isExtension, union, withPriority };

package/dist/gapcursor.d.ts

@@ -0,0 +1,66 @@
+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 { Mappable } from "./transform/map.js";
+import "./state.js";
+import { Selection, SelectionBookmark, SelectionJSON } from "./state/selection.js";
+import { Plugin } from "./state/plugin.js";
+import "./transform.js";
+import * as Option from "effect/Option";
+/**
+ * Gap cursor selections are represented using this class. Its `$anchor`
+ * and `$head` properties both point at the cursor position.
+ *
+ * Node specs may set `allowGapCursor` to explicitly allow or disallow
+ * gap cursors inside nodes of that type, and `createGapCursor` to make
+ * the positions around nodes of that type valid gap cursor positions.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class GapCursor<Sc extends AnySchema = AnySchema> extends Selection<Sc> {
+  /** Create a gap cursor. */
+  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;
+  /** @internal */
+  static fromJSONUnsafe<Sc extends AnySchema>(doc: Node<Sc>, json: any): GapCursor<Sc>;
+  getBookmark(): SelectionBookmark<Sc>;
+  /** Whether a gap cursor is valid at the given position. */
+  static valid($pos: ResolvedPos<any>): boolean;
+  /**
+   * Find a valid gap cursor position starting at `$pos` and searching in
+   * direction `dir` (negative is backwards). When `mustMove` is true,
+   * `$pos` itself is not considered.
+   */
+  static findGapCursorFrom<Sc extends AnySchema>($pos: ResolvedPos<Sc>, dir: number, mustMove?: boolean): Option.Option<ResolvedPos<Sc>>;
+  /** @internal */
+  static findGapCursorFromOrNull<Sc extends AnySchema>($pos: ResolvedPos<Sc>, dir: number, mustMove?: boolean): ResolvedPos<Sc> | null;
+}
+/**
+ * Create a gap cursor plugin. When enabled, this will capture clicks
+ * near and arrow-key-motion past places that don't have a normally
+ * selectable position nearby, and create a gap cursor selection for
+ * them. The cursor is drawn as an element with class
+ * `ProseMirror-gapcursor`. You can either include `gapCursorCSS` or add
+ * your own styles to make it visible.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const gapCursor: () => Plugin<undefined>;
+/**
+ * The gap cursor's stylesheet (from `prosemirror-gapcursor`'s
+ * `style/gapcursor.css`). Add it to the page (for example with
+ * `injectCSS` from `@thomasfosterau/effect-richtext/view-css`) or provide your own
+ * styles for `.ProseMirror-gapcursor`.
+ *
+ * @since 0.1.0
+ * @category styles
+ */
+export declare const gapCursorCSS: string;

package/dist/gapcursor.js

@@ -0,0 +1,273 @@
+import { keydownHandler } from "./keymap/keymap.js";
+import { Fragment } from "./model/fragment.js";
+import { JSONError } from "./model/errors.js";
+import { Slice } from "./model/replace.js";
+import { NodeSelection, Selection, TextSelection } from "./state/selection.js";
+import { Plugin } from "./state/plugin.js";
+import { Decoration, DecorationSet } from "./view/decoration.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+// src/gapcursor.ts
+/**
+* Gap cursors: a selection type (and plugin) for focusing places that
+* don't allow regular selection, such as positions between two
+* adjacent block nodes that aren't textblocks. Ported from
+* `prosemirror-gapcursor`.
+*
+* Importing this module registers the `GapCursor` selection class for
+* JSON deserialization (under the ID `"gapcursor"`).
+*
+* @since 0.1.0
+*/
+const child = (node, index) => node.content.content[index];
+/**
+* Gap cursor selections are represented using this class. Its `$anchor`
+* and `$head` properties both point at the cursor position.
+*
+* Node specs may set `allowGapCursor` to explicitly allow or disallow
+* gap cursors inside nodes of that type, and `createGapCursor` to make
+* the positions around nodes of that type valid gap cursor positions.
+*
+* @since 0.1.0
+* @category models
+*/
+var GapCursor = class GapCursor extends Selection {
+	/** Create a gap cursor. */
+	constructor($pos) {
+		super($pos, $pos);
+	}
+	get visible() {
+		return false;
+	}
+	map(doc, mapping) {
+		const $pos = doc.resolveUnsafe(mapping.map(this.head));
+		return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos);
+	}
+	content() {
+		return Slice.empty;
+	}
+	eq(other) {
+		return other instanceof GapCursor && other.head === this.head;
+	}
+	toJSON() {
+		return {
+			type: "gapcursor",
+			pos: this.head
+		};
+	}
+	/** @internal */
+	static fromJSONUnsafe(doc, json) {
+		if (!Predicate.isNumber(json.pos)) throw new JSONError({ message: "Invalid input for GapCursor.fromJSON" });
+		return new GapCursor(doc.resolveUnsafe(json.pos));
+	}
+	getBookmark() {
+		return new GapBookmark(this.anchor);
+	}
+	/** Whether a gap cursor is valid at the given position. */
+	static valid($pos) {
+		const parent = $pos.parent;
+		if (parent.inlineContent || !closedBefore($pos) || !closedAfter($pos)) return false;
+		const override = parent.type.spec.allowGapCursor;
+		if (override != null) return !!override;
+		const deflt = parent.contentMatchAtUnsafe($pos.index()).defaultTypeOrNull;
+		return !!deflt && deflt.isTextblock;
+	}
+	/**
+	* Find a valid gap cursor position starting at `$pos` and searching in
+	* direction `dir` (negative is backwards). When `mustMove` is true,
+	* `$pos` itself is not considered.
+	*/
+	static findGapCursorFrom($pos, dir, mustMove = false) {
+		return Option.fromNullishOr(GapCursor.findGapCursorFromOrNull($pos, dir, mustMove));
+	}
+	/** @internal */
+	static findGapCursorFromOrNull($pos, dir, mustMove = false) {
+		search: for (;;) {
+			if (!mustMove && GapCursor.valid($pos)) return $pos;
+			let pos = $pos.pos, next = null;
+			for (let d = $pos.depth;; d--) {
+				const parent = $pos.node(d);
+				if (dir > 0 ? $pos.indexAfter(d) < parent.childCount : $pos.index(d) > 0) {
+					next = child(parent, dir > 0 ? $pos.indexAfter(d) : $pos.index(d) - 1);
+					break;
+				} else if (d === 0) return null;
+				pos += dir;
+				const $cur = $pos.doc.resolveUnsafe(pos);
+				if (GapCursor.valid($cur)) return $cur;
+			}
+			for (;;) {
+				const inside = dir > 0 ? next.content.content[0] : next.content.content[next.childCount - 1];
+				if (!inside) {
+					if (next.isAtom && !next.isText && !NodeSelection.isSelectable(next)) {
+						$pos = $pos.doc.resolveUnsafe(pos + next.nodeSize * dir);
+						mustMove = false;
+						continue search;
+					}
+					break;
+				}
+				next = inside;
+				pos += dir;
+				const $cur = $pos.doc.resolveUnsafe(pos);
+				if (GapCursor.valid($cur)) return $cur;
+			}
+			return null;
+		}
+	}
+};
+Selection.jsonID("gapcursor", GapCursor);
+var GapBookmark = class GapBookmark {
+	constructor(pos) {
+		this.pos = pos;
+	}
+	map(mapping) {
+		return new GapBookmark(mapping.map(this.pos));
+	}
+	resolve(doc) {
+		const $pos = doc.resolveUnsafe(this.pos);
+		return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos);
+	}
+};
+function needsGap(type) {
+	return type.isAtom || !!type.spec.isolating || !!type.spec.createGapCursor;
+}
+function closedBefore($pos) {
+	for (let d = $pos.depth; d >= 0; d--) {
+		const index = $pos.index(d), parent = $pos.node(d);
+		if (index === 0) {
+			if (parent.type.spec.isolating) return true;
+			continue;
+		}
+		for (let before = child(parent, index - 1);; before = child(before, before.childCount - 1)) {
+			if (before.childCount === 0 && !before.inlineContent || needsGap(before.type)) return true;
+			if (before.inlineContent) return false;
+		}
+	}
+	return true;
+}
+function closedAfter($pos) {
+	for (let d = $pos.depth; d >= 0; d--) {
+		const index = $pos.indexAfter(d), parent = $pos.node(d);
+		if (index === parent.childCount) {
+			if (parent.type.spec.isolating) return true;
+			continue;
+		}
+		for (let after = child(parent, index);; after = child(after, 0)) {
+			if (after.childCount === 0 && !after.inlineContent || needsGap(after.type)) return true;
+			if (after.inlineContent) return false;
+		}
+	}
+	return true;
+}
+/**
+* Create a gap cursor plugin. When enabled, this will capture clicks
+* near and arrow-key-motion past places that don't have a normally
+* selectable position nearby, and create a gap cursor selection for
+* them. The cursor is drawn as an element with class
+* `ProseMirror-gapcursor`. You can either include `gapCursorCSS` or add
+* your own styles to make it visible.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const gapCursor = () => new Plugin({ props: {
+	decorations: drawGapCursor,
+	createSelectionBetween(_view, $anchor, $head) {
+		return $anchor.pos === $head.pos && GapCursor.valid($head) ? new GapCursor($head) : null;
+	},
+	handleClick,
+	handleKeyDown,
+	handleDOMEvents: { beforeinput }
+} });
+function arrow(axis, dir) {
+	const dirStr = axis === "vert" ? dir > 0 ? "down" : "up" : dir > 0 ? "right" : "left";
+	return (state, dispatch, view) => Effect.suspend(() => {
+		const sel = state.selection;
+		let $start = dir > 0 ? sel.$to : sel.$from, mustMove = sel.empty;
+		if (sel instanceof TextSelection) {
+			if (!view || !view.endOfTextblock(dirStr) || $start.depth === 0) return Effect.succeed(false);
+			mustMove = false;
+			$start = state.doc.resolveUnsafe(dir > 0 ? $start.afterUnsafe() : $start.beforeUnsafe());
+		}
+		const $found = GapCursor.findGapCursorFromOrNull($start, dir, mustMove);
+		if (!$found) return Effect.succeed(false);
+		if (!dispatch) return Effect.succeed(true);
+		return Effect.as(dispatch(state.tr.setSelectionUnsafe(new GapCursor($found))), true);
+	});
+}
+const handleKeyDown = keydownHandler({
+	ArrowLeft: arrow("horiz", -1),
+	ArrowRight: arrow("horiz", 1),
+	ArrowUp: arrow("vert", -1),
+	ArrowDown: arrow("vert", 1)
+});
+function handleClick(view, pos, event) {
+	if (!view || !view.editable) return false;
+	const $pos = view.state.doc.resolveUnsafe(pos);
+	if (!GapCursor.valid($pos)) return false;
+	const clickPos = Option.getOrNull(view.posAtCoords({
+		left: event.clientX,
+		top: event.clientY
+	}));
+	if (clickPos && clickPos.inside > -1) {
+		const node = view.state.doc.nodeAtOrNull(clickPos.inside);
+		if (node && NodeSelection.isSelectable(node)) return false;
+	}
+	return Effect.as(view.dispatch(view.state.tr.setSelectionUnsafe(new GapCursor($pos))), true);
+}
+function beforeinput(view, event) {
+	if (event.inputType !== "insertCompositionText" || !(view.state.selection instanceof GapCursor)) return false;
+	const { $from } = view.state.selection;
+	const insert = $from.parent.contentMatchAtUnsafe($from.index()).findWrappingOrNull(view.state.schema.nodes.text);
+	if (!insert) return false;
+	let frag = Fragment.empty;
+	for (let i = insert.length - 1; i >= 0; i--) frag = Fragment.from(insert[i].createAndFillOrNull(null, frag));
+	const tr = view.state.tr.replaceUnsafe($from.pos, $from.pos, new Slice(frag, 0, 0));
+	tr.setSelectionUnsafe(TextSelection.near(tr.doc.resolveUnsafe($from.pos + 1)));
+	return Effect.as(view.dispatch(tr), false);
+}
+function drawGapCursor(state) {
+	if (!(state.selection instanceof GapCursor)) return null;
+	const widget = Decoration.widget(state.selection.head, (view) => {
+		const node = view.dom.ownerDocument.createElement("div");
+		node.className = "ProseMirror-gapcursor";
+		return node;
+	}, { key: "gapcursor" });
+	return DecorationSet.create(state.doc, [widget]);
+}
+/**
+* The gap cursor's stylesheet (from `prosemirror-gapcursor`'s
+* `style/gapcursor.css`). Add it to the page (for example with
+* `injectCSS` from `@thomasfosterau/effect-richtext/view-css`) or provide your own
+* styles for `.ProseMirror-gapcursor`.
+*
+* @since 0.1.0
+* @category styles
+*/
+const gapCursorCSS = `.ProseMirror-gapcursor {
+  display: none;
+  pointer-events: none;
+  position: absolute;
+}
+
+.ProseMirror-gapcursor:after {
+  content: "";
+  display: block;
+  position: absolute;
+  top: -2px;
+  width: 20px;
+  border-top: 1px solid black;
+  animation: ProseMirror-cursor-blink 1.1s steps(2, start) infinite;
+}
+
+@keyframes ProseMirror-cursor-blink {
+  to {
+    visibility: hidden;
+  }
+}
+
+.ProseMirror-focused .ProseMirror-gapcursor {
+  display: block;
+}
+`;
+export { GapCursor, gapCursor, gapCursorCSS };