@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/model/json.js

@@ -0,0 +1,126 @@
+import { decodeAttrs } from "./attrsCodec.js";
+import { JSONError, isModelError } from "./errors.js";
+import { Fragment } from "./fragment.js";
+import { Mark } from "./mark.js";
+import { Node } from "./node.js";
+import { Slice } from "./replace.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/model/json.ts
+/**
+* JSON (de)serialization of documents, including Effect `Schema` codecs
+* derived from a document schema.
+*
+* @since 0.1.0
+*/
+const fail = (message) => {
+	throw new JSONError({ message });
+};
+const decodeAttrsOrFail = (defs, attrs, kind, name) => {
+	if (attrs == null) return Option.none();
+	if (typeof attrs !== "object" || Array.isArray(attrs)) return fail(`Invalid attributes for ${kind} ${name}`);
+	try {
+		return Option.some(decodeAttrs(defs, attrs));
+	} catch (e) {
+		if (isModelError(e)) throw e;
+		return fail(`Invalid attributes for ${kind} ${name}: ${Predicate.hasProperty(e, "message") ? String(e.message) : String(e)}`);
+	}
+};
+/** @internal */
+function markFromJSON(schema, json) {
+	if (!json || typeof json !== "object") fail("Invalid input for Mark.fromJSON");
+	const type = schema.marks[json.type];
+	if (!type) return fail(`There is no mark type ${json.type} in this schema`);
+	return type.createDecodedUnsafe(decodeAttrsOrFail(type.attrs, json.attrs, "mark", json.type));
+}
+/** @internal */
+function nodeFromJSON(schema, json) {
+	if (!json || typeof json !== "object") fail("Invalid input for Node.fromJSON");
+	if (json.marks && !Array.isArray(json.marks)) fail("Invalid mark data for Node.fromJSON");
+	const marks = json.marks ? json.marks.map((m) => markFromJSON(schema, m)) : Mark.none;
+	if (json.type === "text") {
+		if (typeof json.text !== "string") fail("Invalid text node in JSON");
+		if (!json.text) fail("Empty text nodes are not allowed");
+		return schema.textUnsafe(json.text, marks);
+	}
+	const content = fragmentFromJSON(schema, json.content);
+	const type = schema.nodes[json.type];
+	if (!type) return fail("Unknown node type: " + json.type);
+	return type.createDecodedUnsafe(decodeAttrsOrFail(type.attrs, json.attrs, "node", json.type), content, marks);
+}
+/** @internal */
+function fragmentFromJSON(schema, value) {
+	if (!value) return Fragment.empty;
+	if (!Array.isArray(value)) fail("Invalid input for Fragment.fromJSON");
+	return Fragment.fromArray(value.map((n) => nodeFromJSON(schema, n)));
+}
+/** @internal */
+function sliceFromJSON(schema, value) {
+	return Slice.fromJSONUnsafe(schema, value);
+}
+const NodeJSONSchema = S.suspend(() => S.Struct({
+	type: S.String,
+	attrs: S.optionalKey(S.Record(S.String, S.Unknown)),
+	content: S.optionalKey(S.Array(NodeJSONSchema)),
+	marks: S.optionalKey(S.Array(S.Struct({
+		type: S.String,
+		attrs: S.optionalKey(S.Record(S.String, S.Unknown))
+	}))),
+	text: S.optionalKey(S.String)
+}));
+const wrap = (f) => Effect.suspend(() => {
+	try {
+		return Effect.succeed(f());
+	} catch (e) {
+		return Effect.fail(new SchemaIssue.InvalidValue({ message: Predicate.hasProperty(e, "message") ? String(e.message) : String(e) }));
+	}
+});
+/**
+* An Effect `Schema` that decodes the JSON representation of a node
+* into a `Node` of the given document schema (validating structure,
+* content, and attributes), and encodes nodes back to JSON.
+*
+* ```ts skip-type-checking
+* import { Schema } from "effect"
+* const doc = yield* Schema.decodeUnknownEffect(NodeFromJSON(mySchema))(json)
+* ```
+*
+* @since 0.1.0
+* @category schemas
+*/
+const NodeFromJSON = (schema) => {
+	const target = S.declare((u) => u instanceof Node && u.type.schema === schema, { title: "Node" });
+	return NodeJSONSchema.pipe(S.decodeTo(target, {
+		decode: SchemaGetter.transformEffect((json) => wrap(() => {
+			const node = nodeFromJSON(schema, json);
+			node.checkUnsafe();
+			return node;
+		})),
+		encode: SchemaGetter.transform((node) => node.toJSON())
+	}));
+};
+/**
+* An Effect `Schema` for the top-level document of a schema: like
+* `NodeFromJSON`, but also requires the decoded node to be of the
+* schema's top node type.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const DocFromJSON = (schema) => {
+	const target = S.declare((u) => u instanceof Node && u.type === schema.topNodeType, { title: "Document" });
+	return NodeJSONSchema.pipe(S.decodeTo(target, {
+		decode: SchemaGetter.transformEffect((json) => wrap(() => {
+			const node = nodeFromJSON(schema, json);
+			if (node.type !== schema.topNodeType) fail(`Expected a ${schema.topNodeType.name} node, got ${node.type.name}`);
+			node.checkUnsafe();
+			return node;
+		})),
+		encode: SchemaGetter.transform((node) => node.toJSON())
+	}));
+};
+export { DocFromJSON, NodeFromJSON, fragmentFromJSON, markFromJSON, nodeFromJSON, sliceFromJSON };

package/dist/model/mark.d.ts

@@ -0,0 +1,73 @@
+import { AnySchema, MarkAttrs, MarkNames, MarkType } from "./schema.js";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+/**
+ * A mark is a piece of information that can be attached to a node,
+ * such as it being emphasized, in code font, or a link. It has a type
+ * and optionally a set of attributes that provide further information
+ * (such as the target of the link). Marks are created through a
+ * schema, which controls which types exist and which attributes they
+ * have.
+ *
+ * Marks implement `Equal`, comparing type and attributes.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Mark<Sc extends AnySchema = AnySchema, out M extends MarkNames<Sc> = MarkNames<Sc>> implements Equal.Equal {
+  /** The type of this mark. */
+  readonly type: MarkType<Sc, M>;
+  /** The attributes associated with this mark. */
+  readonly attrs: MarkAttrs<Sc, M>;
+  /** @internal */
+  constructor(
+  /** The type of this mark. */
+  type: MarkType<Sc, M>,
+  /** The attributes associated with this mark. */
+  attrs: MarkAttrs<Sc, M>);
+  /** Narrow this mark to a specific mark type. */
+  is<K extends MarkNames<Sc>>(name: K): this is Mark<Sc, K>;
+  /**
+   * Given a set of marks, create a new set which contains this one as
+   * well, in the right position. If this mark is already in the set,
+   * the set itself is returned. If any marks that are set to be
+   * exclusive with this mark are present, those are replaced by this
+   * one.
+   */
+  addToSet<Mk extends Mark<any, any>>(set: ReadonlyArray<Mk>): ReadonlyArray<Mk | this>;
+  /**
+   * Remove this mark from the given set, returning a new set. If this
+   * mark is not in the set, the set itself is returned.
+   */
+  removeFromSet<Mk extends Mark<any, any>>(set: ReadonlyArray<Mk>): ReadonlyArray<Mk>;
+  /** Test whether this mark is in the given set of marks. */
+  isInSet(set: ReadonlyArray<Mark<any, any>>): boolean;
+  /** Test whether this mark has the same type and attributes as another mark. */
+  eq(other: Mark<any, any>): boolean;
+  /** @internal */
+  [Equal.symbol](that: Equal.Equal): boolean;
+  /** @internal */
+  [Hash.symbol](): number;
+  /** Convert this mark to a JSON-serializable representation. */
+  toJSON(): MarkJSON;
+  /** @internal */
+  toString(): string;
+  /** Test whether two sets of marks are identical. */
+  static sameSet(a: ReadonlyArray<Mark<any, any>>, b: ReadonlyArray<Mark<any, any>>): boolean;
+  /** Create a properly sorted mark set from nothing, a single mark, or an unsorted array of marks. */
+  static setFrom<Mk extends Mark<any, any>>(marks?: Mk | ReadonlyArray<Mk> | null): ReadonlyArray<Mk>;
+  /** The empty set of marks. */
+  static readonly none: ReadonlyArray<Mark<any, any>>;
+}
+/**
+ * The JSON representation of a mark.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface MarkJSON {
+  readonly type: string;
+  readonly attrs?: {
+    readonly [name: string]: unknown;
+  };
+}

package/dist/model/mark.js

@@ -0,0 +1,121 @@
+import { encodeAttrs } from "./attrsCodec.js";
+import { compareDeep } from "./comparedeep.js";
+import * as Arr from "effect/Array";
+import * as Order from "effect/Order";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+// src/model/mark.ts
+/**
+* Marks.
+*
+* @since 0.1.0
+*/
+const byRank = (a, b) => Order.Number(a.type.rank, b.type.rank);
+/**
+* A mark is a piece of information that can be attached to a node,
+* such as it being emphasized, in code font, or a link. It has a type
+* and optionally a set of attributes that provide further information
+* (such as the target of the link). Marks are created through a
+* schema, which controls which types exist and which attributes they
+* have.
+*
+* Marks implement `Equal`, comparing type and attributes.
+*
+* @since 0.1.0
+* @category models
+*/
+var Mark = class Mark {
+	/** @internal */
+	constructor(type, attrs) {
+		this.type = type;
+		this.attrs = attrs;
+	}
+	/** Narrow this mark to a specific mark type. */
+	is(name) {
+		return this.type.name === name;
+	}
+	/**
+	* Given a set of marks, create a new set which contains this one as
+	* well, in the right position. If this mark is already in the set,
+	* the set itself is returned. If any marks that are set to be
+	* exclusive with this mark are present, those are replaced by this
+	* one.
+	*/
+	addToSet(set) {
+		let copy;
+		let placed = false;
+		for (let i = 0; i < set.length; i++) {
+			const other = set[i];
+			if (this.eq(other)) return set;
+			if (this.type.excludes(other.type)) {
+				if (!copy) copy = set.slice(0, i);
+			} else if (other.type.excludes(this.type)) return set;
+			else {
+				if (!placed && other.type.rank > this.type.rank) {
+					if (!copy) copy = set.slice(0, i);
+					copy.push(this);
+					placed = true;
+				}
+				if (copy) copy.push(other);
+			}
+		}
+		if (!copy) copy = set.slice();
+		if (!placed) copy.push(this);
+		return copy;
+	}
+	/**
+	* Remove this mark from the given set, returning a new set. If this
+	* mark is not in the set, the set itself is returned.
+	*/
+	removeFromSet(set) {
+		for (let i = 0; i < set.length; i++) if (this.eq(set[i])) return set.slice(0, i).concat(set.slice(i + 1));
+		return set;
+	}
+	/** Test whether this mark is in the given set of marks. */
+	isInSet(set) {
+		for (let i = 0; i < set.length; i++) if (this.eq(set[i])) return true;
+		return false;
+	}
+	/** Test whether this mark has the same type and attributes as another mark. */
+	eq(other) {
+		return this === other || this.type === other.type && compareDeep(this.attrs, other.attrs);
+	}
+	/** @internal */
+	[Equal.symbol](that) {
+		return that instanceof Mark && this.eq(that);
+	}
+	/** @internal */
+	[Hash.symbol]() {
+		return Hash.combine(Hash.string(this.type.name))(Hash.structure(this.attrs));
+	}
+	/** Convert this mark to a JSON-serializable representation. */
+	toJSON() {
+		const obj = { type: this.type.name };
+		for (const _ in this.attrs) {
+			obj.attrs = this.type.identityAttrs ? this.attrs : encodeAttrs(this.type.attrs, this.attrs);
+			break;
+		}
+		return obj;
+	}
+	/** @internal */
+	toString() {
+		return this.type.name;
+	}
+	/** Test whether two sets of marks are identical. */
+	static sameSet(a, b) {
+		if (a === b) return true;
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!a[i].eq(b[i])) return false;
+		return true;
+	}
+	/** Create a properly sorted mark set from nothing, a single mark, or an unsorted array of marks. */
+	static setFrom(marks) {
+		if (!marks || Array.isArray(marks) && Arr.isReadonlyArrayEmpty(marks)) return Mark.none;
+		if (marks instanceof Mark) return [marks];
+		return Arr.sort(marks, byRank);
+	}
+	static {
+		this.none = [];
+	}
+};
+export { Mark };

