@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/compat/model.js

@@ -0,0 +1,1212 @@
+import { Fragment as Fragment$1 } from "../model/fragment.js";
+import { ContentMatch as ContentMatch$1 } from "../model/content.js";
+import { Mark as Mark$1 } from "../model/mark.js";
+import { Slice as Slice$1 } from "../model/replace.js";
+import { DOMParser as DOMParser$1 } from "../model/from_dom.js";
+import { NodeRange as NodeRange$1, ResolvedPos as ResolvedPos$1 } from "../model/resolvedpos.js";
+import { Node as Node$1, TextNode as TextNode$1 } from "../model/node.js";
+import { DocSchema, MarkType as MarkType$1, NodeType as NodeType$1 } from "../model/schema.js";
+import { DOMSerializer as DOMSerializer$1 } from "../model/to_dom.js";
+import { CORE, ReplaceError, adopt, guard, link, registerWrapper, setEmptyCoreArray, unwrap, unwrapArray, wrap, wrapArray } from "./internal/core.js";
+import { OrderedMap } from "./orderedmap.js";
+import * as Option from "effect/Option";
+// src/compat/model.ts
+/**
+* A `prosemirror-model`-compatible facade over `@thomasfosterau/effect-richtext/model`.
+*
+* The classes exported here have the API of their ProseMirror
+* counterparts (nullable results instead of `Option`, exceptions
+* instead of `Effect` failures, string content expressions,
+* `OrderedMap` specs, `new Schema(spec)`), and delegate all work to
+* the core objects they wrap. Wrapping is identity-preserving: the same
+* core object always yields the same facade. Use `toCore` / `fromCore`
+* to move between this API and the Effect API.
+*
+* Ported API surface from prosemirror-model (MIT, Marijn Haverbeke and others).
+*
+* @since 0.1.0
+*/
+const ORIGINAL = Symbol.for("effect-richtext/compat/original");
+/** @internal */
+const fragmentInput = (content) => {
+	if (content == null) return content;
+	if (Array.isArray(content)) return unwrapArray(content);
+	return unwrap(content);
+};
+const marksInput = (marks) => marks == null ? marks : unwrapArray(marks);
+const nullable = (o) => wrap(Option.getOrNull(o));
+/**
+* This class represents a node in the tree that makes up a ProseMirror
+* document.
+*
+* @since 0.1.0
+* @category models
+*/
+var Node = class {
+	/** @internal */
+	constructor(type, attrs, content, marks = Mark.none) {
+		link(this, new Node$1(type[CORE], attrs, content ? content[CORE] : null, unwrapArray(marks)));
+	}
+	/** The type of node that this is. */
+	get type() {
+		return wrap(this[CORE].type);
+	}
+	/** An object mapping attribute names to values. */
+	get attrs() {
+		return this[CORE].attrs;
+	}
+	/** A container holding the node's children. */
+	get content() {
+		return wrap(this[CORE].content);
+	}
+	/** The marks (things like whether it is emphasized or part of a link) applied to this node. */
+	get marks() {
+		return wrapArray(this[CORE].marks);
+	}
+	/** For text nodes, this contains the node's text content. */
+	get text() {}
+	/** The array of this node's child nodes. */
+	get children() {
+		return wrapArray(this[CORE].content.content);
+	}
+	/** The size of this node, as defined by the integer-based indexing scheme. */
+	get nodeSize() {
+		return this[CORE].nodeSize;
+	}
+	/** The number of children that the node has. */
+	get childCount() {
+		return this[CORE].childCount;
+	}
+	/** Get the child node at the given index. Raises an error when the index is out of range. */
+	child(index) {
+		return wrap(guard(() => this[CORE].childUnsafe(index)));
+	}
+	/** Get the child node at the given index, if it exists. */
+	maybeChild(index) {
+		return wrap(this[CORE].content.content[index] ?? null);
+	}
+	/** Call `f` for every child node. */
+	forEach(f) {
+		this[CORE].forEach((node, offset, index) => f(wrap(node), offset, index));
+	}
+	/** Invoke a callback for all descendant nodes recursively overlapping the given two positions. */
+	nodesBetween(from, to, f, startPos = 0) {
+		this[CORE].nodesBetween(from, to, visitor(f), startPos);
+	}
+	/** Call the given callback for every descendant node. */
+	descendants(f) {
+		this[CORE].descendants(visitor(f));
+	}
+	/** Concatenates all the text nodes found in this fragment and its children. */
+	get textContent() {
+		return this[CORE].textContent;
+	}
+	/** Get all text between positions `from` and `to`. */
+	textBetween(from, to, blockSeparator, leafText) {
+		return this[CORE].textBetween(from, to, blockSeparator, leafTextInput(leafText));
+	}
+	/** Returns this node's first child, or `null` if there are no children. */
+	get firstChild() {
+		return nullable(this[CORE].firstChild);
+	}
+	/** Returns this node's last child, or `null` if there are no children. */
+	get lastChild() {
+		return nullable(this[CORE].lastChild);
+	}
+	/** Test whether two nodes represent the same piece of document. */
+	eq(other) {
+		return this === other || this[CORE].eq(other[CORE]);
+	}
+	/** Compare the markup (type, attributes, and marks) of this node to those of another. */
+	sameMarkup(other) {
+		return this[CORE].sameMarkup(other[CORE]);
+	}
+	/** Check whether this node's markup correspond to the given type, attributes, and marks. */
+	hasMarkup(type, attrs, marks) {
+		return this[CORE].hasMarkup(type[CORE], attrs, marksInput(marks));
+	}
+	/** Create a new node with the same markup as this node, containing the given content. */
+	copy(content = null) {
+		return wrap(this[CORE].copy(content && content[CORE]));
+	}
+	/** Create a copy of this node, with the given set of marks instead of the node's own marks. */
+	mark(marks) {
+		return wrap(this[CORE].mark(unwrapArray(marks)));
+	}
+	/** Create a copy of this node with only the content between the given positions. */
+	cut(from, to) {
+		return wrap(this[CORE].cut(from, to));
+	}
+	/** Cut out the part of the document between the given positions, and return it as a `Slice` object. */
+	slice(from, to = this.content.size, includeParents = false) {
+		return wrap(guard(() => this[CORE].sliceUnsafe(from, to, includeParents)));
+	}
+	/** Replace the part of the document between the given positions with the given slice. */
+	replace(from, to, slice) {
+		return wrap(guard(() => this[CORE].replaceUnsafe(from, to, slice[CORE])));
+	}
+	/** Find the node directly after the given position. */
+	nodeAt(pos) {
+		return wrap(this[CORE].nodeAtOrNull(pos));
+	}
+	/** Find the (direct) child node after the given offset, if any. */
+	childAfter(pos) {
+		const { index, node, offset } = guard(() => this[CORE].childAfter(pos));
+		return {
+			node: nullable(node),
+			index,
+			offset
+		};
+	}
+	/** Find the (direct) child node before the given offset, if any. */
+	childBefore(pos) {
+		const { index, node, offset } = guard(() => this[CORE].childBefore(pos));
+		return {
+			node: nullable(node),
+			index,
+			offset
+		};
+	}
+	/** Resolve the given position in the document. */
+	resolve(pos) {
+		return wrap(guard(() => this[CORE].resolveUnsafe(pos)));
+	}
+	/** @internal */
+	resolveNoCache(pos) {
+		return wrap(guard(() => this[CORE].resolveNoCache(pos)));
+	}
+	/** Test whether a given mark or mark type occurs in this document between the two given positions. */
+	rangeHasMark(from, to, type) {
+		return this[CORE].rangeHasMark(from, to, type[CORE]);
+	}
+	/** True when this is a block (non-inline node). */
+	get isBlock() {
+		return this[CORE].isBlock;
+	}
+	/** True when this is a textblock node, a block node with inline content. */
+	get isTextblock() {
+		return this[CORE].isTextblock;
+	}
+	/** True when this node allows inline content. */
+	get inlineContent() {
+		return this[CORE].inlineContent;
+	}
+	/** True when this is an inline node. */
+	get isInline() {
+		return this[CORE].isInline;
+	}
+	/** True when this is a text node. */
+	get isText() {
+		return this[CORE].isText;
+	}
+	/** True when this is a leaf node. */
+	get isLeaf() {
+		return this[CORE].isLeaf;
+	}
+	/** True when this is an atom. */
+	get isAtom() {
+		return this[CORE].isAtom;
+	}
+	/** Return a string representation of this node for debugging purposes. */
+	toString() {
+		return this[CORE].toString();
+	}
+	/** Get the content match in this node at the given index. */
+	contentMatchAt(index) {
+		return wrap(guard(() => this[CORE].contentMatchAtUnsafe(index)));
+	}
+	/**
+	* Test whether replacing the range between `from` and `to` (by child
+	* index) with the given replacement fragment would leave the node's
+	* content valid.
+	*/
+	canReplace(from, to, replacement = Fragment.empty, start = 0, end) {
+		return guard(() => this[CORE].canReplace(from, to, replacement[CORE], start, end));
+	}
+	/** Test whether replacing the range `from` to `to` (by index) with a node of the given type would be valid. */
+	canReplaceWith(from, to, type, marks) {
+		return guard(() => this[CORE].canReplaceWith(from, to, type[CORE], marksInput(marks)));
+	}
+	/** Test whether the given node's content could be appended to this node. */
+	canAppend(other) {
+		return guard(() => this[CORE].canAppend(other[CORE]));
+	}
+	/** Check whether this node and its descendants conform to the schema, and raise an exception when they do not. */
+	check() {
+		guard(() => this[CORE].checkUnsafe());
+	}
+	/** Return a JSON-serializeable representation of this node. */
+	toJSON() {
+		return this[CORE].toJSON();
+	}
+	/** Deserialize a node from its JSON representation. */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => schema[CORE].nodeFromJSONUnsafe(json)));
+	}
+};
+/** @internal */
+var TextNode = class extends Node {
+	get text() {
+		return this[CORE].text;
+	}
+	/** @internal */
+	withText(text) {
+		return wrap(this[CORE].withText(text));
+	}
+};
+const visitor = (f) => (node, pos, parent, index) => f(wrap(node), pos, nullable(parent), index);
+const leafTextInput = (leafText) => typeof leafText === "function" ? (node) => leafText(wrap(node)) : leafText;
+registerWrapper(Node$1, (core) => adopt(Node.prototype, core));
+registerWrapper(TextNode$1, (core) => adopt(TextNode.prototype, core));
+/**
+* A fragment represents a node's collection of child nodes.
+*
+* @since 0.1.0
+* @category models
+*/
+var Fragment = class Fragment {
+	/** @internal */
+	constructor(content, size) {
+		link(this, new Fragment$1(unwrapArray(content), size));
+	}
+	/** The child nodes in this fragment. */
+	get content() {
+		return wrapArray(this[CORE].content);
+	}
+	/** The size of the fragment, which is the total of the size of its content nodes. */
+	get size() {
+		return this[CORE].size;
+	}
+	/** Invoke a callback for all descendant nodes between the given two positions. */
+	nodesBetween(from, to, f, nodeStart = 0, parent) {
+		this[CORE].nodesBetween(from, to, visitor(f), nodeStart, parent && parent[CORE]);
+	}
+	/** Call the given callback for every descendant node. */
+	descendants(f) {
+		this[CORE].descendants(visitor(f));
+	}
+	/** Extract the text between `from` and `to`. */
+	textBetween(from, to, blockSeparator, leafText) {
+		return this[CORE].textBetween(from, to, blockSeparator, leafTextInput(leafText));
+	}
+	/** Create a new fragment containing the combined content of this fragment and the other. */
+	append(other) {
+		return wrap(this[CORE].append(other[CORE]));
+	}
+	/** Cut out the sub-fragment between the two given positions. */
+	cut(from, to) {
+		return wrap(this[CORE].cut(from, to));
+	}
+	/** @internal */
+	cutByIndex(from, to) {
+		return wrap(this[CORE].cutByIndex(from, to));
+	}
+	/** Create a new fragment in which the node at the given index is replaced by the given node. */
+	replaceChild(index, node) {
+		return wrap(this[CORE].replaceChild(index, node[CORE]));
+	}
+	/** Create a new fragment by prepending the given node to this fragment. */
+	addToStart(node) {
+		return wrap(this[CORE].addToStart(node[CORE]));
+	}
+	/** Create a new fragment by appending the given node to this fragment. */
+	addToEnd(node) {
+		return wrap(this[CORE].addToEnd(node[CORE]));
+	}
+	/** Compare this fragment to another one. */
+	eq(other) {
+		return this[CORE].eq(other[CORE]);
+	}
+	/** The first child of the fragment, or `null` if it is empty. */
+	get firstChild() {
+		return nullable(this[CORE].firstChild);
+	}
+	/** The last child of the fragment, or `null` if it is empty. */
+	get lastChild() {
+		return nullable(this[CORE].lastChild);
+	}
+	/** The number of child nodes in this fragment. */
+	get childCount() {
+		return this[CORE].childCount;
+	}
+	/** Get the child node at the given index. Raise an error when the index is out of range. */
+	child(index) {
+		return wrap(guard(() => this[CORE].childUnsafe(index)));
+	}
+	/** Get the child node at the given index, if it exists. */
+	maybeChild(index) {
+		return wrap(this[CORE].content[index] ?? null);
+	}
+	/** Call `f` for every child node in this fragment. */
+	forEach(f) {
+		this[CORE].forEach((node, offset, index) => f(wrap(node), offset, index));
+	}
+	/** Find the first position at which this fragment and another fragment differ, or `null` if they are the same. */
+	findDiffStart(other, pos = 0) {
+		return Option.getOrNull(this[CORE].findDiffStart(other[CORE], pos));
+	}
+	/** Find the first position, searching from the end, at which this fragment and the given fragment differ. */
+	findDiffEnd(other, pos = this.size, otherPos = other.size) {
+		return Option.getOrNull(this[CORE].findDiffEnd(other[CORE], pos, otherPos));
+	}
+	/** @internal */
+	findIndex(pos) {
+		return guard(() => this[CORE].findIndex(pos));
+	}
+	/** Return a debugging string that describes this fragment. */
+	toString() {
+		return this[CORE].toString();
+	}
+	/** @internal */
+	toStringInner() {
+		return this[CORE].toStringInner();
+	}
+	/** Create a JSON-serializeable representation of this fragment. */
+	toJSON() {
+		return this[CORE].toJSON();
+	}
+	/** Deserialize a fragment from its JSON representation. */
+	static fromJSON(schema, value) {
+		if (!value) return Fragment.empty;
+		if (!Array.isArray(value)) throw new RangeError("Invalid input for Fragment.fromJSON");
+		return wrap(guard(() => Fragment$1.fromArray(value.map((v) => schema[CORE].nodeFromJSONUnsafe(v)))));
+	}
+	/** Build a fragment from an array of nodes. */
+	static fromArray(array) {
+		return wrap(Fragment$1.fromArray(unwrapArray(array)));
+	}
+	/** Create a fragment from something that can be interpreted as a set of nodes. */
+	static from(nodes) {
+		return wrap(guard(() => Fragment$1.from(fragmentInput(nodes))));
+	}
+};
+registerWrapper(Fragment$1, (core) => adopt(Fragment.prototype, core));
+Fragment.empty = wrap(Fragment$1.empty);
+/**
+* A mark is a piece of information that can be attached to a node.
+*
+* @since 0.1.0
+* @category models
+*/
+var Mark = class Mark {
+	/** @internal */
+	constructor(type, attrs) {
+		link(this, new Mark$1(type[CORE], attrs));
+	}
+	/** The type of this mark. */
+	get type() {
+		return wrap(this[CORE].type);
+	}
+	/** The attributes associated with this mark. */
+	get attrs() {
+		return this[CORE].attrs;
+	}
+	/** Given a set of marks, create a new set which contains this one as well. */
+	addToSet(set) {
+		return wrapArray(this[CORE].addToSet(unwrapArray(set)));
+	}
+	/** Remove this mark from the given set. */
+	removeFromSet(set) {
+		return wrapArray(this[CORE].removeFromSet(unwrapArray(set)));
+	}
+	/** Test whether this mark is in the given set of marks. */
+	isInSet(set) {
+		return this[CORE].isInSet(unwrapArray(set));
+	}
+	/** Test whether this mark has the same type and attributes as another mark. */
+	eq(other) {
+		return this === other || this[CORE].eq(other[CORE]);
+	}
+	/** Convert this mark to a JSON-serializeable representation. */
+	toJSON() {
+		return this[CORE].toJSON();
+	}
+	/** @internal */
+	toString() {
+		return this[CORE].toString();
+	}
+	/** Deserialize a mark from JSON. */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => schema[CORE].markFromJSONUnsafe(json)));
+	}
+	/** Test whether two sets of marks are identical. */
+	static sameSet(a, b) {
+		return a === b || Mark$1.sameSet(unwrapArray(a), unwrapArray(b));
+	}
+	/** Create a properly sorted mark set from null, a single mark, or an unsorted array of marks. */
+	static setFrom(marks) {
+		return wrapArray(Mark$1.setFrom(marks instanceof Mark ? marks[CORE] : marksInput(marks)));
+	}
+};
+registerWrapper(Mark$1, (core) => adopt(Mark.prototype, core));
+Mark.none = wrapArray(Mark$1.none);
+setEmptyCoreArray(Mark$1.none);
+/**
+* A slice represents a piece cut out of a larger document.
+*
+* @since 0.1.0
+* @category models
+*/
+var Slice = class {
+	/** Create a slice. */
+	constructor(content, openStart, openEnd) {
+		link(this, new Slice$1(content[CORE], openStart, openEnd));
+	}
+	/** The slice's content. */
+	get content() {
+		return wrap(this[CORE].content);
+	}
+	/** The open depth at the start of the fragment. */
+	get openStart() {
+		return this[CORE].openStart;
+	}
+	/** The open depth at the end. */
+	get openEnd() {
+		return this[CORE].openEnd;
+	}
+	/** The size this slice would add when inserted into a document. */
+	get size() {
+		return this[CORE].size;
+	}
+	/** @internal */
+	insertAt(pos, fragment) {
+		return wrap(guard(() => this[CORE].insertAt(pos, fragment[CORE])));
+	}
+	/** @internal */
+	removeBetween(from, to) {
+		return wrap(guard(() => this[CORE].removeBetween(from, to)));
+	}
+	/** Tests whether this slice is equal to another slice. */
+	eq(other) {
+		return this[CORE].eq(other[CORE]);
+	}
+	/** @internal */
+	toString() {
+		return this[CORE].toString();
+	}
+	/** Convert a slice to a JSON-serializable representation. */
+	toJSON() {
+		return this[CORE].toJSON();
+	}
+	/** Deserialize a slice from its JSON representation. */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => Slice$1.fromJSONUnsafe(schema[CORE], json)));
+	}
+	/** Create a slice from a fragment by taking the maximum possible open value on both side of the fragment. */
+	static maxOpen(fragment, openIsolating = true) {
+		return wrap(Slice$1.maxOpen(fragment[CORE], openIsolating));
+	}
+};
+registerWrapper(Slice$1, (core) => adopt(Slice.prototype, core));
+Slice.empty = wrap(Slice$1.empty);
+/**
+* You can resolve a position to get more information about it.
+*
+* @since 0.1.0
+* @category models
+*/
+var ResolvedPos = class {
+	/** @internal */
+	constructor(pos, path, parentOffset) {
+		link(this, new ResolvedPos$1(pos, path.map((x, i) => i % 3 === 0 ? unwrap(x) : x), parentOffset));
+	}
+	/** The position that was resolved. */
+	get pos() {
+		return this[CORE].pos;
+	}
+	/** @internal */
+	get path() {
+		return this._path ??= this[CORE].path.map((x, i) => i % 3 === 0 ? wrap(x) : x);
+	}
+	/** The offset this position has into its parent node. */
+	get parentOffset() {
+		return this[CORE].parentOffset;
+	}
+	/** The number of levels the parent node is from the root. */
+	get depth() {
+		return this[CORE].depth;
+	}
+	/** The parent node that the position points into. */
+	get parent() {
+		return wrap(this[CORE].parent);
+	}
+	/** The root node in which the position was resolved. */
+	get doc() {
+		return wrap(this[CORE].doc);
+	}
+	/** The ancestor node at the given level. */
+	node(depth) {
+		return wrap(this[CORE].node(depth));
+	}
+	/** The index into the ancestor at the given level. */
+	index(depth) {
+		return this[CORE].index(depth);
+	}
+	/** The index pointing after this position into the ancestor at the given level. */
+	indexAfter(depth) {
+		return this[CORE].indexAfter(depth);
+	}
+	/** The (absolute) position at the start of the node at the given level. */
+	start(depth) {
+		return this[CORE].start(depth);
+	}
+	/** The (absolute) position at the end of the node at the given level. */
+	end(depth) {
+		return this[CORE].end(depth);
+	}
+	/** The (absolute) position directly before the wrapping node at the given level. */
+	before(depth) {
+		return guard(() => this[CORE].beforeUnsafe(depth));
+	}
+	/** The (absolute) position directly after the wrapping node at the given level. */
+	after(depth) {
+		return guard(() => this[CORE].afterUnsafe(depth));
+	}
+	/** When this position points into a text node, this returns the distance between the position and the start of the text node. */
+	get textOffset() {
+		return this[CORE].textOffset;
+	}
+	/** Get the node directly after the position, if any. */
+	get nodeAfter() {
+		return wrap(this[CORE].nodeAfterOrNull);
+	}
+	/** Get the node directly before the position, if any. */
+	get nodeBefore() {
+		return wrap(this[CORE].nodeBeforeOrNull);
+	}
+	/** Get the position at the given index in the parent node at the given depth. */
+	posAtIndex(index, depth) {
+		return this[CORE].posAtIndex(index, depth);
+	}
+	/** Get the marks at this position. */
+	marks() {
+		return wrapArray(this[CORE].marks());
+	}
+	/** Get the marks after the current position, if any, except those that are non-inclusive and not present at position `$end`. */
+	marksAcross($end) {
+		const marks = this[CORE].marksAcrossOrNull($end[CORE]);
+		return marks && wrapArray(marks);
+	}
+	/** The depth up to which this position and the given (non-resolved) position share the same parent nodes. */
+	sharedDepth(pos) {
+		return this[CORE].sharedDepth(pos);
+	}
+	/** Returns a range based on the place where this position and the given position diverge around block content. */
+	blockRange(other = this, pred) {
+		return wrap(this[CORE].blockRangeOrNull(other[CORE], pred && ((node) => pred(wrap(node)))));
+	}
+	/** Query whether the given position shares the same parent node. */
+	sameParent(other) {
+		return this[CORE].sameParent(other[CORE]);
+	}
+	/** Return the greater of this and the given position. */
+	max(other) {
+		return wrap(this[CORE].max(other[CORE]));
+	}
+	/** Return the smaller of this and the given position. */
+	min(other) {
+		return wrap(this[CORE].min(other[CORE]));
+	}
+	/** @internal */
+	toString() {
+		return this[CORE].toString();
+	}
+	/** @internal */
+	static resolve(doc, pos) {
+		return wrap(guard(() => ResolvedPos$1.resolve(doc[CORE], pos)));
+	}
+	/** @internal */
+	static resolveCached(doc, pos) {
+		return wrap(guard(() => ResolvedPos$1.resolveCached(doc[CORE], pos)));
+	}
+};
+registerWrapper(ResolvedPos$1, (core) => adopt(ResolvedPos.prototype, core));
+/**
+* Represents a flat range of content, i.e. one that starts and ends in
+* the same node.
+*
+* @since 0.1.0
+* @category models
+*/
+var NodeRange = class {
+	/** Construct a node range. */
+	constructor($from, $to, depth) {
+		link(this, new NodeRange$1($from[CORE], $to[CORE], depth));
+	}
+	/** A resolved position along the start of the content. */
+	get $from() {
+		return wrap(this[CORE].$from);
+	}
+	/** A position along the end of the content. */
+	get $to() {
+		return wrap(this[CORE].$to);
+	}
+	/** The depth of the node that this range points into. */
+	get depth() {
+		return this[CORE].depth;
+	}
+	/** The position at the start of the range. */
+	get start() {
+		return this[CORE].start;
+	}
+	/** The position at the end of the range. */
+	get end() {
+		return this[CORE].end;
+	}
+	/** The parent node that the range points into. */
+	get parent() {
+		return wrap(this[CORE].parent);
+	}
+	/** The start index of the range in the parent node. */
+	get startIndex() {
+		return this[CORE].startIndex;
+	}
+	/** The end index of the range in the parent node. */
+	get endIndex() {
+		return this[CORE].endIndex;
+	}
+};
+registerWrapper(NodeRange$1, (core) => adopt(NodeRange.prototype, core));
+/**
+* Instances of this class represent a match state of a node type's
+* content expression.
+*
+* @since 0.1.0
+* @category models
+*/
+var ContentMatch = class {
+	/** @internal */
+	constructor(validEnd) {
+		link(this, new ContentMatch$1(validEnd));
+	}
+	/** True when this match state represents a valid end of the node. */
+	get validEnd() {
+		return this[CORE].validEnd;
+	}
+	/** @internal */
+	get next() {
+		return this[CORE].next.map(wrapEdge);
+	}
+	/** @internal */
+	static parse(string, nodeTypes) {
+		const types = {};
+		for (const name in nodeTypes) types[name] = nodeTypes[name][CORE];
+		return wrap(guard(() => ContentMatch$1.compile(string, types, "")));
+	}
+	/** Match a node type, returning a match after that node if successful. */
+	matchType(type) {
+		return wrap(this[CORE].matchTypeOrNull(type[CORE]));
+	}
+	/** Try to match a fragment. Returns the resulting match when successful. */
+	matchFragment(frag, start = 0, end = frag.childCount) {
+		return wrap(this[CORE].matchFragmentOrNull(frag[CORE], start, end));
+	}
+	/** @internal */
+	get inlineContent() {
+		return this[CORE].inlineContent;
+	}
+	/** Get the first matching node type at this match position that can be generated. */
+	get defaultType() {
+		return wrap(this[CORE].defaultTypeOrNull);
+	}
+	/** @internal */
+	compatible(other) {
+		return this[CORE].compatible(other[CORE]);
+	}
+	/** Try to match the given fragment, and if that fails, see if it can be made to match by inserting nodes in front of it. */
+	fillBefore(after, toEnd = false, startIndex = 0) {
+		return wrap(this[CORE].fillBeforeOrNull(after[CORE], toEnd, startIndex));
+	}
+	/** Find a set of wrapping node types that would allow a node of the given type to appear at this position. */
+	findWrapping(target) {
+		const found = this[CORE].findWrappingOrNull(target[CORE]);
+		return found && wrapArray(found);
+	}
+	/** The number of outgoing edges this node has in the finite automaton that describes the content expression. */
+	get edgeCount() {
+		return this[CORE].edgeCount;
+	}
+	/** Get the _n_th outgoing edge from this node in the finite automaton that describes the content expression. */
+	edge(n) {
+		const edge = this[CORE].next[n];
+		if (!edge) throw new RangeError(`There's no ${n}th edge in this content match`);
+		return wrapEdge(edge);
+	}
+	/** @internal */
+	toString() {
+		return this[CORE].toString();
+	}
+};
+const wrapEdge = (edge) => ({
+	type: wrap(edge.type),
+	next: wrap(edge.next)
+});
+registerWrapper(ContentMatch$1, (core) => adopt(ContentMatch.prototype, core));
+ContentMatch.empty = wrap(ContentMatch$1.empty);
+const translateRule = (rule) => {
+	if (!rule.getContent && !rule.clearMark) return rule;
+	const copy = {
+		...rule,
+		[ORIGINAL]: rule
+	};
+	if (rule.getContent) copy.getContent = (dom, schema) => unwrap(rule.getContent(dom, wrap(schema)));
+	if (rule.clearMark) copy.clearMark = (mark) => rule.clearMark(wrap(mark));
+	return copy;
+};
+const translateNodeSpec = (spec) => {
+	const copy = {
+		...spec,
+		[ORIGINAL]: spec
+	};
+	if (spec.toDOM) copy.toDOM = (node) => spec.toDOM(wrap(node));
+	if (spec.toDebugString) copy.toDebugString = (node) => spec.toDebugString(wrap(node));
+	if (spec.leafText) copy.leafText = (node) => spec.leafText(wrap(node));
+	if (spec.parseDOM) copy.parseDOM = spec.parseDOM.map(translateRule);
+	return copy;
+};
+const translateMarkSpec = (spec) => {
+	const copy = {
+		...spec,
+		[ORIGINAL]: spec
+	};
+	if (spec.toDOM) copy.toDOM = (mark, inline) => spec.toDOM(wrap(mark), inline);
+	if (spec.parseDOM) copy.parseDOM = spec.parseDOM.map(translateRule);
+	return copy;
+};
+const originalSpec = (spec) => spec[ORIGINAL] ?? spec;
+/**
+* Node types are objects allocated once per `Schema` and used to tag
+* `Node` instances.
+*
+* @since 0.1.0
+* @category models
+*/
+var NodeType = class {
+	/** The name the node type has in this schema. */
+	get name() {
+		return this[CORE].name;
+	}
+	/** A link back to the `Schema` the node type belongs to. */
+	get schema() {
+		return wrap(this[CORE].schema);
+	}
+	/** The spec that this type is based on. */
+	get spec() {
+		return originalSpec(this[CORE].spec);
+	}
+	/** @internal */
+	get groups() {
+		return this[CORE].groups;
+	}
+	/** @internal */
+	get attrs() {
+		return this[CORE].attrs;
+	}
+	/** @internal */
+	get defaultAttrs() {
+		return this[CORE].defaultAttrs;
+	}
+	/** True if this is a block type. */
+	get isBlock() {
+		return this[CORE].isBlock;
+	}
+	/** True if this is the text node type. */
+	get isText() {
+		return this[CORE].isText;
+	}
+	/** True if this node type has inline content. */
+	get inlineContent() {
+		return this[CORE].inlineContent;
+	}
+	/** The starting match of the node type's content expression. */
+	get contentMatch() {
+		return wrap(this[CORE].contentMatch);
+	}
+	/** The set of marks allowed in this node. `null` means all marks are allowed. */
+	get markSet() {
+		const set = this[CORE].markSet;
+		return set && wrapArray(set);
+	}
+	/** True if this is an inline type. */
+	get isInline() {
+		return this[CORE].isInline;
+	}
+	/** True if this is a textblock type, a block that contains inline content. */
+	get isTextblock() {
+		return this[CORE].isTextblock;
+	}
+	/** True for node types that allow no content. */
+	get isLeaf() {
+		return this[CORE].isLeaf;
+	}
+	/** True when this node is an atom, i.e. when it does not have directly editable content. */
+	get isAtom() {
+		return this[CORE].isAtom;
+	}
+	/** Return true when this node type is part of the given group. */
+	isInGroup(group) {
+		return this[CORE].isInGroup(group);
+	}
+	/** The node type's whitespace option. */
+	get whitespace() {
+		return this[CORE].whitespace;
+	}
+	/** Tells you whether this node type has any required attributes. */
+	hasRequiredAttrs() {
+		return this[CORE].hasRequiredAttrs();
+	}
+	/** Indicates whether this node allows some of the same content as the given node type. */
+	compatibleContent(other) {
+		return this[CORE].compatibleContent(other[CORE]);
+	}
+	/** @internal */
+	computeAttrs(attrs) {
+		return guard(() => this[CORE].computeAttrs(attrs));
+	}
+	/** Create a `Node` of this type. */
+	create(attrs = null, content, marks) {
+		return wrap(guard(() => this[CORE].createUnsafe(attrs, fragmentInput(content), marksInput(marks))));
+	}
+	/** Like `create`, but check the given content against the node type's content restrictions. */
+	createChecked(attrs = null, content, marks) {
+		return wrap(guard(() => this[CORE].createCheckedUnsafe(attrs, fragmentInput(content), marksInput(marks))));
+	}
+	/** Like `create`, but see if it is necessary to add nodes to the start or end of the given fragment to make it fit the node. */
+	createAndFill(attrs = null, content, marks) {
+		return wrap(guard(() => this[CORE].createAndFillOrNull(attrs, fragmentInput(content), marksInput(marks))));
+	}
+	/** Returns true if the given fragment is valid content for this node type. */
+	validContent(content) {
+		return this[CORE].validContent(content[CORE]);
+	}
+	/** @internal */
+	checkContent(content) {
+		guard(() => this[CORE].checkContent(content[CORE]));
+	}
+	/** @internal */
+	checkAttrs(attrs) {
+		guard(() => this[CORE].checkAttrs(attrs));
+	}
+	/** Check whether the given mark type is allowed in this node. */
+	allowsMarkType(markType) {
+		return this[CORE].allowsMarkType(markType[CORE]);
+	}
+	/** Test whether the given set of marks are allowed in this node. */
+	allowsMarks(marks) {
+		return this[CORE].allowsMarks(unwrapArray(marks));
+	}
+	/** Removes the marks that are not allowed in this node from the given set. */
+	allowedMarks(marks) {
+		return wrapArray(this[CORE].allowedMarks(unwrapArray(marks)));
+	}
+	/** @internal */
+	toString() {
+		return this[CORE].toString();
+	}
+};
+registerWrapper(NodeType$1, (core) => adopt(NodeType.prototype, core));
+/**
+* Like nodes, marks (which are associated with nodes to signify things
+* like emphasis or being part of a link) are tagged with type objects,
+* which are instantiated once per `Schema`.
+*
+* @since 0.1.0
+* @category models
+*/
+var MarkType = class {
+	/** The name of the mark type. */
+	get name() {
+		return this[CORE].name;
+	}
+	/** @internal */
+	get rank() {
+		return this[CORE].rank;
+	}
+	/** The schema that this mark type instance is part of. */
+	get schema() {
+		return wrap(this[CORE].schema);
+	}
+	/** The spec on which the type is based. */
+	get spec() {
+		return originalSpec(this[CORE].spec);
+	}
+	/** @internal */
+	get attrs() {
+		return this[CORE].attrs;
+	}
+	/** @internal */
+	get excluded() {
+		return wrapArray(this[CORE].excluded);
+	}
+	/** @internal */
+	get instance() {
+		return nullable(this[CORE].instance);
+	}
+	/** Create a mark of this type. */
+	create(attrs = null) {
+		return wrap(guard(() => this[CORE].createUnsafe(attrs ?? void 0)));
+	}
+	/** When there is a mark of this type in the given set, a new set without it is returned. */
+	removeFromSet(set) {
+		return wrapArray(this[CORE].removeFromSet(unwrapArray(set)));
+	}
+	/** Tests whether there is a mark of this type in the given set. */
+	isInSet(set) {
+		return wrap(this[CORE].findInSet(unwrapArray(set)));
+	}
+	/** @internal */
+	checkAttrs(attrs) {
+		guard(() => this[CORE].checkAttrs(attrs));
+	}
+	/** Queries whether a given mark type is excluded by this one. */
+	excludes(other) {
+		return this[CORE].excludes(other[CORE]);
+	}
+	/** @internal */
+	toString() {
+		return this[CORE].toString();
+	}
+};
+registerWrapper(MarkType$1, (core) => adopt(MarkType.prototype, core));
+/**
+* A document schema. Holds node and mark type objects for the nodes and
+* marks that may occur in conforming documents, and provides
+* functionality for creating and deserializing such documents.
+*
+* @since 0.1.0
+* @category models
+*/
+var Schema = class {
+	/** Construct a schema from a schema specification. */
+	constructor(spec) {
+		const instanceSpec = {};
+		for (const prop in spec) instanceSpec[prop] = spec[prop];
+		instanceSpec.nodes = OrderedMap.from(spec.nodes);
+		instanceSpec.marks = OrderedMap.from(spec.marks || {});
+		const nodes = {}, marks = {};
+		instanceSpec.nodes.forEach((name, s) => {
+			nodes[name] = translateNodeSpec(s);
+		});
+		instanceSpec.marks.forEach((name, s) => {
+			marks[name] = translateMarkSpec(s);
+		});
+		const core = guard(() => DocSchema.makeUnsafe({
+			nodes,
+			marks,
+			topNode: spec.topNode
+		}));
+		link(this, core);
+		initSchema(this, core, instanceSpec);
+	}
+	/** Create a node in this schema. */
+	node(type, attrs = null, content, marks) {
+		return wrap(guard(() => this[CORE].nodeUnsafe(typeof type === "string" ? type : type[CORE], attrs, fragmentInput(content), marksInput(marks))));
+	}
+	/** Create a text node in the schema. Empty text nodes are not allowed. */
+	text(text, marks) {
+		return wrap(guard(() => this[CORE].textUnsafe(text, marksInput(marks))));
+	}
+	/** Create a mark with the given type and attributes. */
+	mark(type, attrs) {
+		return wrap(guard(() => this[CORE].markUnsafe(typeof type === "string" ? type : type[CORE], attrs ?? void 0)));
+	}
+	/** Deserialize a node from its JSON representation. */
+	nodeFromJSON(json) {
+		return wrap(guard(() => this[CORE].nodeFromJSONUnsafe(json)));
+	}
+	/** Deserialize a mark from its JSON representation. */
+	markFromJSON(json) {
+		return wrap(guard(() => this[CORE].markFromJSONUnsafe(json)));
+	}
+	/** @internal */
+	nodeType(name) {
+		return wrap(guard(() => this[CORE].nodeType(name)));
+	}
+};
+function initSchema(schema, core, spec) {
+	const nodes = Object.create(null);
+	for (const name in core.nodes) nodes[name] = wrap(core.nodes[name]);
+	const marks = Object.create(null);
+	for (const name in core.marks) marks[name] = wrap(core.marks[name]);
+	schema.spec = spec;
+	schema.nodes = nodes;
+	schema.marks = marks;
+	schema.linebreakReplacement = nullable(core.linebreakReplacement);
+	schema.topNodeType = wrap(core.topNodeType);
+	schema.cached = Object.create(null);
+	schema.nodeFromJSON = schema.nodeFromJSON.bind(schema);
+	schema.markFromJSON = schema.markFromJSON.bind(schema);
+}
+registerWrapper(DocSchema, (core) => {
+	const schema = adopt(Schema.prototype, core);
+	const nodes = {}, marks = {};
+	for (const name in core.spec.nodes) nodes[name] = originalSpec(core.spec.nodes[name]);
+	for (const name in core.spec.marks) marks[name] = originalSpec(core.spec.marks[name]);
+	initSchema(schema, core, {
+		...core.spec,
+		nodes: OrderedMap.from(nodes),
+		marks: OrderedMap.from(marks)
+	});
+	return schema;
+});
+/** @internal */
+const parseOptions = (options) => {
+	if (!options) return {};
+	const result = { ...options };
+	if (options.topNode) result.topNode = options.topNode[CORE];
+	if (options.topMatch) result.topMatch = options.topMatch[CORE];
+	if (options.context) result.context = options.context[CORE];
+	if (options.ruleFromNode) {
+		const f = options.ruleFromNode;
+		result.ruleFromNode = (node) => {
+			const rule = f(node);
+			return rule && translateRule(rule);
+		};
+	}
+	return result;
+};
+/**
+* A DOM parser represents a strategy for parsing DOM content into a
+* ProseMirror document conforming to a given schema.
+*
+* @since 0.1.0
+* @category models
+*/
+var DOMParser = class {
+	/** Create a parser that targets the given schema, using the given parsing rules. */
+	constructor(schema, rules) {
+		this._rules = rules;
+		link(this, guard(() => new DOMParser$1(schema[CORE], rules.map(translateRule))));
+	}
+	/** The schema into which the parser parses. */
+	get schema() {
+		return wrap(this[CORE].schema);
+	}
+	/** The set of parse rules that the parser uses, in order of precedence. */
+	get rules() {
+		return this._rules ?? this[CORE].rules.map(originalSpec);
+	}
+	/** @internal */
+	get tags() {
+		return this[CORE].tags.map(originalSpec);
+	}
+	/** @internal */
+	get styles() {
+		return this[CORE].styles.map(originalSpec);
+	}
+	/** Parse a document from the content of a DOM node. */
+	parse(dom, options) {
+		return wrap(guard(() => this[CORE].parseUnsafe(dom, parseOptions(options))));
+	}
+	/** Parses the content of the given DOM node, like `parse`, and returns a slice open at the sides. */
+	parseSlice(dom, options) {
+		return wrap(guard(() => this[CORE].parseSliceUnsafe(dom, parseOptions(options))));
+	}
+	/** @internal */
+	matchTag(dom, context, after) {
+		return Option.getOrNull(this[CORE].matchTag(dom, context, after));
+	}
+	/** @internal */
+	matchStyle(prop, value, context, after) {
+		return Option.getOrNull(this[CORE].matchStyle(prop, value, context, after));
+	}
+	/** @internal */
+	static schemaRules(schema) {
+		return DOMParser$1.schemaRules(schema[CORE]).map((rule) => {
+			const original = rule[ORIGINAL];
+			if (!original) return rule;
+			const result = Object.assign({}, original);
+			if (rule.node !== void 0) result.node = rule.node;
+			if (rule.mark !== void 0) result.mark = rule.mark;
+			return result;
+		});
+	}
+	/** Construct a DOM parser using the parsing rules listed in a schema's node specs, reordered by priority. */
+	static fromSchema(schema) {
+		return wrap(DOMParser$1.fromSchema(schema[CORE]));
+	}
+};
+registerWrapper(DOMParser$1, (core) => adopt(DOMParser.prototype, core));
+/**
+* A DOM serializer knows how to convert ProseMirror nodes and marks of
+* various types to DOM nodes.
+*
+* @since 0.1.0
+* @category models
+*/
+var DOMSerializer = class DOMSerializer {
+	/** Create a serializer. */
+	constructor(nodes, marks) {
+		this.nodes = nodes;
+		this.marks = marks;
+		const coreNodes = {};
+		for (const name in nodes) {
+			const f = nodes[name];
+			if (f) coreNodes[name] = (node) => f(wrap(node));
+		}
+		const coreMarks = {};
+		for (const name in marks) {
+			const f = marks[name];
+			coreMarks[name] = f ? (mark, inline) => f(wrap(mark), inline) : f;
+		}
+		link(this, new DOMSerializer$1(coreNodes, coreMarks));
+	}
+	/** Serialize the content of this fragment to a DOM fragment. */
+	serializeFragment(fragment, options = {}, target) {
+		return guard(() => this[CORE].serializeFragment(fragment[CORE], options, target));
+	}
+	/** Serialize this node to a DOM node. */
+	serializeNode(node, options = {}) {
+		return guard(() => this[CORE].serializeNode(node[CORE], options));
+	}
+	/** @internal */
+	serializeMark(mark, inline, options = {}) {
+		return guard(() => this[CORE].serializeMarkOrNull(mark[CORE], inline, options));
+	}
+	/** Render an output spec to a DOM node. */
+	static renderSpec(doc, structure, xmlNS = null, blockArraysIn) {
+		return guard(() => DOMSerializer$1.renderSpecUnsafe(doc, structure, xmlNS, blockArraysIn));
+	}
+	/** Build a serializer using the `toDOM` properties in a schema's node and mark specs. */
+	static fromSchema(schema) {
+		return schema.cached.domSerializer || (schema.cached.domSerializer = new DOMSerializer(this.nodesFromSchema(schema), this.marksFromSchema(schema)));
+	}
+	/** Gather the serializers in a schema's node specs into an object. */
+	static nodesFromSchema(schema) {
+		const result = gatherToDOM(schema.nodes);
+		if (!result.text) result.text = (node) => node.text;
+		return result;
+	}
+	/** Gather the serializers in a schema's mark specs into an object. */
+	static marksFromSchema(schema) {
+		return gatherToDOM(schema.marks);
+	}
+};
+function gatherToDOM(obj) {
+	const result = {};
+	for (const name in obj) {
+		const toDOM = obj[name].spec.toDOM;
+		if (toDOM) result[name] = toDOM;
+	}
+	return result;
+}
+registerWrapper(DOMSerializer$1, (core) => {
+	const serializer = adopt(DOMSerializer.prototype, core);
+	const nodes = {};
+	for (const name in core.nodes) nodes[name] = (node) => core.nodes[name](node[CORE]);
+	const marks = {};
+	for (const name in core.marks) {
+		const f = core.marks[name];
+		if (f) marks[name] = (mark, inline) => f(mark[CORE], inline);
+	}
+	serializer.nodes = nodes;
+	serializer.marks = marks;
+	return serializer;
+});
+function toCore(value) {
+	return Array.isArray(value) ? unwrapArray(value) : unwrap(value);
+}
+function fromCore(value) {
+	return Array.isArray(value) ? wrapArray(value) : wrap(value);
+}
+export { ContentMatch, DOMParser, DOMSerializer, Fragment, Mark, MarkType, Node, NodeRange, NodeType, OrderedMap, ReplaceError, ResolvedPos, Schema, Slice, TextNode, fragmentInput, fromCore, parseOptions, toCore };