@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/compat/model.d.ts

@@ -0,0 +1,893 @@
+import { NodeRange as NodeRange$1, ResolvedPos as ResolvedPos$1 } from "../model/resolvedpos.js";
+import { Slice as Slice$1 } from "../model/replace.js";
+import { DOMParser as DOMParser$1, ParseOptions as ParseOptions$1 } from "../model/from_dom.js";
+import { DOMOutputSpec as DOMOutputSpec$1, DOMSerializer as DOMSerializer$1 } from "../model/to_dom.js";
+import { DocSchema, MarkType as MarkType$1, NodeType as NodeType$1 } from "../model/schema.js";
+import { Mark as Mark$1 } from "../model/mark.js";
+import { Node as Node$1, TextNode as TextNode$1 } from "../model/node.js";
+import { Fragment as Fragment$1 } from "../model/fragment.js";
+import { ContentMatch as ContentMatch$1 } from "../model/content.js";
+import "../model.js";
+import { CORE, ReplaceError } from "./internal/core.js";
+import { OrderedMap } from "./orderedmap.js";
+/**
+ * An object holding the attributes of a node or mark.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Attrs = {
+  readonly [attr: string]: any;
+};
+/**
+ * A DOM output spec (see `prosemirror-model`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type DOMOutputSpec = DOMOutputSpec$1;
+/** @internal */
+export declare const fragmentInput: (content: unknown) => any;
+/**
+ * This class represents a node in the tree that makes up a ProseMirror
+ * document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Node {
+  /** @internal */
+  readonly [CORE]: Node$1;
+  /** @internal */
+  constructor(type: NodeType, attrs: Attrs, content?: Fragment | null, marks?: ReadonlyArray<Mark>);
+  /** The type of node that this is. */
+  get type(): NodeType;
+  /** An object mapping attribute names to values. */
+  get attrs(): Attrs;
+  /** A container holding the node's children. */
+  get content(): Fragment;
+  /** The marks (things like whether it is emphasized or part of a link) applied to this node. */
+  get marks(): ReadonlyArray<Mark>;
+  /** For text nodes, this contains the node's text content. */
+  get text(): string | undefined;
+  /** The array of this node's child nodes. */
+  get children(): ReadonlyArray<Node>;
+  /** The size of this node, as defined by the integer-based indexing scheme. */
+  get nodeSize(): number;
+  /** The number of children that the node has. */
+  get childCount(): number;
+  /** Get the child node at the given index. Raises an error when the index is out of range. */
+  child(index: number): Node;
+  /** Get the child node at the given index, if it exists. */
+  maybeChild(index: number): Node | null;
+  /** Call `f` for every child node. */
+  forEach(f: (node: Node, offset: number, index: number) => void): void;
+  /** Invoke a callback for all descendant nodes recursively overlapping the given two positions. */
+  nodesBetween(from: number, to: number, f: (node: Node, pos: number, parent: Node | null, index: number) => boolean | void, startPos?: number): void;
+  /** Call the given callback for every descendant node. */
+  descendants(f: (node: Node, pos: number, parent: Node | null, index: number) => boolean | void): void;
+  /** Concatenates all the text nodes found in this fragment and its children. */
+  get textContent(): string;
+  /** Get all text between positions `from` and `to`. */
+  textBetween(from: number, to: number, blockSeparator?: string | null, leafText?: null | string | ((leafNode: Node) => string)): string;
+  /** Returns this node's first child, or `null` if there are no children. */
+  get firstChild(): Node | null;
+  /** Returns this node's last child, or `null` if there are no children. */
+  get lastChild(): Node | null;
+  /** Test whether two nodes represent the same piece of document. */
+  eq(other: Node): boolean;
+  /** Compare the markup (type, attributes, and marks) of this node to those of another. */
+  sameMarkup(other: Node): boolean;
+  /** Check whether this node's markup correspond to the given type, attributes, and marks. */
+  hasMarkup(type: NodeType, attrs?: Attrs | null, marks?: ReadonlyArray<Mark>): boolean;
+  /** Create a new node with the same markup as this node, containing the given content. */
+  copy(content?: Fragment | null): Node;
+  /** Create a copy of this node, with the given set of marks instead of the node's own marks. */
+  mark(marks: ReadonlyArray<Mark>): Node;
+  /** Create a copy of this node with only the content between the given positions. */
+  cut(from: number, to?: number): Node;
+  /** Cut out the part of the document between the given positions, and return it as a `Slice` object. */
+  slice(from: number, to?: number, includeParents?: boolean): Slice;
+  /** Replace the part of the document between the given positions with the given slice. */
+  replace(from: number, to: number, slice: Slice): Node;
+  /** Find the node directly after the given position. */
+  nodeAt(pos: number): Node | null;
+  /** Find the (direct) child node after the given offset, if any. */
+  childAfter(pos: number): {
+    node: Node | null;
+    index: number;
+    offset: number;
+  };
+  /** Find the (direct) child node before the given offset, if any. */
+  childBefore(pos: number): {
+    node: Node | null;
+    index: number;
+    offset: number;
+  };
+  /** Resolve the given position in the document. */
+  resolve(pos: number): ResolvedPos;
+  /** @internal */
+  resolveNoCache(pos: number): ResolvedPos;
+  /** Test whether a given mark or mark type occurs in this document between the two given positions. */
+  rangeHasMark(from: number, to: number, type: Mark | MarkType): 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. */
+  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. */
+  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): ContentMatch;
+  /**
+   * 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: number, to: number, replacement?: Fragment, start?: number, end?: number): boolean;
+  /** Test whether replacing the range `from` to `to` (by index) with a node of the given type would be valid. */
+  canReplaceWith(from: number, to: number, type: NodeType, marks?: ReadonlyArray<Mark>): boolean;
+  /** Test whether the given node's content could be appended to this node. */
+  canAppend(other: Node): boolean;
+  /** Check whether this node and its descendants conform to the schema, and raise an exception when they do not. */
+  check(): void;
+  /** Return a JSON-serializeable representation of this node. */
+  toJSON(): any;
+  /** Deserialize a node from its JSON representation. */
+  static fromJSON(schema: Schema, json: any): Node;
+}
+/** @internal */
+export declare class TextNode extends Node {
+  /** @internal */
+  readonly [CORE]: TextNode$1;
+  get text(): string;
+  /** @internal */
+  withText(text: string): TextNode;
+}
+/**
+ * A fragment represents a node's collection of child nodes.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Fragment {
+  /** @internal */
+  readonly [CORE]: Fragment$1;
+  /** @internal */
+  constructor(content: ReadonlyArray<Node>, size?: number);
+  /** The child nodes in this fragment. */
+  get content(): ReadonlyArray<Node>;
+  /** The size of the fragment, which is the total of the size of its content nodes. */
+  get size(): number;
+  /** Invoke a callback for all descendant nodes between the given two positions. */
+  nodesBetween(from: number, to: number, f: (node: Node, start: number, parent: Node | null, index: number) => boolean | void, nodeStart?: number, parent?: Node): void;
+  /** Call the given callback for every descendant node. */
+  descendants(f: (node: Node, pos: number, parent: Node | null, index: number) => boolean | void): void;
+  /** Extract the text between `from` and `to`. */
+  textBetween(from: number, to: number, blockSeparator?: string | null, leafText?: string | null | ((leafNode: Node) => string)): string;
+  /** Create a new fragment containing the combined content of this fragment and the other. */
+  append(other: Fragment): Fragment;
+  /** Cut out the sub-fragment between the two given positions. */
+  cut(from: number, to?: number): Fragment;
+  /** @internal */
+  cutByIndex(from: number, to: number): Fragment;
+  /** Create a new fragment in which the node at the given index is replaced by the given node. */
+  replaceChild(index: number, node: Node): Fragment;
+  /** Create a new fragment by prepending the given node to this fragment. */
+  addToStart(node: Node): Fragment;
+  /** Create a new fragment by appending the given node to this fragment. */
+  addToEnd(node: Node): Fragment;
+  /** Compare this fragment to another one. */
+  eq(other: Fragment): boolean;
+  /** The first child of the fragment, or `null` if it is empty. */
+  get firstChild(): Node | null;
+  /** The last child of the fragment, or `null` if it is empty. */
+  get lastChild(): Node | null;
+  /** The number of child nodes in this fragment. */
+  get childCount(): number;
+  /** Get the child node at the given index. Raise an error when the index is out of range. */
+  child(index: number): Node;
+  /** Get the child node at the given index, if it exists. */
+  maybeChild(index: number): Node | null;
+  /** Call `f` for every child node in this fragment. */
+  forEach(f: (node: Node, offset: number, index: number) => void): void;
+  /** Find the first position at which this fragment and another fragment differ, or `null` if they are the same. */
+  findDiffStart(other: Fragment, pos?: number): number | null;
+  /** Find the first position, searching from the end, at which this fragment and the given fragment differ. */
+  findDiffEnd(other: Fragment, pos?: number, otherPos?: number): {
+    a: number;
+    b: number;
+  } | null;
+  /** @internal */
+  findIndex(pos: number): {
+    index: number;
+    offset: number;
+  };
+  /** Return a debugging string that describes this fragment. */
+  toString(): string;
+  /** @internal */
+  toStringInner(): string;
+  /** Create a JSON-serializeable representation of this fragment. */
+  toJSON(): any;
+  /** Deserialize a fragment from its JSON representation. */
+  static fromJSON(schema: Schema, value: any): Fragment;
+  /** Build a fragment from an array of nodes. */
+  static fromArray(array: ReadonlyArray<Node>): Fragment;
+  /** Create a fragment from something that can be interpreted as a set of nodes. */
+  static from(nodes?: Fragment | Node | ReadonlyArray<Node> | null): Fragment;
+  /** An empty fragment. */
+  static empty: Fragment;
+}
+/**
+ * A mark is a piece of information that can be attached to a node.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Mark {
+  /** @internal */
+  readonly [CORE]: Mark$1;
+  /** @internal */
+  constructor(type: MarkType, attrs: Attrs);
+  /** The type of this mark. */
+  get type(): MarkType;
+  /** The attributes associated with this mark. */
+  get attrs(): Attrs;
+  /** Given a set of marks, create a new set which contains this one as well. */
+  addToSet(set: ReadonlyArray<Mark>): ReadonlyArray<Mark>;
+  /** Remove this mark from the given set. */
+  removeFromSet(set: ReadonlyArray<Mark>): ReadonlyArray<Mark>;
+  /** Test whether this mark is in the given set of marks. */
+  isInSet(set: ReadonlyArray<Mark>): boolean;
+  /** Test whether this mark has the same type and attributes as another mark. */
+  eq(other: Mark): boolean;
+  /** Convert this mark to a JSON-serializeable representation. */
+  toJSON(): any;
+  /** @internal */
+  toString(): string;
+  /** Deserialize a mark from JSON. */
+  static fromJSON(schema: Schema, json: any): Mark;
+  /** Test whether two sets of marks are identical. */
+  static sameSet(a: ReadonlyArray<Mark>, b: ReadonlyArray<Mark>): boolean;
+  /** Create a properly sorted mark set from null, a single mark, or an unsorted array of marks. */
+  static setFrom(marks?: Mark | ReadonlyArray<Mark> | null): ReadonlyArray<Mark>;
+  /** The empty set of marks. */
+  static none: ReadonlyArray<Mark>;
+}
+/**
+ * A slice represents a piece cut out of a larger document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Slice {
+  /** @internal */
+  readonly [CORE]: Slice$1;
+  /** Create a slice. */
+  constructor(content: Fragment, openStart: number, openEnd: number);
+  /** The slice's content. */
+  get content(): Fragment;
+  /** The open depth at the start of the fragment. */
+  get openStart(): number;
+  /** The open depth at the end. */
+  get openEnd(): number;
+  /** The size this slice would add when inserted into a document. */
+  get size(): number;
+  /** @internal */
+  insertAt(pos: number, fragment: Fragment): Slice | null;
+  /** @internal */
+  removeBetween(from: number, to: number): Slice;
+  /** Tests whether this slice is equal to another slice. */
+  eq(other: Slice): boolean;
+  /** @internal */
+  toString(): string;
+  /** Convert a slice to a JSON-serializable representation. */
+  toJSON(): any;
+  /** Deserialize a slice from its JSON representation. */
+  static fromJSON(schema: Schema, json: any): Slice;
+  /** Create a slice from a fragment by taking the maximum possible open value on both side of the fragment. */
+  static maxOpen(fragment: Fragment, openIsolating?: boolean): Slice;
+  /** The empty slice. */
+  static empty: Slice;
+}
+/**
+ * You can resolve a position to get more information about it.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class ResolvedPos {
+  /** @internal */
+  readonly [CORE]: ResolvedPos$1;
+  /** @internal */
+  private _path?;
+  /** @internal */
+  constructor(pos: number, path: Array<any>, parentOffset: number);
+  /** The position that was resolved. */
+  get pos(): number;
+  /** @internal */
+  get path(): Array<any>;
+  /** The offset this position has into its parent node. */
+  get parentOffset(): number;
+  /** The number of levels the parent node is from the root. */
+  get depth(): number;
+  /** The parent node that the position points into. */
+  get parent(): Node;
+  /** The root node in which the position was resolved. */
+  get doc(): Node;
+  /** The ancestor node at the given level. */
+  node(depth?: number | null): Node;
+  /** The index into the ancestor at the given level. */
+  index(depth?: number | null): number;
+  /** The index pointing after this position into the ancestor at the given level. */
+  indexAfter(depth?: number | null): number;
+  /** The (absolute) position at the start of the node at the given level. */
+  start(depth?: number | null): number;
+  /** The (absolute) position at the end of the node at the given level. */
+  end(depth?: number | null): number;
+  /** The (absolute) position directly before the wrapping node at the given level. */
+  before(depth?: number | null): number;
+  /** The (absolute) position directly after the wrapping node at the given level. */
+  after(depth?: number | null): number;
+  /** When this position points into a text node, this returns the distance between the position and the start of the text node. */
+  get textOffset(): number;
+  /** Get the node directly after the position, if any. */
+  get nodeAfter(): Node | null;
+  /** Get the node directly before the position, if any. */
+  get nodeBefore(): Node | null;
+  /** Get the position at the given index in the parent node at the given depth. */
+  posAtIndex(index: number, depth?: number | null): number;
+  /** Get the marks at this position. */
+  marks(): ReadonlyArray<Mark>;
+  /** Get the marks after the current position, if any, except those that are non-inclusive and not present at position `$end`. */
+  marksAcross($end: ResolvedPos): ReadonlyArray<Mark> | null;
+  /** The depth up to which this position and the given (non-resolved) position share the same parent nodes. */
+  sharedDepth(pos: number): number;
+  /** Returns a range based on the place where this position and the given position diverge around block content. */
+  blockRange(other?: ResolvedPos, pred?: (node: Node) => boolean): NodeRange | null;
+  /** Query whether the given position shares the same parent node. */
+  sameParent(other: ResolvedPos): boolean;
+  /** Return the greater of this and the given position. */
+  max(other: ResolvedPos): ResolvedPos;
+  /** Return the smaller of this and the given position. */
+  min(other: ResolvedPos): ResolvedPos;
+  /** @internal */
+  toString(): string;
+  /** @internal */
+  static resolve(doc: Node, pos: number): ResolvedPos;
+  /** @internal */
+  static resolveCached(doc: Node, pos: number): ResolvedPos;
+}
+/**
+ * Represents a flat range of content, i.e. one that starts and ends in
+ * the same node.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class NodeRange {
+  /** @internal */
+  readonly [CORE]: NodeRange$1;
+  /** Construct a node range. */
+  constructor($from: ResolvedPos, $to: ResolvedPos, depth: number);
+  /** A resolved position along the start of the content. */
+  get $from(): ResolvedPos;
+  /** A position along the end of the content. */
+  get $to(): ResolvedPos;
+  /** The depth of the node that this range points into. */
+  get depth(): number;
+  /** The position at the start of the range. */
+  get start(): number;
+  /** The position at the end of the range. */
+  get end(): number;
+  /** The parent node that the range points into. */
+  get parent(): Node;
+  /** The start index of the range in the parent node. */
+  get startIndex(): number;
+  /** The end index of the range in the parent node. */
+  get endIndex(): number;
+}
+/**
+ * Instances of this class represent a match state of a node type's
+ * content expression.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class ContentMatch {
+  /** @internal */
+  readonly [CORE]: ContentMatch$1;
+  /** @internal */
+  constructor(validEnd: boolean);
+  /** True when this match state represents a valid end of the node. */
+  get validEnd(): boolean;
+  /** @internal */
+  get next(): ReadonlyArray<{
+    readonly type: NodeType;
+    readonly next: ContentMatch;
+  }>;
+  /** @internal */
+  static parse(string: string, nodeTypes: {
+    readonly [name: string]: NodeType;
+  }): ContentMatch;
+  /** Match a node type, returning a match after that node if successful. */
+  matchType(type: NodeType): ContentMatch | null;
+  /** Try to match a fragment. Returns the resulting match when successful. */
+  matchFragment(frag: Fragment, start?: number, end?: number): ContentMatch | null;
+  /** @internal */
+  get inlineContent(): boolean;
+  /** Get the first matching node type at this match position that can be generated. */
+  get defaultType(): NodeType | null;
+  /** @internal */
+  compatible(other: ContentMatch): boolean;
+  /** 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: Fragment, toEnd?: boolean, startIndex?: number): Fragment | null;
+  /** Find a set of wrapping node types that would allow a node of the given type to appear at this position. */
+  findWrapping(target: NodeType): ReadonlyArray<NodeType> | null;
+  /** The number of outgoing edges this node has in the finite automaton that describes the content expression. */
+  get edgeCount(): number;
+  /** Get the _n_th outgoing edge from this node in the finite automaton that describes the content expression. */
+  edge(n: number): {
+    readonly type: NodeType;
+    readonly next: ContentMatch;
+  };
+  /** @internal */
+  toString(): string;
+  /** @internal */
+  static empty: ContentMatch;
+}
+/**
+ * Used to define attributes on nodes or marks.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface AttributeSpec {
+  default?: any;
+  validate?: (string | ((value: any) => void)) | undefined;
+}
+/**
+ * A description of a node type, used when defining a schema.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface NodeSpec {
+  content?: string | undefined;
+  marks?: string | undefined;
+  group?: string | undefined;
+  inline?: boolean | undefined;
+  atom?: boolean | undefined;
+  attrs?: {
+    [name: string]: AttributeSpec;
+  } | undefined;
+  selectable?: boolean | undefined;
+  draggable?: boolean | undefined;
+  code?: boolean | undefined;
+  whitespace?: "pre" | "normal" | undefined;
+  definingAsContext?: boolean | undefined;
+  definingForContent?: boolean | undefined;
+  defining?: boolean | undefined;
+  isolating?: boolean | undefined;
+  toDOM?: ((node: Node) => DOMOutputSpec) | undefined;
+  parseDOM?: ReadonlyArray<TagParseRule> | undefined;
+  toDebugString?: ((node: Node) => string) | undefined;
+  leafText?: ((node: Node) => string) | undefined;
+  linebreakReplacement?: boolean | undefined;
+  [key: string]: any;
+}
+/**
+ * Used to define marks when creating a schema.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface MarkSpec {
+  attrs?: {
+    [name: string]: AttributeSpec;
+  } | undefined;
+  inclusive?: boolean | undefined;
+  excludes?: string | undefined;
+  group?: string | undefined;
+  spanning?: boolean | undefined;
+  code?: boolean | undefined;
+  toDOM?: ((mark: Mark, inline: boolean) => DOMOutputSpec) | undefined;
+  parseDOM?: ReadonlyArray<ParseRule> | undefined;
+  [key: string]: any;
+}
+/**
+ * An object describing a schema, as passed to the `Schema` constructor.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface SchemaSpec<Nodes extends string = any, Marks extends string = any> {
+  nodes: { [name in Nodes]: NodeSpec; } | OrderedMap<NodeSpec>;
+  marks?: { [name in Marks]: MarkSpec; } | OrderedMap<MarkSpec> | undefined;
+  topNode?: string | undefined;
+}
+/**
+ * Fields that may be present in both tag and style parse rules.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface GenericParseRule {
+  priority?: number | undefined;
+  consuming?: boolean | undefined;
+  context?: string | undefined;
+  mark?: string | undefined;
+  ignore?: boolean | undefined;
+  closeParent?: boolean | undefined;
+  skip?: boolean | undefined;
+  attrs?: Attrs | undefined;
+}
+/**
+ * Parse rule targeting a DOM element.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface TagParseRule extends GenericParseRule {
+  tag: string;
+  style?: undefined;
+  namespace?: string | undefined;
+  node?: string | undefined;
+  getAttrs?: ((node: HTMLElement) => Attrs | false | null) | undefined;
+  contentElement?: (string | HTMLElement | ((node: HTMLElement) => HTMLElement)) | undefined;
+  getContent?: ((node: globalThis.Node, schema: Schema) => Fragment) | undefined;
+  preserveWhitespace?: boolean | "full" | undefined;
+}
+/**
+ * A parse rule targeting a style property.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface StyleParseRule extends GenericParseRule {
+  style: string;
+  clearMark?: ((mark: Mark) => boolean) | undefined;
+  getAttrs?: ((node: string) => Attrs | false | null) | undefined;
+}
+/**
+ * A value that describes how to parse a given DOM node or inline style
+ * as a ProseMirror node or mark.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ParseRule = TagParseRule | StyleParseRule;
+/**
+ * Node types are objects allocated once per `Schema` and used to tag
+ * `Node` instances.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class NodeType {
+  /** @internal */
+  readonly [CORE]: NodeType$1;
+  /** The name the node type has in this schema. */
+  get name(): string;
+  /** A link back to the `Schema` the node type belongs to. */
+  get schema(): Schema;
+  /** The spec that this type is based on. */
+  get spec(): NodeSpec;
+  /** @internal */
+  get groups(): ReadonlyArray<string>;
+  /** @internal */
+  get attrs(): {
+    readonly [name: string]: {
+      readonly hasDefault: boolean;
+      readonly default: any;
+    };
+  };
+  /** @internal */
+  get defaultAttrs(): Attrs | null;
+  /** True if this is a block type. */
+  get isBlock(): boolean;
+  /** True if this is the text node type. */
+  get isText(): boolean;
+  /** True if this node type has inline content. */
+  get inlineContent(): boolean;
+  /** The starting match of the node type's content expression. */
+  get contentMatch(): ContentMatch;
+  /** The set of marks allowed in this node. `null` means all marks are allowed. */
+  get markSet(): ReadonlyArray<MarkType> | null;
+  /** True if this is an inline type. */
+  get isInline(): boolean;
+  /** True if this is a textblock type, a block that contains inline content. */
+  get isTextblock(): boolean;
+  /** True for node types that allow no content. */
+  get isLeaf(): boolean;
+  /** True when this node is an atom, i.e. when it does not have directly editable content. */
+  get isAtom(): boolean;
+  /** Return true when this node type is part of the given group. */
+  isInGroup(group: string): boolean;
+  /** The node type's whitespace option. */
+  get whitespace(): "pre" | "normal";
+  /** Tells you whether this node type has any required attributes. */
+  hasRequiredAttrs(): boolean;
+  /** Indicates whether this node allows some of the same content as the given node type. */
+  compatibleContent(other: NodeType): boolean;
+  /** @internal */
+  computeAttrs(attrs: Attrs | null | undefined): Attrs;
+  /** Create a `Node` of this type. */
+  create(attrs?: Attrs | null, content?: Fragment | Node | ReadonlyArray<Node> | null, marks?: ReadonlyArray<Mark>): Node;
+  /** Like `create`, but check the given content against the node type's content restrictions. */
+  createChecked(attrs?: Attrs | null, content?: Fragment | Node | ReadonlyArray<Node> | null, marks?: ReadonlyArray<Mark>): Node;
+  /** 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?: Attrs | null, content?: Fragment | Node | ReadonlyArray<Node> | null, marks?: ReadonlyArray<Mark>): Node | null;
+  /** Returns true if the given fragment is valid content for this node type. */
+  validContent(content: Fragment): boolean;
+  /** @internal */
+  checkContent(content: Fragment): void;
+  /** @internal */
+  checkAttrs(attrs: Attrs): void;
+  /** Check whether the given mark type is allowed in this node. */
+  allowsMarkType(markType: MarkType): boolean;
+  /** Test whether the given set of marks are allowed in this node. */
+  allowsMarks(marks: ReadonlyArray<Mark>): boolean;
+  /** Removes the marks that are not allowed in this node from the given set. */
+  allowedMarks(marks: ReadonlyArray<Mark>): ReadonlyArray<Mark>;
+  /** @internal */
+  toString(): string;
+}
+/**
+ * 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
+ */
+export declare class MarkType {
+  /** @internal */
+  readonly [CORE]: MarkType$1;
+  /** The name of the mark type. */
+  get name(): string;
+  /** @internal */
+  get rank(): number;
+  /** The schema that this mark type instance is part of. */
+  get schema(): Schema;
+  /** The spec on which the type is based. */
+  get spec(): MarkSpec;
+  /** @internal */
+  get attrs(): {
+    readonly [name: string]: {
+      readonly hasDefault: boolean;
+      readonly default: any;
+    };
+  };
+  /** @internal */
+  get excluded(): ReadonlyArray<MarkType>;
+  /** @internal */
+  get instance(): Mark | null;
+  /** Create a mark of this type. */
+  create(attrs?: Attrs | null): Mark;
+  /** When there is a mark of this type in the given set, a new set without it is returned. */
+  removeFromSet(set: ReadonlyArray<Mark>): ReadonlyArray<Mark>;
+  /** Tests whether there is a mark of this type in the given set. */
+  isInSet(set: ReadonlyArray<Mark>): Mark | undefined;
+  /** @internal */
+  checkAttrs(attrs: Attrs): void;
+  /** Queries whether a given mark type is excluded by this one. */
+  excludes(other: MarkType): boolean;
+  /** @internal */
+  toString(): string;
+}
+/**
+ * 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
+ */
+export declare class Schema<Nodes extends string = any, Marks extends string = any> {
+  /** @internal */
+  readonly [CORE]: DocSchema;
+  /** The spec on which the schema is based. */
+  spec: {
+    nodes: OrderedMap<NodeSpec>;
+    marks: OrderedMap<MarkSpec>;
+    topNode?: string;
+  };
+  /** An object mapping the schema's node names to node type objects. */
+  nodes: { readonly [name in Nodes]: NodeType; } & {
+    readonly [key: string]: NodeType;
+  };
+  /** A map from mark names to mark type objects. */
+  marks: { readonly [name in Marks]: MarkType; } & {
+    readonly [key: string]: MarkType;
+  };
+  /** The linebreak replacement node defined in this schema, if any. */
+  linebreakReplacement: NodeType | null;
+  /** The type of the default top node for this schema. */
+  topNodeType: NodeType;
+  /** An object for storing whatever values modules may want to compute and cache per schema. */
+  cached: {
+    [key: string]: any;
+  };
+  /** Construct a schema from a schema specification. */
+  constructor(spec: SchemaSpec<Nodes, Marks>);
+  /** Create a node in this schema. */
+  node(type: string | NodeType, attrs?: Attrs | null, content?: Fragment | Node | ReadonlyArray<Node>, marks?: ReadonlyArray<Mark>): Node;
+  /** Create a text node in the schema. Empty text nodes are not allowed. */
+  text(text: string, marks?: ReadonlyArray<Mark> | null): Node;
+  /** Create a mark with the given type and attributes. */
+  mark(type: string | MarkType, attrs?: Attrs | null): Mark;
+  /** Deserialize a node from its JSON representation. */
+  nodeFromJSON(json: any): Node;
+  /** Deserialize a mark from its JSON representation. */
+  markFromJSON(json: any): Mark;
+  /** @internal */
+  nodeType(name: string): NodeType;
+}
+/**
+ * Options accepted by the parser methods.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ParseOptions {
+  preserveWhitespace?: boolean | "full" | undefined;
+  findPositions?: Array<{
+    node: globalThis.Node;
+    offset: number;
+    pos?: number;
+  }> | undefined;
+  from?: number | undefined;
+  to?: number | undefined;
+  topNode?: Node | undefined;
+  topMatch?: ContentMatch | undefined;
+  context?: ResolvedPos | undefined;
+  ruleFromNode?: ((node: globalThis.Node) => Omit<TagParseRule, "tag"> | null) | undefined;
+  topOpen?: boolean | undefined;
+}
+/** @internal */
+export declare const parseOptions: (options: ParseOptions | undefined) => ParseOptions$1;
+/**
+ * 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
+ */
+export declare class DOMParser {
+  /** @internal */
+  readonly [CORE]: DOMParser$1;
+  /** @internal */
+  private _rules?;
+  /** Create a parser that targets the given schema, using the given parsing rules. */
+  constructor(schema: Schema, rules: ReadonlyArray<ParseRule>);
+  /** The schema into which the parser parses. */
+  get schema(): Schema;
+  /** The set of parse rules that the parser uses, in order of precedence. */
+  get rules(): ReadonlyArray<ParseRule>;
+  /** @internal */
+  get tags(): ReadonlyArray<TagParseRule>;
+  /** @internal */
+  get styles(): ReadonlyArray<StyleParseRule>;
+  /** Parse a document from the content of a DOM node. */
+  parse(dom: globalThis.Node, options?: ParseOptions): Node;
+  /** Parses the content of the given DOM node, like `parse`, and returns a slice open at the sides. */
+  parseSlice(dom: globalThis.Node, options?: ParseOptions): Slice;
+  /** @internal */
+  matchTag(dom: globalThis.Node, context?: any, after?: TagParseRule): TagParseRule | null;
+  /** @internal */
+  matchStyle(prop: string, value: string, context?: any, after?: StyleParseRule): StyleParseRule | null;
+  /** @internal */
+  static schemaRules(schema: Schema): Array<ParseRule>;
+  /** Construct a DOM parser using the parsing rules listed in a schema's node specs, reordered by priority. */
+  static fromSchema(schema: Schema): DOMParser;
+}
+/**
+ * A DOM serializer knows how to convert ProseMirror nodes and marks of
+ * various types to DOM nodes.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class DOMSerializer {
+  /** @internal */
+  readonly [CORE]: DOMSerializer$1;
+  /** The node serialization functions. */
+  readonly nodes: {
+    readonly [node: string]: (node: Node) => DOMOutputSpec;
+  };
+  /** The mark serialization functions. */
+  readonly marks: {
+    readonly [mark: string]: (mark: Mark, inline: boolean) => DOMOutputSpec;
+  };
+  /** Create a serializer. */
+  constructor(nodes: {
+    readonly [node: string]: (node: Node) => DOMOutputSpec;
+  }, marks: {
+    readonly [mark: string]: ((mark: Mark, inline: boolean) => DOMOutputSpec) | null | undefined;
+  });
+  /** Serialize the content of this fragment to a DOM fragment. */
+  serializeFragment(fragment: Fragment, options?: {
+    document?: Document;
+  }, target?: HTMLElement | DocumentFragment): HTMLElement | DocumentFragment;
+  /** Serialize this node to a DOM node. */
+  serializeNode(node: Node, options?: {
+    document?: Document;
+  }): globalThis.Node;
+  /** @internal */
+  serializeMark(mark: Mark, inline: boolean, options?: {
+    document?: Document;
+  }): {
+    dom: globalThis.Node;
+    contentDOM?: HTMLElement;
+  } | null;
+  /** Render an output spec to a DOM node. */
+  static renderSpec(doc: Document, structure: DOMOutputSpec, xmlNS?: string | null, blockArraysIn?: {
+    [name: string]: any;
+  }): {
+    dom: globalThis.Node;
+    contentDOM?: HTMLElement;
+  };
+  /** Build a serializer using the `toDOM` properties in a schema's node and mark specs. */
+  static fromSchema(schema: Schema): DOMSerializer;
+  /** Gather the serializers in a schema's node specs into an object. */
+  static nodesFromSchema(schema: Schema): {
+    [node: string]: (node: Node) => DOMOutputSpec;
+  };
+  /** Gather the serializers in a schema's mark specs into an object. */
+  static marksFromSchema(schema: Schema): {
+    [mark: string]: (mark: Mark, inline: boolean) => DOMOutputSpec;
+  };
+}
+/**
+ * Get the core (Effect API) object behind a facade.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare function toCore(node: Node): Node$1;
+export declare function toCore(fragment: Fragment): Fragment$1;
+export declare function toCore(mark: Mark): Mark$1;
+export declare function toCore(slice: Slice): Slice$1;
+export declare function toCore($pos: ResolvedPos): ResolvedPos$1;
+export declare function toCore(range: NodeRange): NodeRange$1;
+export declare function toCore(match: ContentMatch): ContentMatch$1;
+export declare function toCore(type: NodeType): NodeType$1;
+export declare function toCore(type: MarkType): MarkType$1;
+export declare function toCore(schema: Schema): DocSchema;
+export declare function toCore(parser: DOMParser): DOMParser$1;
+export declare function toCore(serializer: DOMSerializer): DOMSerializer$1;
+export declare function toCore(marks: ReadonlyArray<Mark>): ReadonlyArray<Mark$1>;
+export declare function toCore(nodes: ReadonlyArray<Node>): ReadonlyArray<Node$1>;
+/**
+ * Get the facade for a core (Effect API) object. The same core object
+ * always yields the same facade.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare function fromCore(node: TextNode$1<any>): Node;
+export declare function fromCore(node: Node$1<any, any>): Node;
+export declare function fromCore(fragment: Fragment$1<any, any>): Fragment;
+export declare function fromCore(mark: Mark$1<any, any>): Mark;
+export declare function fromCore(slice: Slice$1<any>): Slice;
+export declare function fromCore($pos: ResolvedPos$1<any>): ResolvedPos;
+export declare function fromCore(range: NodeRange$1<any>): NodeRange;
+export declare function fromCore(match: ContentMatch$1): ContentMatch;
+export declare function fromCore(type: NodeType$1<any, any>): NodeType;
+export declare function fromCore(type: MarkType$1<any, any>): MarkType;
+export declare function fromCore(schema: DocSchema<any, any>): Schema;
+export declare function fromCore(parser: DOMParser$1<any>): DOMParser;
+export declare function fromCore(serializer: DOMSerializer$1<any>): DOMSerializer;
+export declare function fromCore(marks: ReadonlyArray<Mark$1<any, any>>): ReadonlyArray<Mark>;
+export declare function fromCore(nodes: ReadonlyArray<Node$1<any, any>>): ReadonlyArray<Node>;
+export { OrderedMap, ReplaceError };