package/dist/model/node.d.ts

@@ -0,0 +1,267 @@
+import { ContentMatch } from "./content.js";
+import { AttributeError, ContentError, PositionError, ReplaceError } from "./errors.js";
+import { Fragment, NodeVisitor } from "./fragment.js";
+import { Mark, MarkJSON } from "./mark.js";
+import { Slice } from "./replace.js";
+import { ResolvedPos } from "./resolvedpos.js";
+import { AnySchema, Attrs, ChildNames, MarkType, NodeAttrs, NodeNames, NodeType } from "./schema.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+/**
+ * The JSON representation of a node.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface NodeJSON {
+  readonly type: string;
+  readonly attrs?: {
+    readonly [name: string]: unknown;
+  };
+  readonly content?: ReadonlyArray<NodeJSON>;
+  readonly marks?: ReadonlyArray<MarkJSON>;
+  readonly text?: string;
+}
+/**
+ * The result of `childAfter` / `childBefore`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ChildInfo<Sc extends AnySchema, N extends NodeNames<Sc>> {
+  readonly node: Option.Option<Node<Sc, N>>;
+  readonly index: number;
+  readonly offset: number;
+}
+/**
+ * This class represents a node in the tree that makes up a document.
+ * So a document is an instance of `Node`, with children that are also
+ * instances of `Node`.
+ *
+ * Nodes are persistent data structures. Instead of changing them, you
+ * create new ones with the content you want. Old ones keep pointing at
+ * the old document shape. This is made cheaper by sharing structure
+ * between the old and new data as much as possible.
+ *
+ * The type parameters track the schema and the node type name (or
+ * union of names), which determines the type of `attrs` and of the
+ * node's children. Use `is` to narrow a node to a specific type.
+ *
+ * Nodes implement `Equal`, comparing structurally.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Node<Sc extends AnySchema = AnySchema, out N extends NodeNames<Sc> = NodeNames<Sc>> implements Equal.Equal {
+  /** The type of node that this is. */
+  readonly type: NodeType<Sc, N>;
+  /**
+   * An object mapping attribute names to values. The kind of
+   * attributes allowed and required are determined by the node type.
+   */
+  readonly attrs: NodeAttrs<Sc, N>;
+  /** The marks applied to this node. */
+  readonly marks: ReadonlyArray<Mark<Sc>>;
+  /** A container holding the node's children. */
+  readonly content: Fragment<Sc, ChildNames<Sc, N>>;
+  /** @internal */
+  constructor(
+  /** The type of node that this is. */
+  type: NodeType<Sc, N>,
+  /**
+   * An object mapping attribute names to values. The kind of
+   * attributes allowed and required are determined by the node type.
+   */
+  attrs: NodeAttrs<Sc, N>, content?: Fragment<Sc, ChildNames<Sc, N>> | null,
+  /** The marks applied to this node. */
+  marks?: ReadonlyArray<Mark<Sc>>);
+  /** Narrow this node to the given node type(s). */
+  is<K extends NodeNames<Sc>>(...names: ReadonlyArray<K>): this is Node<Sc, K>;
+  /** Narrow this node to a text node. */
+  isTextNode(): this is TextNode<Sc>;
+  /** The array of this node's child nodes. */
+  get children(): ReadonlyArray<Node<Sc, ChildNames<Sc, N>>>;
+  /**
+   * The size of this node, as defined by the integer-based indexing
+   * scheme. For text nodes, this is the amount of characters. For other
+   * leaf nodes, it is one. For non-leaf nodes, it is the size of the
+   * content plus two (the start and end token).
+   */
+  get nodeSize(): number;
+  /** The number of children that the node has. */
+  get childCount(): number;
+  /** Get the child node at the given index. Fails when the index is out of range. */
+  child(index: number): Effect.Effect<Node<Sc, ChildNames<Sc, N>>, PositionError>;
+  /** Like `child`, but throws a `PositionError` when the index is out of range. */
+  childUnsafe(index: number): Node<Sc, ChildNames<Sc, N>>;
+  /** Get the child node at the given index, if it exists. */
+  maybeChild(index: number): Option.Option<Node<Sc, ChildNames<Sc, N>>>;
+  /** Call `f` for every child node, passing the node, its offset into this parent node, and its index. */
+  forEach(f: (node: Node<Sc, ChildNames<Sc, N>>, offset: number, index: number) => void): void;
+  /**
+   * Invoke a callback for all descendant nodes recursively overlapping
+   * the given two positions that are relative to start of this node's
+   * content. This includes all ancestors of the nodes containing the
+   * two positions. The callback is invoked with the node, its position
+   * relative to the original node (method receiver), its parent node,
+   * and its child index. When the callback returns false for a given
+   * node, that node's children will not be recursed over. The last
+   * parameter can be used to specify a starting position to count
+   * from.
+   */
+  nodesBetween(from: number, to: number, f: NodeVisitor<Sc>, startPos?: number): void;
+  /** Call the given callback for every descendant node. Doesn't descend into a node when the callback returns `false`. */
+  descendants(f: NodeVisitor<Sc>): void;
+  /** Concatenates all the text nodes found in this node and its children. */
+  get textContent(): string;
+  /**
+   * Get all text between positions `from` and `to`. When
+   * `blockSeparator` is given, it will be inserted to separate text from
+   * different block nodes. If `leafText` is given, it'll be inserted for
+   * every non-text leaf node encountered, otherwise the spec's
+   * `leafText` will be used.
+   */
+  textBetween(from: number, to: number, blockSeparator?: string | null, leafText?: null | string | ((leafNode: Node<Sc>) => string)): string;
+  /** Returns this node's first child, if any. */
+  get firstChild(): Option.Option<Node<Sc, ChildNames<Sc, N>>>;
+  /** Returns this node's last child, if any. */
+  get lastChild(): Option.Option<Node<Sc, ChildNames<Sc, N>>>;
+  /** Test whether two nodes represent the same piece of document. */
+  eq(other: Node<any, any>): boolean;
+  /** @internal */
+  [Equal.symbol](that: Equal.Equal): boolean;
+  /** @internal */
+  [Hash.symbol](): number;
+  /** Compare the markup (type, attributes, and marks) of this node to those of another. */
+  sameMarkup(other: Node<any, any>): boolean;
+  /** Check whether this node's markup correspond to the given type, attributes, and marks. */
+  hasMarkup(type: NodeType<any, any>, attrs?: Attrs | null, marks?: ReadonlyArray<Mark<any, any>>): boolean;
+  /** Create a new node with the same markup as this node, containing the given content (or empty, if no content is given). */
+  copy(content?: Fragment<Sc, ChildNames<Sc, N>> | null): Node<Sc, N>;
+  /** Create a copy of this node, with the given set of marks instead of the node's own marks. */
+  mark(marks: ReadonlyArray<Mark<Sc>>): Node<Sc, N>;
+  /**
+   * Create a copy of this node with only the content between the given
+   * positions. If `to` is not given, it defaults to the end of the node.
+   */
+  cut(from: number, to?: number): Node<Sc, N>;
+  /** Cut out the part of the document between the given positions, and return it as a `Slice`. */
+  slice(from: number, to?: number, includeParents?: boolean): Effect.Effect<Slice<Sc>, PositionError>;
+  /** Like `slice`, but throws a `PositionError` for invalid positions. */
+  sliceUnsafe(from: number, to?: number, includeParents?: boolean): Slice<Sc>;
+  /**
+   * Replace the part of the document between the given positions with
+   * the given slice. The slice must 'fit', meaning its open sides must
+   * be able to connect to the surrounding content, and its content
+   * nodes must be valid children for the node they are placed into. If
+   * any of this is violated, the effect fails with a `ReplaceError`.
+   */
+  replace(from: number, to: number, slice: Slice<Sc>): Effect.Effect<Node<Sc, N>, ReplaceError | PositionError | ContentError>;
+  /** Like `replace`, but throws on failure. */
+  replaceUnsafe(from: number, to: number, slice: Slice<Sc>): Node<Sc, N>;
+  /** Find the node directly after the given position, if any. */
+  nodeAt(pos: number): Option.Option<Node<Sc>>;
+  /** @internal */
+  nodeAtOrNull(pos: number): Node<Sc> | null;
+  /**
+   * Find the (direct) child node after the given offset, if any, and
+   * return it along with its index and offset relative to this node.
+   */
+  childAfter(pos: number): ChildInfo<Sc, ChildNames<Sc, N>>;
+  /**
+   * Find the (direct) child node before the given offset, if any, and
+   * return it along with its index and offset relative to this node.
+   */
+  childBefore(pos: number): ChildInfo<Sc, ChildNames<Sc, N>>;
+  /**
+   * Resolve the given position in the document, returning an object
+   * with information about its context.
+   */
+  resolve(pos: number): Effect.Effect<ResolvedPos<Sc>, PositionError>;
+  /** Like `resolve`, but throws a `PositionError` for out-of-range positions. */
+  resolveUnsafe(pos: number): ResolvedPos<Sc>;
+  /** @internal */
+  resolveNoCache(pos: number): ResolvedPos<Sc>;
+  /** Test whether a given mark or mark type occurs in this document between the two given positions. */
+  rangeHasMark(from: number, to: number, type: Mark<any, any> | MarkType<any, any>): boolean;
+  /** True when this is a block (non-inline node) */
+  get isBlock(): boolean;
+  /** True when this is a textblock node, a block node with inline content. */
+  get isTextblock(): boolean;
+  /** True when this node allows inline content. */
+  get inlineContent(): boolean;
+  /** True when this is an inline node (a text node or a node that can appear among text). */
+  get isInline(): boolean;
+  /** True when this is a text node. */
+  get isText(): boolean;
+  /** True when this is a leaf node. */
+  get isLeaf(): boolean;
+  /**
+   * True when this is an atom, i.e. when it does not have directly
+   * editable content. This is usually the same as `isLeaf`, but can be
+   * configured with the `atom` property on a node's spec.
+   */
+  get isAtom(): boolean;
+  /** Return a string representation of this node for debugging purposes. */
+  toString(): string;
+  /** Get the content match in this node at the given index. */
+  contentMatchAt(index: number): Effect.Effect<ContentMatch, ContentError>;
+  /** Like `contentMatchAt`, but throws when the node's content is invalid. */
+  contentMatchAtUnsafe(index: number): ContentMatch;
+  /**
+   * Test whether replacing the range between `from` and `to` (by child
+   * index) with the given replacement fragment (which defaults to the
+   * empty fragment) would leave the node's content valid. You can
+   * optionally pass `start` and `end` indices into the replacement
+   * fragment.
+   */
+  canReplace(from: number, to: number, replacement?: Fragment<any, any>, start?: number, end?: number): boolean;
+  /**
+   * Test whether replacing the range `from` to `to` (by index) with a
+   * node of the given type would leave the node's content valid.
+   */
+  canReplaceWith(from: number, to: number, type: NodeType<any, any>, marks?: ReadonlyArray<Mark<any, any>>): boolean;
+  /**
+   * Test whether the given node's content could be appended to this
+   * node. If that node is empty, this will only return true if there is
+   * at least one node type that can appear in both nodes (to avoid
+   * merging completely incompatible nodes).
+   */
+  canAppend(other: Node<any, any>): boolean;
+  /**
+   * Check whether this node and its descendants conform to the schema
+   * (including attribute schemas), failing with a `ContentError` or
+   * `AttributeError` when they do not.
+   */
+  check(): Effect.Effect<void, ContentError | AttributeError>;
+  /** Like `check`, but throws on failure. */
+  checkUnsafe(): void;
+  /** Return a JSON-serializable representation of this node. */
+  toJSON(): NodeJSON;
+}
+/**
+ * A text node. Text nodes are always leaves and carry their text in
+ * `text`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class TextNode<Sc extends AnySchema = AnySchema> extends Node<Sc, "text" & NodeNames<Sc>> {
+  /** The text content of this node. */
+  readonly text: string;
+  /** @internal */
+  constructor(type: NodeType<Sc, any>, attrs: Attrs, content: string, marks?: ReadonlyArray<Mark<Sc>>);
+  toString(): string;
+  get textContent(): string;
+  textBetween(from: number, to: number): string;
+  get nodeSize(): number;
+  mark(marks: ReadonlyArray<Mark<Sc>>): TextNode<Sc>;
+  /** Create a copy of this text node with different text. */
+  withText(text: string): TextNode<Sc>;
+  cut(from?: number, to?: number): TextNode<Sc>;
+  eq(other: Node<any, any>): boolean;
+  [Hash.symbol](): number;
+  toJSON(): NodeJSON;
+}