@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/compat/state.js

@@ -0,0 +1,689 @@
+import { Plugin as Plugin$1, PluginKey as PluginKey$1 } from "../state/plugin.js";
+import { AllSelection as AllSelection$1, NodeSelection as NodeSelection$1, Selection as Selection$1, SelectionRange as SelectionRange$1, TextSelection as TextSelection$1 } from "../state/selection.js";
+import { Transaction as Transaction$1 } from "../state/transaction.js";
+import { EditorState as EditorState$1 } from "../state/state.js";
+import { BASE, CORE, adopt, callBase, getBase, guard, isFacade, link, registerWrapper, runSync, unwrap, unwrapArray, wrap, wrapArray } from "./internal/core.js";
+import { propsFromCore, propsToCore } from "./internal/props.js";
+import { Slice } from "./model.js";
+import { Transform } from "./transform.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+// src/compat/state.ts
+/**
+* A `prosemirror-state`-compatible facade over `@thomasfosterau/effect-richtext/state`.
+*
+* `Selection` can be subclassed like ProseMirror's: a subclass of the
+* facade `Selection` is adapted into a core selection that calls back
+* into it. Plugins are written with ProseMirror's plugin spec (hooks
+* and props receive facades) and bridged to core plugins. Commands are
+* plain `(state, dispatch?, view?) => boolean` functions;
+* `fromCoreCommand` / `toCoreCommand` convert between them and core
+* commands.
+*
+* Ported API surface from prosemirror-state (MIT, Marijn Haverbeke and others).
+*
+* @since 0.1.0
+*/
+const INTERNAL = Symbol("effect-richtext/compat/internal");
+/**
+* Represents a selected range in a document.
+*
+* @since 0.1.0
+* @category models
+*/
+var SelectionRange = class {
+	/** Create a range. */
+	constructor($from, $to) {
+		link(this, new SelectionRange$1($from[CORE], $to[CORE]));
+	}
+	/** The lower bound of the range. */
+	get $from() {
+		return wrap(this[CORE].$from);
+	}
+	/** The upper bound of the range. */
+	get $to() {
+		return wrap(this[CORE].$to);
+	}
+};
+registerWrapper(SelectionRange$1, (core) => adopt(SelectionRange.prototype, core));
+var BookmarkFacade = class {
+	map(mapping) {
+		return bookmarkFromCore(this[CORE].map(unwrap(mapping)));
+	}
+	resolve(doc) {
+		return wrap(this[CORE].resolve(doc[CORE]));
+	}
+};
+const bookmarkFacades = /* @__PURE__ */ new WeakMap();
+const bookmarkCores = /* @__PURE__ */ new WeakMap();
+const bookmarkFromCore = (core) => {
+	let found = bookmarkFacades.get(core);
+	if (!found) {
+		if (core[ADAPTED_BOOKMARK]) return core[ADAPTED_BOOKMARK];
+		found = link(new BookmarkFacade(), core);
+		bookmarkFacades.set(core, found);
+	}
+	return found;
+};
+const ADAPTED_BOOKMARK = Symbol("effect-richtext/compat/bookmark");
+const bookmarkToCore = (bookmark) => {
+	if (isFacade(bookmark)) return bookmark[CORE];
+	let found = bookmarkCores.get(bookmark);
+	if (!found) {
+		found = {
+			[ADAPTED_BOOKMARK]: bookmark,
+			map: (mapping) => bookmarkToCore(bookmark.map(wrap(mapping))),
+			resolve: (doc) => bookmark.resolve(wrap(doc))[CORE]
+		};
+		bookmarkCores.set(bookmark, found);
+	}
+	return found;
+};
+/**
+* Superclass for editor selections. Subclass it to define custom
+* selection types: subclasses are adapted into core selections.
+*
+* @since 0.1.0
+* @category models
+*/
+var Selection = class {
+	/** Initialize a selection with the head and anchor and ranges. */
+	constructor($anchor, $head, ranges) {
+		if ($anchor === INTERNAL) {
+			const [CoreClass, args] = $head;
+			link(this, guard(() => coreSelection(this, new.target, CoreClass, args)));
+		} else {
+			const args = [
+				$anchor[CORE],
+				$head[CORE],
+				ranges && unwrapArray(ranges)
+			];
+			link(this, coreSelection(this, new.target, Selection$1, args));
+		}
+	}
+	/** The ranges covered by the selection. */
+	get ranges() {
+		return wrapArray(this[CORE].ranges);
+	}
+	/** The resolved anchor of the selection. */
+	get $anchor() {
+		return wrap(this[CORE].$anchor);
+	}
+	/** The resolved head of the selection. */
+	get $head() {
+		return wrap(this[CORE].$head);
+	}
+	/** The selection's anchor, as an unresolved position. */
+	get anchor() {
+		return this[CORE].anchor;
+	}
+	/** The selection's head. */
+	get head() {
+		return this[CORE].head;
+	}
+	/** The lower bound of the selection's main range. */
+	get from() {
+		return this[CORE].from;
+	}
+	/** The upper bound of the selection's main range. */
+	get to() {
+		return this[CORE].to;
+	}
+	/** The resolved lower bound of the selection's main range. */
+	get $from() {
+		return wrap(this[CORE].$from);
+	}
+	/** The resolved upper bound of the selection's main range. */
+	get $to() {
+		return wrap(this[CORE].$to);
+	}
+	/** Indicates whether the selection contains any content. */
+	get empty() {
+		return this[CORE].empty;
+	}
+	/** Controls whether, when a selection of this type is active in the browser, the selected range should be visible to the user. */
+	get visible() {
+		return getBase(this[CORE], "visible");
+	}
+	/** Get the content of this selection as a slice. */
+	content() {
+		return wrap(guard(() => callBase(this[CORE], "content")));
+	}
+	/** Replace the selection with a slice or, if no slice is given, delete the selection. */
+	replace(tr, content = Slice.empty) {
+		guard(() => callBase(this[CORE], "replace", [tr[CORE], content[CORE]]));
+	}
+	/** Replace the selection with the given node, appending the changes to the given transaction. */
+	replaceWith(tr, node) {
+		guard(() => callBase(this[CORE], "replaceWith", [tr[CORE], node[CORE]]));
+	}
+	/** Find a valid cursor or leaf node selection starting at the given position and searching back if `dir` is negative, and forward if positive. */
+	static findFrom($pos, dir, textOnly = false) {
+		return wrap(guard(() => Selection$1.findFromOrNull($pos[CORE], dir, textOnly)));
+	}
+	/** Find a valid cursor or leaf node selection near the given position. */
+	static near($pos, bias = 1) {
+		return wrap(guard(() => Selection$1.near($pos[CORE], bias)));
+	}
+	/** Find the cursor or leaf node selection closest to the start of the given document. */
+	static atStart(doc) {
+		return wrap(guard(() => Selection$1.atStart(doc[CORE])));
+	}
+	/** Find the cursor or leaf node selection closest to the end of the given document. */
+	static atEnd(doc) {
+		return wrap(guard(() => Selection$1.atEnd(doc[CORE])));
+	}
+	/** Deserialize the JSON representation of a selection. */
+	static fromJSON(doc, json) {
+		return wrap(guard(() => Selection$1.fromJSONUnsafe(doc[CORE], json)));
+	}
+	/** To be able to deserialize selections from JSON, custom selection classes must register themselves with an ID string. */
+	static jsonID(id, selectionClass) {
+		try {
+			Selection$1.jsonID(id, { fromJSONUnsafe: (doc, json) => selectionClass.fromJSON(wrap(doc), json)[CORE] });
+		} catch (e) {
+			throw new RangeError(e.message);
+		}
+		selectionClass.prototype.jsonID = id;
+		return selectionClass;
+	}
+	/** Get a bookmark for this selection. */
+	getBookmark() {
+		return bookmarkFromCore(callBase(this[CORE], "getBookmark"));
+	}
+};
+const getterOf = (proto, prop) => {
+	for (; proto; proto = Object.getPrototypeOf(proto)) {
+		const desc = Object.getOwnPropertyDescriptor(proto, prop);
+		if (desc) return desc.get;
+	}
+};
+const adaptedSelectionClasses = /* @__PURE__ */ new WeakMap();
+/**
+* The core class used for instances of user subclasses of a facade
+* selection class: a subclass of the corresponding core class whose
+* methods call the facade's overrides, when it has them. @internal
+*/
+const adaptedSelectionClass = (CoreClass, FacadeClass) => {
+	let found = adaptedSelectionClasses.get(CoreClass);
+	if (!found) {
+		const base = FacadeClass.prototype, baseVisible = getterOf(base, "visible");
+		found = class extends CoreClass {
+			get visible() {
+				const get = getterOf(Object.getPrototypeOf(this.facade), "visible");
+				return get && get !== baseVisible ? get.call(this.facade) : super.visible;
+			}
+			eq(other) {
+				return this.facade.eq === base.eq ? super.eq(other) : this.facade.eq(wrap(other));
+			}
+			map(doc, mapping) {
+				return this.facade.map === base.map ? super.map(doc, mapping) : this.facade.map(wrap(doc), wrap(mapping))[CORE];
+			}
+			content() {
+				return this.facade.content === base.content ? super.content() : this.facade.content()[CORE];
+			}
+			replace(tr, content) {
+				if (this.facade.replace === base.replace) super.replace(tr, content);
+				else this.facade.replace(wrap(tr), content === void 0 ? Slice.empty : wrap(content));
+			}
+			replaceWith(tr, node) {
+				if (this.facade.replaceWith === base.replaceWith) super.replaceWith(tr, node);
+				else this.facade.replaceWith(wrap(tr), wrap(node));
+			}
+			toJSON() {
+				return this.facade.toJSON === base.toJSON ? super.toJSON() : this.facade.toJSON();
+			}
+			getBookmark() {
+				return this.facade.getBookmark === base.getBookmark ? super.getBookmark() : bookmarkToCore(this.facade.getBookmark());
+			}
+		};
+		found.prototype[BASE] = CoreClass.prototype;
+		adaptedSelectionClasses.set(CoreClass, found);
+	}
+	return found;
+};
+const coreSelection = (facade, target, CoreClass, args) => {
+	const FacadeClass = CoreClass === TextSelection$1 ? TextSelection : CoreClass === NodeSelection$1 ? NodeSelection : CoreClass === AllSelection$1 ? AllSelection : Selection;
+	if (target === FacadeClass) return new CoreClass(...args);
+	const core = new (adaptedSelectionClass(CoreClass, FacadeClass))(...args);
+	core.facade = facade;
+	return core;
+};
+/**
+* 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.
+*
+* @since 0.1.0
+* @category models
+*/
+var TextSelection = class extends Selection {
+	/** Construct a text selection between the given points. */
+	constructor($anchor, $head = $anchor) {
+		super(INTERNAL, [TextSelection$1, [$anchor[CORE], $head[CORE]]]);
+	}
+	/** Returns a resolved position if this is a cursor selection (an empty text selection), and null otherwise. */
+	get $cursor() {
+		return wrap(this[CORE].$cursorOrNull);
+	}
+	map(doc, mapping) {
+		return wrap(guard(() => callBase(this[CORE], "map", [doc[CORE], unwrap(mapping)])));
+	}
+	eq(other) {
+		return callBase(this[CORE], "eq", [other[CORE]]);
+	}
+	toJSON() {
+		return callBase(this[CORE], "toJSON");
+	}
+	/** @internal */
+	static fromJSON(doc, json) {
+		return wrap(guard(() => TextSelection$1.fromJSONUnsafe(doc[CORE], json)));
+	}
+	/** Create a text selection from non-resolved positions. */
+	static create(doc, anchor, head = anchor) {
+		return wrap(guard(() => TextSelection$1.createUnsafe(doc[CORE], anchor, head)));
+	}
+	/** Return a text selection that spans the given positions or, if they aren't text positions, find a text selection near them. */
+	static between($anchor, $head, bias) {
+		return wrap(guard(() => TextSelection$1.between($anchor[CORE], $head[CORE], bias)));
+	}
+};
+/**
+* A node selection is a selection that points at a single node.
+*
+* @since 0.1.0
+* @category models
+*/
+var NodeSelection = class extends Selection {
+	/** Create a node selection. Does not verify the validity of its argument. */
+	constructor($pos) {
+		super(INTERNAL, [NodeSelection$1, [$pos[CORE]]]);
+	}
+	/** The selected node. */
+	get node() {
+		return wrap(this[CORE].node);
+	}
+	map(doc, mapping) {
+		return wrap(guard(() => callBase(this[CORE], "map", [doc[CORE], unwrap(mapping)])));
+	}
+	eq(other) {
+		return callBase(this[CORE], "eq", [other[CORE]]);
+	}
+	toJSON() {
+		return callBase(this[CORE], "toJSON");
+	}
+	/** @internal */
+	static fromJSON(doc, json) {
+		return wrap(guard(() => NodeSelection$1.fromJSONUnsafe(doc[CORE], json)));
+	}
+	/** Create a node selection from non-resolved positions. */
+	static create(doc, from) {
+		return wrap(guard(() => NodeSelection$1.createUnsafe(doc[CORE], from)));
+	}
+	/** Determines whether the given node may be selected as a node selection. */
+	static isSelectable(node) {
+		return NodeSelection$1.isSelectable(node[CORE]);
+	}
+};
+/**
+* A selection type that represents selecting the whole document.
+*
+* @since 0.1.0
+* @category models
+*/
+var AllSelection = class extends Selection {
+	/** Create an all-selection over the given document. */
+	constructor(doc) {
+		super(INTERNAL, [AllSelection$1, [doc[CORE]]]);
+	}
+	map(doc) {
+		return wrap(callBase(this[CORE], "map", [doc[CORE]]));
+	}
+	eq(other) {
+		return callBase(this[CORE], "eq", [other[CORE]]);
+	}
+	toJSON() {
+		return callBase(this[CORE], "toJSON");
+	}
+};
+registerWrapper(TextSelection$1, (core) => adopt(TextSelection.prototype, core));
+registerWrapper(NodeSelection$1, (core) => adopt(NodeSelection.prototype, core));
+registerWrapper(AllSelection$1, (core) => adopt(AllSelection.prototype, core));
+const metaKey = (key) => typeof key === "string" ? key : key.key;
+/**
+* An editor state transaction, which can be applied to a state to
+* create an updated state.
+*
+* @since 0.1.0
+* @category models
+*/
+var Transaction = class extends Transform {
+	/** @internal */
+	constructor(state) {
+		super(state.doc);
+		link(this, new Transaction$1(state[CORE]));
+	}
+	/** The timestamp associated with this transaction. */
+	get time() {
+		return this[CORE].time;
+	}
+	set time(value) {
+		this[CORE].time = value;
+	}
+	/** The stored marks set by this transaction, if any. */
+	get storedMarks() {
+		const marks = this[CORE].storedMarksOrNull;
+		return marks && wrapArray(marks);
+	}
+	/** The transaction's current selection. */
+	get selection() {
+		return wrap(this[CORE].selection);
+	}
+	/** Update the transaction's current selection. */
+	setSelection(selection) {
+		guard(() => this[CORE].setSelectionUnsafe(selection[CORE]));
+		return this;
+	}
+	/** Whether the selection was explicitly updated by this transaction. */
+	get selectionSet() {
+		return this[CORE].selectionSet;
+	}
+	/** Set the current stored marks. */
+	setStoredMarks(marks) {
+		this[CORE].setStoredMarks(marks && unwrapArray(marks));
+		return this;
+	}
+	/** Make sure the current stored marks or, if that is null, the marks at the selection, match the given set of marks. */
+	ensureMarks(marks) {
+		this[CORE].ensureMarks(unwrapArray(marks));
+		return this;
+	}
+	/** Add a mark to the set of stored marks. */
+	addStoredMark(mark) {
+		this[CORE].addStoredMark(mark[CORE]);
+		return this;
+	}
+	/** Remove a mark or mark type from the set of stored marks. */
+	removeStoredMark(mark) {
+		this[CORE].removeStoredMark(mark[CORE]);
+		return this;
+	}
+	/** Whether the stored marks were explicitly set for this transaction. */
+	get storedMarksSet() {
+		return this[CORE].storedMarksSet;
+	}
+	/** Update the timestamp for the transaction. */
+	setTime(time) {
+		this[CORE].setTime(time);
+		return this;
+	}
+	/** Replace the current selection with the given slice. */
+	replaceSelection(slice) {
+		guard(() => this[CORE].replaceSelection(slice[CORE]));
+		return this;
+	}
+	/** Replace the selection with the given node. */
+	replaceSelectionWith(node, inheritMarks = true) {
+		guard(() => this[CORE].replaceSelectionWith(node[CORE], inheritMarks));
+		return this;
+	}
+	/** Delete the selection. */
+	deleteSelection() {
+		guard(() => this[CORE].deleteSelection());
+		return this;
+	}
+	/** Replace the given range, or the selection if no range is given, with a text node containing the given string. */
+	insertText(text, from, to) {
+		guard(() => this[CORE].insertTextUnsafe(text, from, to));
+		return this;
+	}
+	/** Store a metadata property in this transaction, keyed either by name or by plugin. */
+	setMeta(key, value) {
+		this[CORE].setMeta(metaKey(key), value);
+		return this;
+	}
+	/** Retrieve a metadata property for a given name or plugin. */
+	getMeta(key) {
+		return wrap(Option.getOrUndefined(this[CORE].getMeta(metaKey(key))));
+	}
+	/** Returns true if this transaction doesn't contain any metadata, and can thus safely be extended. */
+	get isGeneric() {
+		return this[CORE].isGeneric;
+	}
+	/** Indicate that the editor should scroll the selection into view when updated to the state produced by this transaction. */
+	scrollIntoView() {
+		this[CORE].scrollIntoView();
+		return this;
+	}
+	/** True when this transaction has had `scrollIntoView` called on it. */
+	get scrolledIntoView() {
+		return this[CORE].scrolledIntoView;
+	}
+};
+registerWrapper(Transaction$1, (core) => adopt(Transaction.prototype, core));
+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 configs = /* @__PURE__ */ new WeakMap();
+const facadeConfig = (config) => configs.get(config) ?? config;
+const pluginViewToCore = (pluginView) => ({
+	get update() {
+		return pluginView.update && ((view, prevState) => pluginView.update(wrap(view), wrap(prevState)));
+	},
+	get destroy() {
+		return pluginView.destroy && (() => pluginView.destroy());
+	}
+});
+const pluginSpecToCore = (spec, self) => {
+	const result = { ...spec };
+	result.key = spec.key && spec.key[CORE];
+	const state = spec.state;
+	if (state) result.state = {
+		init: (config, instance) => state.init.call(self, facadeConfig(config), wrap(instance)),
+		apply: (tr, value, oldState, newState) => state.apply.call(self, wrap(tr), value, wrap(oldState), wrap(newState)),
+		toJSON: state.toJSON && ((value) => state.toJSON.call(self, value)),
+		fromJSON: state.fromJSON && ((config, value, instance) => state.fromJSON.call(self, facadeConfig(config), value, wrap(instance)))
+	};
+	const filter = spec.filterTransaction;
+	if (filter) result.filterTransaction = (tr, s) => filter.call(self, wrap(tr), wrap(s));
+	const append = spec.appendTransaction;
+	if (append) result.appendTransaction = (trs, oldState, newState) => unwrap(append.call(self, trs.map(wrap), wrap(oldState), wrap(newState)));
+	const view = spec.view;
+	if (view) result.view = (v) => pluginViewToCore(view.call(self, wrap(v)));
+	result.props = spec.props ? propsToCore(spec.props, self) : void 0;
+	return result;
+};
+/**
+* Plugins bundle functionality that can be added to an editor.
+*
+* @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);
+		link(this, guard(() => new Plugin$1(pluginSpecToCore(spec, this))));
+	}
+	/** @internal */
+	get key() {
+		return this[CORE].key;
+	}
+	/** Extract the plugin's state field from an editor state. */
+	getState(state) {
+		return state[CORE].slots[this.key];
+	}
+};
+registerWrapper(Plugin$1, (core) => {
+	const plugin = adopt(Plugin.prototype, core);
+	plugin.spec = core.spec;
+	plugin.props = propsFromCore(core.props, core);
+	return plugin;
+});
+/**
+* A key is used to tag plugins in a way that makes it possible to find
+* them, given an editor state.
+*
+* @since 0.1.0
+* @category models
+*/
+var PluginKey = class {
+	/** Create a plugin key. */
+	constructor(name = "key") {
+		link(this, new PluginKey$1(name));
+	}
+	/** @internal */
+	get key() {
+		return this[CORE].key;
+	}
+	/** Get the active plugin with this key, if any, from an editor state. */
+	get(state) {
+		return wrap(state[CORE].config.pluginsByKey[this.key]);
+	}
+	/** Get the plugin's state from an editor state. */
+	getState(state) {
+		return state[CORE].slots[this.key];
+	}
+};
+registerWrapper(PluginKey$1, (core) => adopt(PluginKey.prototype, core));
+const configToCore = (config) => {
+	const result = { ...config };
+	if (config.schema) result.schema = config.schema[CORE];
+	if (config.doc) result.doc = config.doc[CORE];
+	if (config.selection) result.selection = config.selection[CORE];
+	if (config.storedMarks) result.storedMarks = unwrapArray(config.storedMarks);
+	if (config.plugins) result.plugins = config.plugins.map(unwrap);
+	configs.set(result, config);
+	return result;
+};
+/**
+* The state of a ProseMirror editor.
+*
+* @since 0.1.0
+* @category models
+*/
+var EditorState = class {
+	/** @internal */
+	constructor() {}
+	/** The current document. */
+	get doc() {
+		return wrap(this[CORE].doc);
+	}
+	/** The selection. */
+	get selection() {
+		return wrap(this[CORE].selection);
+	}
+	/** A set of marks to apply to the next input. Will be null when no explicit marks have been set. */
+	get storedMarks() {
+		const marks = this[CORE].storedMarksOrNull;
+		return marks && wrapArray(marks);
+	}
+	/** @internal */
+	get scrollToSelection() {
+		return this[CORE].scrollToSelection;
+	}
+	/** The schema of the state's document. */
+	get schema() {
+		return wrap(this[CORE].schema);
+	}
+	/** The plugins that are active in this state. */
+	get plugins() {
+		return wrapArray(this[CORE].plugins);
+	}
+	/** Apply the given transaction to produce a new state. */
+	apply(tr) {
+		return this.applyTransaction(tr).state;
+	}
+	/** @internal */
+	filterTransaction(tr, ignore = -1) {
+		return runSync(this[CORE].filterTransaction(tr[CORE], ignore));
+	}
+	/** Verbose variant of `apply` that returns the precise transactions that were applied and the new state. */
+	applyTransaction(rootTr) {
+		const result = runSync(this[CORE].applyTransaction(rootTr[CORE]));
+		return {
+			state: wrap(result.state),
+			transactions: result.transactions.map(wrap)
+		};
+	}
+	/** Start a transaction from this state. */
+	get tr() {
+		return wrap(this[CORE].tr);
+	}
+	/** Create a new state based on this one, but with an adjusted set of active plugins. */
+	reconfigure(config) {
+		return wrap(runSync(this[CORE].reconfigure(configToCore(config))));
+	}
+	/** Serialize this state to JSON. */
+	toJSON(pluginFields) {
+		let fields;
+		if (pluginFields && typeof pluginFields == "object") {
+			fields = {};
+			for (const prop in pluginFields) fields[prop] = unwrap(pluginFields[prop]);
+		}
+		return guard(() => this[CORE].toJSON(fields));
+	}
+	/** Create a new state. */
+	static create(config) {
+		return wrap(runSync(EditorState$1.create(configToCore(config))));
+	}
+	/** Deserialize a JSON representation of a state. */
+	static fromJSON(config, json, pluginFields) {
+		const fields = pluginFields && {};
+		if (pluginFields) for (const prop in pluginFields) fields[prop] = unwrap(pluginFields[prop]);
+		return wrap(runSync(EditorState$1.fromJSON(configToCore(config), json, fields)));
+	}
+};
+registerWrapper(EditorState$1, (core) => adopt(EditorState.prototype, core));
+const pmCommands = /* @__PURE__ */ new WeakMap();
+const coreCommands = /* @__PURE__ */ new WeakMap();
+/**
+* Convert a core (Effect) command into a ProseMirror-style command. The
+* command is run synchronously; failures are thrown.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const fromCoreCommand = (command) => {
+	let found = pmCommands.get(command);
+	if (!found) {
+		found = (state, dispatch, view) => runSync(command(state[CORE], dispatch && ((tr) => Effect.sync(() => dispatch(wrap(tr)))), view && unwrap(view)));
+		pmCommands.set(command, found);
+		coreCommands.set(found, command);
+	}
+	return found;
+};
+/**
+* Convert a ProseMirror-style command into a core (Effect) command.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const toCoreCommand = (command) => {
+	let found = coreCommands.get(command);
+	if (!found) {
+		found = (state, dispatch, view) => Effect.sync(() => command(wrap(state), dispatch && ((tr) => runSync(dispatch(tr[CORE]))), view && wrap(view)));
+		coreCommands.set(command, found);
+		pmCommands.set(found, command);
+	}
+	return found;
+};
+function toCore(value) {
+	if (typeof value === "function") return toCoreCommand(value);
+	if (value instanceof BookmarkFacade || value && !isFacade(value) && typeof value.resolve === "function") return bookmarkToCore(value);
+	return unwrap(value);
+}
+function fromCore(value) {
+	if (typeof value === "function") return fromCoreCommand(value);
+	return wrap(value);
+}
+export { AllSelection, EditorState, NodeSelection, Plugin, PluginKey, Selection, SelectionRange, TextSelection, Transaction, fromCore, fromCoreCommand, toCore, toCoreCommand };