@nerd-bible/wordgard 0.3.3

package/dist/doc.d.ts

@@ -0,0 +1,2210 @@
+type DOMElement$1 = Element;
+
+type DOMElement = Element;
+/**
+Parse the given DOM structure as a document, using the given
+schema. By default the set of parse rules will be derived from the
+schema, but it is possible to pass in a custom set.
+*/
+declare function parse(schema: Schema, doc: Element | DocumentFragment, options?: parse.Options): Plot.Doc;
+declare namespace parse {
+    /**
+    Options that can be passed to parsing functions.
+    */
+    type Options = {
+        /**
+        Controls whether HTML-style whitespace collapsing is used
+        (outside nodes that don't enable `preserveWhitespace`). Defaults
+        to true.
+        */
+        collapseWhiteSpace?: boolean;
+        /**
+        Function used in in {@link parse.slice} to determine
+        whether a given element is open (on either side).
+        */
+        isOpen?: (elt: Element) => null | "start" | "end" | "start end";
+        /**
+        The rule set to use. Defaults to the rule set derived from the
+        schema.
+        */
+        ruleSet?: parse.Rule.Set;
+    };
+    /**
+    Parse the given DOM structure as a slice.
+    */
+    function slice(schema: Schema, doc: Element | DocumentFragment, options?: parse.Options): {
+        slice: Slice;
+        context: Plot.Tag<unknown>[];
+    };
+    /**
+    Parse rules describe how DOM constructs should map to Wordgard
+    document nodes. Many can be automatically derived from node and
+    mark {@link Node.Spec.shape shapes}, but it is also often
+    useful to provide them directly.
+    */
+    type Rule<Param = any> = Rule.Element<Param> | Rule.Attribute<Param>;
+    namespace Rule {
+        /**
+        Describes a rule that matches elements by selector.
+        */
+        interface Element<Param> {
+            /**
+            The CSS selector that should match the element.
+            */
+            selector: string;
+            /**
+            If this is a node-creating rule, this holds the type of node
+            to create when this rule matches. If this is a node type
+            without default parameter, you _must_ also define {@link
+            parse.Rule.Element.param} or {@link
+            parse.Rule.Element.readElement}.
+            */
+            tag?: Leaf<Param> | Plot.Tag<Param> | Node.Type<Param>;
+            /**
+            Mark-creating rules should provide a mark or mark type here.
+            The mark will be applied to the content of the element.
+            Again, if the type lacks a parameter, {@link
+            parse.Rule.Element.param} or {@link
+            parse.Rule.Element.readElement} will be used to find it.
+            */
+            mark?: Mark.Type<Param> | Mark<Param>;
+            /**
+            Instead of creating a node or mark, rules may tell the
+            parser to ignore a given element. `true` means discard it
+            entirely, `"skip"` means ignore the element itself, but do
+            parse its child nodes.
+            */
+            ignore?: boolean | "skip";
+            /**
+            A parameter for the tag or mark type.
+            */
+            param?: Param;
+            /**
+            A function that reads the parameter from the matched
+            element. May return {@link parse.Reject} to indicate
+            that the rule should not be applied to this element.
+            */
+            readElement?: (element: DOMElement) => Param | typeof Reject;
+            /**
+            An optional CSS selector for finding an additional inner
+            element to read marks from.
+            */
+            marksFrom?: string;
+            /**
+            By default, when applying a rule for a plot or mark type,
+            parsing continues with the element's direct children. You
+            can pass a selector or function here to select another content element.
+            */
+            contentElement?: string | ((elt: DOMElement) => DOMElement);
+            /**
+            Ignore DOM nodes matching this selector or predicate, when
+            they appear in this plot's content element.
+            */
+            ignoreContent?: string | ((elt: DOMElement) => boolean);
+            /**
+            A number between -10 and 10 (inclusive) that specifies the
+            relative precedence of this rule. Defaults to 0.
+            */
+            precedence?: number;
+        }
+        /**
+        An attribute parse rule matches an attribute, instead of an
+        entire element. Such a rule can only create marks, not tags.
+        */
+        interface Attribute<Param> {
+            /**
+            The attribute to look for. May have the form `style/color`
+            to look at a style property instead.
+            */
+            attribute: string;
+            /**
+            When given, this rule only matches when the attribute has
+            this value.
+            */
+            value?: string;
+            /**
+            The mark to create for this attribute, if any.
+            */
+            mark?: Mark.Type<Param> | Mark<Param>;
+            /**
+            Remove a mark from the surrounding set of marks when this
+            rule matches.
+            */
+            clearMark?: (mark: Mark<unknown>) => boolean;
+            /**
+            Can be set to true to cause the parser to ignore this
+            attribute.
+            */
+            ignore?: boolean;
+            /**
+            A parameter to give to the mark type in {@link
+            parse.Rule.Attribute.mark}.
+            */
+            param?: Param;
+            /**
+            Read a parameter value from the attribute value. May return
+            {@link parse.Reject} to prevent the rule from matching.
+            */
+            readAttribute?: (value: string) => Param | typeof Reject;
+            /**
+            Controls whether other rules may match this attribute after
+            this rule matches. Defaults to true.
+            */
+            consuming?: boolean;
+            /**
+            A number between -10 and 10 (inclusive) that specifies the
+            relative precedence of this rule. Defaults to 0.
+            */
+            precedence?: number;
+        }
+        /**
+        A collection of parse rules. Usually derived from a schema.
+        */
+        class Set {
+            /**
+            The rules in this set.
+            */
+            readonly rules: readonly Rule[];
+            private constructor();
+            /**
+            Create a rule set with the given parse rules.
+            */
+            static of(rules: readonly Rule[]): Set;
+            /**
+            Create a rule set containing all the parse rules attached to
+            nodes and marks in the given schema, as well as the rules that
+            can be derived from the node and mark shape declarations.
+            */
+            static fromSchema(schema: Schema): Set;
+        }
+    }
+    /**
+    A special value that parse rule functions can return to block
+    the rule from matching.
+    */
+    const Reject: unique symbol;
+}
+
+/**
+This class describes a DOM element, its attributes, and its
+children. It is used in describing the structure of {@link
+Node.Spec.shape nodes} and {@link editor.Decoration decorations}.
+
+Elements can provide a wrapping structure by having a content hole
+somewhere in their children, which indicates where the structure
+they wrap (typically a node's content) goes.
+
+The type parameter indicates the set of additional leaf types. By
+default, it holds only `string` (as a shorthand for text nodes),
+but elements used in decorations also support {@link editor.Widget
+custom widgets}.
+*/
+declare class Elt<T = string> {
+    /**
+    The element's tag name. May be prefixed with `"svg:"` or
+    `"math:"` to indicate an SVG or MathML element.
+    */
+    readonly tagName: string;
+    /**
+    The set of attributes, as an {@link Attributes array of
+    strings}.
+    */
+    readonly attrs: Attributes;
+    /**
+    The element's children.
+    */
+    readonly children: readonly (T | Elt<T> | 0)[];
+    private constructor();
+    /**
+    Create an element. See also {@link Elt.mk} for a more ergonomic
+    creation function.
+    */
+    static create<T = string>(tagName: string, attrs: Attributes, children: readonly (T | Elt<T> | 0)[]): Elt<Exclude<T, Elt<any> | 0>>;
+    /**
+    Create an element, specifying the attributes as an object. Both
+    the set of attributesand the array of children are optional. The
+    literal number 0 is used to indicate a content hole in the
+    array of children.
+    */
+    static mk<T = string>(name: string, children?: (T | 0 | Elt<T>)[]): Elt<Exclude<T, Elt<any> | 0>>;
+    static mk<T = string>(name: string, attrs: Record<string, string>, children?: readonly (T | 0 | Elt<T>)[]): Elt<Exclude<T, Elt<any> | 0>>;
+    /**
+    True if this element or one of its children has a content hole.
+    */
+    get hasContent(): boolean;
+    /**
+    Compare this element's tag name and attributes (not its
+    children) to another element.
+    */
+    eqTag(elt: Elt<any>): boolean;
+    /**
+    Compare this element (including its children) to another
+    element.
+    */
+    eq(other: any): boolean;
+    private modifyBySelector;
+    /**
+    Convert an element with string content to an HTML string.
+    */
+    toHTML(this: Elt<string>): string;
+    /**
+    Convert an element (with only string content) to a DOM tree.
+    */
+    toDOM(this: Elt<string>, doc?: Document): Element | Text;
+}
+declare namespace Elt {
+    /**
+    A collection of elements or other content values.
+    */
+    class Fragment<T = string> {
+        readonly content: readonly (T | Elt<T>)[];
+        private constructor();
+        /**
+        Create a fragment.
+        */
+        static create<T = string>(content: readonly (T | Elt<T>)[]): Fragment<T>;
+        /**
+        Convert this fragment to an HTML string.
+        */
+        toHTML(this: Fragment<string>): string;
+        /**
+        Convert this fragment to a DOM fragment.
+        */
+        toDOM(this: Fragment<string>, doc?: Document): DocumentFragment;
+    }
+}
+/**
+Sets of attributes are stored in arrays of strings, with the even
+indices holding attribute names, the odd ones attribute values. The
+attributes are sorted by name.
+*/
+type Attributes = readonly string[];
+declare namespace Attributes {
+    /**
+    The empty set of attributes.
+    */
+    const none: Attributes;
+    /**
+    Compare two attribute sets.
+    */
+    function eq(a: Attributes, b: Attributes): boolean;
+    /**
+    Combine two attribute sets, with b having higher precedence when
+    they set the same attribute.
+    */
+    function merge(a: Attributes, b: Attributes): Attributes;
+    /**
+    Convert an attribute object into a set.
+    */
+    function read(obj: Record<string, string | null>): Attributes;
+    /**
+    Get the value of the given attribute.
+    */
+    function get(attrs: Attributes, name: string): string | null;
+}
+declare namespace Shape {
+    /**
+    Declares the shape of a node or mark to be a simple element. A
+    parse rule can automatically be derived for it if the node or mark
+    has a default parameter or a `read` function is defined to
+    determine the parameter.
+    */
+    type Element<Param> = {
+        /**
+        The element name to use.
+        */
+        element: string;
+        /**
+        A selector to use in the parse rule. Defaults to the element
+        name.
+        */
+        selector?: string;
+        /**
+        Attributes to add to the element.
+        */
+        attributes?: Record<string, string> | ((param: Param) => Record<string, string>);
+        /**
+        A helper to read a parameter value from the element. If this
+        returns {@link parse.Reject}, the parse rule will not apply.
+        */
+        readElement?: (element: DOMElement$1) => Param | typeof parse.Reject;
+        /**
+        When specifying the shape of a plot, this indicates whether this
+        node is an atom, meaning its content isn't editable through the
+        editor.
+        */
+        atom?: boolean;
+    };
+    /**
+    Declares the shape of a node in a way that allows a more
+    complicated shape than {@link Shape.Element}. This will not
+    automatically create a parse rule, so you'll want to define
+    those yourself.
+    */
+    type Structure<Param> = {
+        /**
+        The structure as a tree of {@link Elt}s. If this is for a plot
+        that is not to be rendered as an atom, the structure should
+        contain a hole for the content.
+        */
+        structure: Elt<string> | ((param: Param) => Elt<string>);
+        /**
+        If `structure` is a function, and the target node is a plot, use
+        this to specify whether the plot should be rendered as an atom
+        or with content.
+        */
+        atom?: boolean;
+    };
+    /**
+    Declares that a mark is represented with a specific DOM attribute.
+    This allows a matching parse rule to be derived automatically in
+    most situations.
+    */
+    type Attribute<Param> = {
+        /**
+        The name of the attribute.
+        */
+        attribute: string;
+        /**
+        Its value. When given as 0, which is ony valid when the
+        `Param` type is `string`, the value of the mark's parameter is
+        used directly.
+        */
+        value: (Param extends string ? 0 : never) | string | ((param: Param) => string | null);
+        /**
+        An optional function that converts the value of the attribute
+        back into a parameter value. Used in the parse rule.
+        */
+        readAttribute?: (value: string) => Param | typeof parse.Reject;
+        /**
+        If the target node may be a composite shape (rather than a
+        single DOM element), you can provide a limited form of selector
+        here to target a specific element in that shape. Node names and
+        class names are supported, as in `"img"`, `"img.my-class"`, or
+        `".class1.class2"`. If no matching element is found, the
+        attributes will be added to the node's outer element, as normal.
+        */
+        preferTarget?: string;
+    };
+    /**
+    Declares that a dynamic attribute or set of attributes should be
+    added to nodes with this mark. Will not produce an implicit parse
+    rule.
+    */
+    type Attributes<Param> = {
+        /**
+        The attributes to add, either directly or as a function of the
+        mark's parameter.
+        */
+        attributes: Record<string, string> | ((param: Param) => Record<string, string>);
+        /**
+        A selector for the {@link Shape.Attribute.preferTarget
+        preferred target} element.
+        */
+        preferTarget?: string;
+    };
+}
+
+/**
+A mark has a type and a value. Some mark types without a
+meaningful parameter value (such as {@link types.Emphasis}),
+will only use a single mark object.
+*/
+declare class Mark<Value = unknown> {
+    /**
+    The type of the mark.
+    */
+    readonly type: Mark.Type<Value>;
+    /**
+    The parameter value. This may be something like the link
+    target for a link mark, or the alignment side for a text
+    alignment mark.
+    */
+    readonly value: Value;
+    private constructor();
+    /**
+    Compare this mark to another one. Parameter values are compared
+    by structure.
+    */
+    eq(other: Mark): boolean;
+    /**
+    The name of this mark's type.
+    */
+    get name(): string;
+    /**
+    Define a singleton mark, without parameter.
+    */
+    static define(name: string, spec: Mark.Spec<null>): Mark<null>;
+    /**
+    Add this mark to the given set. Will overwrite existing
+    instances of the mark in the set, unless this is a {@link
+    Mark.Spec.set set-valued} mark.
+    */
+    addToSet(set: Mark.Set): Mark.Set;
+    /**
+    Remove this mark from the given set.
+    */
+    removeFromSet(set: Mark.Set): Mark.Set;
+    /**
+    Test whether this mark is in the given set.
+    */
+    isInSet(set: Mark.Set): Mark<Value> | null;
+    /**
+    Compare two sets of marks.
+    */
+    static sameSet(a: Mark.Set, b: Mark.Set): boolean;
+    /**
+    The empty mark set.
+    */
+    static none: Mark.Set;
+}
+declare namespace Mark {
+    class Type<Param = unknown> {
+        /**
+        The name of the mark's type.
+        */
+        readonly name: string;
+        /**
+        The {@link Mark.Spec.defaultParam default} mark for this type,
+        if any.
+        */
+        readonly default: Mark<Param> | null;
+        /**
+        Whether this is an {@link Mark.Spec.inclusive inclusive} mark.
+        */
+        readonly inclusive: boolean;
+        /**
+        Whether this is a {@link Mark.Spec.spanning spanning} mark.
+        */
+        readonly spanning: boolean;
+        /**
+        The spec used to define this mark. (Its type parameter is set
+        to `any` to circumvent a typing issue where `Mark<T>` isn't a
+        subtype of `Mark<unknown>`.)
+        */
+        readonly spec: Mark.Spec<any>;
+        private constructor();
+        /**
+        Create a mark of this type.
+        */
+        of(value: Param): Mark<Param>;
+        /**
+        Remove the mark of this type from the given set, if present.
+        */
+        removeFromSet(set: Mark.Set): Mark.Set;
+        /**
+        Test whether there is a mark of this type in the given set. If
+        so, return it.
+        */
+        isInSet(set: Mark.Set): Mark<Param> | null;
+        /**
+        Whether this mark is rendered with an element.
+        */
+        get isElement(): boolean;
+        /**
+        Define a mark type with the given parameter type.
+        */
+        static define<Param>(name: string, spec: Mark.Spec<Param>, 
+        /**
+        @internal
+        */
+        isFlag?: boolean): Type<Param>;
+    }
+    /**
+    Configuration for marks.
+    */
+    interface Spec<Param> {
+        /**
+        Which node tags this mark may apply to, as node {@link Node.Query query}.
+        The default is `{and: [Node.Group.Inline, Node.Group.Leaf]}`.
+        */
+        target?: Node.Query;
+        /**
+        Determines the position of this mark relative to other marks.
+        Should be a number between 0 and 100. Marks with lower rank
+        appear first in mark set arrays, and are rendered around
+        higher rank marks when rendered as an element. Ties are broken
+        by name. Defaults to 100.
+        */
+        rank?: number;
+        /**
+        Whether this mark should be active when the cursor is positioned
+        at its end (or at its start when that is also the start of the
+        parent node). Defaults to true.
+        */
+        inclusive?: boolean;
+        /**
+        Whether this mark can span across multiple nodes, or refers to
+        an individual node. Only spanning marks can be added to text.
+        Spanning marks with an element representation can be drawn as
+        elements containing multiple nodes, unless another, lower-ranked
+        mark requires the nodes to be wrapped separately. Defaults to
+        true for specs with an element representation, false
+        for specs with an attribute representation.
+        */
+        spanning?: boolean;
+        /**
+        Used by {@link Plot.Tag.split `Plot.Tag.split`} to determine
+        whether to keep this mark in the split-off tag. `atEnd` will
+        be true if the split happens at the end of the node's content.
+        */
+        keepOnSplit?: boolean | ((tag: Plot.Tag, atEnd: boolean) => boolean);
+        /**
+        Used by {@link Schema.withMarksFrom} to decide whether marks
+        of this type are preserved after the type change.
+        */
+        keepOnTypeChange?: boolean | ((from: Node.Tag, to: Node.Tag) => boolean);
+        /**
+        A default value for the parameter. If given, a mark with this
+        parameter will be stored in {@link Mark.Type.default
+        `Mark.Type.default`}.
+        */
+        defaultParam?: Param;
+        /**
+        A function or type name used to validate parameters of this
+        mark. See {@link Node.Spec.validate `Node.Spec.validate`}.
+        */
+        validate?: string | ((value: Param) => void);
+        /**
+        A mark parameter can be set-valued, which changes how adding
+        and removing marks of that type works. This requires the mark
+        parameter to be an array type. When adding a set-valued mark
+        to a mark set, the value of the mark in the new set is the
+        union of the values of its original value and the added mark.
+        Similarly, when removing such a mark, only the values in the
+        parameter of the removed mark are removed from the mark in the
+        set (except when there are none left, in which case the mark
+        is removed entirely).
+        
+        `compare` should be a function that compares two values and
+        returns 0 if they are the same, or an ordering number
+        otherwise. This is used to sort and compare the values.
+        */
+        set?: Param extends ReadonlyArray<infer Content> ? {
+            compare: (a: Content, b: Content) => number;
+        } : never;
+        /**
+        A mark can be either represented with a wrapping element, or
+        with one or more attributes added to the affected nodes.
+        */
+        shape: Shape.Element<Param> | Shape.Attribute<Param> | Shape.Attributes<Param>;
+        /**
+        A set of parse rules for this mark. The `mark` field for these
+        will automatically be defaulted to the mark type itself.
+        */
+        parseRules?: readonly parse.Rule<Param>[];
+    }
+    /**
+    A set of marks is a sorted array in which a given mark type can
+    occur at most once.
+    */
+    type Set = readonly Mark[];
+}
+
+/**
+A schema is a collection of node and mark types, including exactly
+one document type, plus an optional set of {@link Schema.Override
+overrides} that modify the relations between those elements. It
+determines what kind of elements may occur in documents that
+follow this schema, and where they can show up.
+*/
+declare class Schema {
+    /**
+    All the schema elements that make up this schema. Useful if you
+    want to base another schema on this one.
+    */
+    readonly elements: readonly Schema.Element[];
+    /**
+    The node types that are part of this schema.
+    */
+    readonly nodes: readonly Node.Type[];
+    /**
+    Mark types used in this schema.
+    */
+    readonly marks: readonly Mark.Type[];
+    private plotContent;
+    private markTarget;
+    private nodeGroup;
+    /**
+    The plot tag used by documents in this schema.
+    */
+    readonly docTag: Plot.Tag<null>;
+    /**
+    The {@link Node.Role.LineBreak line break} node defined in
+    this schema, if any.
+    */
+    readonly lineBreak: Leaf | null;
+    private nodesByName;
+    private marksByName;
+    private wrappingCache;
+    private validated;
+    private constructor();
+    /**
+    Create a document in this schema.
+    */
+    doc(children: readonly Node[]): Plot.Doc;
+    /**
+    Validate that a node and its content conform to this schema.
+    Will run automatically when creating a document.
+    */
+    validate(node: Node): void;
+    /**
+    Test whether the given mark or tag type is included in this
+    schema.
+    */
+    has(elt: Mark<any> | Mark.Type | Node.Type.Ref<any>): boolean;
+    /**
+    Test whether a node type matches the given {@link Node.Query
+    node query}.
+    */
+    matchNode(node: Node.Type, q: Node.Query): boolean;
+    /**
+    Test whether the given mark is allowed on the given node type.
+    */
+    markAllowed(mark: Mark.Type, node: Node.Type): boolean;
+    /**
+    Returns true if there's at least one node type in the schema
+    that may occur in both `a` and `b`.
+    */
+    sharesContent(a: Plot.Type, b: Plot.Type): boolean;
+    /**
+    Returns a copy of `to` with all the marks from `from` that it
+    doesn't already have, and that aren't dropped by the mark's
+    {@link Mark.Spec.keepOnTypeChange} configuration.
+    */
+    withMarksFrom<T extends Node.Tag>(from: Node.Tag, to: T): T;
+    /**
+    Check whether a given plot type can contain a given node type.
+    */
+    canContain(parent: Plot.Type, child: Node.Type): boolean;
+    /**
+    Return the first {@link Leaf.Type.default defaultable} node tag that
+    can occur as a child of `parent`.
+    */
+    defaultContentTag(parent: Plot.Type): Node.Tag | null;
+    /**
+    Return the first {@link Plot.Type.default defaultable} plot tag
+    that can be a child of `parent`.
+    */
+    defaultContentPlot(parent: Plot.Type): Plot.Tag | null;
+    /**
+    Create a node from a tag, optionally adding a default child if
+    this is a plot that cannot be empty.
+    */
+    createAndFill(parent: Node.Tag): Node;
+    /**
+    Find a set of tags that `child` must be wrapped in to be able to
+    occur in `parent`. Will return the empty array if it fits
+    directly, and `null` if it cannot occur at all.
+    */
+    findWrapping(parent: Plot.Type, child: Node.Type): readonly Plot.Tag[] | null;
+    private findWrappingInner;
+    /**
+    Get the mark type with the given name in this schema.
+    */
+    getMark(name: string): Mark.Type | undefined;
+    /**
+    Get the node type with the given name.
+    */
+    getNode(name: string): Node.Type | undefined;
+    /**
+    Define a schema from a set of schema elements. The set must
+    contain precisely one document type, and no conflicting node or
+    mark names.
+    */
+    static define(spec: readonly Schema.Element[]): Schema;
+    /**
+    Deserialize a node from its JSON representation.
+    */
+    nodeFromJSON(json: Node.JSON): Node;
+    /**
+    Deserialize a tag from its JSON representation.
+    */
+    tagFromJSON(json: Node.JSON): Leaf<unknown> | Plot.Tag<unknown>;
+    /**
+    Read a set of marks from their JSON representation.
+    */
+    marksFromJSON(json: Record<string, any>): Mark.Set;
+    /**
+    Read a document from JSON.
+    */
+    docFromJSON(json: Node.JSON): Plot.Doc;
+}
+declare namespace Schema {
+    /**
+    A schema element is any node tag or type, mark or mark type, or
+    override.
+    */
+    type Element = Node.Tag | Node.Type | Mark | Mark.Type | Schema.Override;
+    /**
+    Though nodes and marks are mostly self-contained, a few of their
+    aspects can be overridden per schema.
+    */
+    class Override {
+        private constructor();
+        /**
+        @hidden
+        */
+        tag: "schema.override";
+        /**
+        Create a schema override that changes the target nodes for a
+        mark.
+        */
+        static markTarget(mark: Mark.Type | Mark, target: Node.Query | ((target: Node.Query) => Node.Query)): Override;
+        /**
+        Create a schema override that changes the content specification
+        for a given node. Note that this can not change a node with
+        inline content to block content or vice versa.
+        */
+        static plotContent(plot: Plot.Type | Plot.Tag, content: Node.Query | ((content: Node.Query) => Node.Query)): Override;
+        /**
+        Override the set of groups that a node may be part of.
+        */
+        static nodeGroup(node: Node.Type | Node.Tag, group: Node.Group | readonly Node.Group[]): Override;
+    }
+}
+
+/**
+The type of tokens in a slice. A plot tag represents the point
+where a plot is opened, {@link Plot.End} the point where a plot is
+closed, and nodes just represent the insertion of that node.
+*/
+type Token = Node | Plot.Tag | typeof Plot.End;
+declare namespace Token {
+    /**
+    Tokens have a `tokenType` property holding oneof these values.
+    */
+    enum Type {
+        Open = 0,
+        Close = 1,
+        Node = 2
+    }
+}
+/**
+A slice represents a part of a document. It is used to represent
+inserted content in {@link ChangeSet change sets}, or things like
+clipboard content.
+*/
+declare class Slice {
+    readonly content: readonly Token[];
+    /**
+    The length of the slice's content.
+    */
+    readonly length: number;
+    private constructor();
+    /**
+    Create a slice.
+    */
+    static of(content: readonly Token[]): Slice;
+    /**
+    Compare a slice to another one.
+    */
+    eq(other: Slice): boolean;
+    /**
+    Create a sub-slice of this slice.
+    */
+    slice(from: number, to?: number): Slice;
+    /**
+    Concatenate this slice to another slice.
+    */
+    concat(other: Slice): Slice;
+    /**
+    Get the text content of the slice's tokens.
+    */
+    textContent(options?: {
+        blockSeparator?: string;
+        leafText?: string | ((node: Leaf) => string);
+    }): string;
+    /**
+    The empty slice.
+    */
+    static empty: Slice;
+    /**
+    Convert this slice to a JSON-serializeable representation.
+    */
+    toJSON(): Slice.JSON;
+    /**
+    Build a slice from its JSON representation.
+    */
+    static fromJSON(schema: Schema, json: Slice.JSON): Slice;
+}
+declare namespace Slice {
+    /**
+    A slice's JSON representation.
+    */
+    type JSON = readonly (Node.JSON | ".")[];
+}
+
+type _Node = Node;
+type _Plot = Plot;
+type _Doc = Plot.Doc;
+type _Tag = Plot.Tag;
+/**
+This class represents a {@link Plot.Doc.resolve resolved}
+position.
+*/
+declare class Pos {
+    /**
+    The plot that the position points into.
+    */
+    readonly parent: Pos.Plot;
+    /**
+    The position itself.
+    */
+    readonly pos: number;
+    /**
+    The index into its parent's content array. Note that if
+    `inText` is non-zero, this is the index of the text node.
+    */
+    readonly index: number;
+    /**
+    Text nodes don't count as parent plots. Rather, positions that
+    fall inside a text node have a non-zero value here that
+    provides the offset into the text node.
+    */
+    readonly inText: number;
+    private constructor();
+    /**
+    Find the innermost parent plot for which the given predicate
+    returns true.
+    */
+    matchingParent(pred: (plot: _Plot) => boolean): Pos.Plot | null;
+    /**
+    Move ahead through the document the given number of positions.
+    Don't descend into nodes that fall entirely within the skipped
+    range. If `walk` is given, call methods on it for each node
+    entered, skipped, or left. Return a new position at the end of
+    the range.
+    */
+    advance(distance: number, walk?: Pos.Walker): Pos;
+    /**
+    Move ahead through the document, always entering every plot. If
+    `walk` is given, call methods on it for each node or node
+    boundary passed. Return a new position.
+    */
+    walk(distance: number, walk: Pos.Walker): Pos;
+    /**
+    Get the node directly after this position. If `inText` is
+    non-zero, return only the part of the text node that's after the
+    position.
+    */
+    get nodeAfter(): Node | null;
+    /**
+    Get the node directly before this position. If `inText` is
+    non-zero, return only the part of the text node before the
+    position.
+    */
+    get nodeBefore(): Node | null;
+    /**
+    Get the nearest parent that is a {@link Plot.isTextblock
+    textblock}.
+    */
+    get textblockParent(): Pos.Plot | null;
+    /**
+    Get the depth of this position (the amount of plots that wrap
+    it, not counting the document).
+    */
+    get depth(): number;
+    /**
+    Get the parent plot at the given depth.
+    */
+    parentAt(depth: number): Pos.Plot;
+    /**
+    Returns true if this position is right at the start of the given
+    parent plot, or transitively at the start of its first child.
+    */
+    isAtStart(parent: Pos.Plot): boolean;
+    /**
+    Returns true if this position is right at the end of the given
+    parent plot, or transitively at the end of its last child.
+    */
+    isAtEnd(parent: Pos.Plot): boolean;
+    /**
+    Get the document that this position points into.
+    */
+    get doc(): Plot.Doc;
+    /**
+    Get the set of active inline marks at this position or, if
+    `across` is given, the marks that would apply to content
+    replacing the range between that `this` and `across`.
+    */
+    marks(across?: Pos): Mark.Set;
+}
+declare namespace Pos {
+    /**
+    Interface for the walker object that can be passed to {@link
+    Pos.advance `Pos.advance`} and {@link Pos.walk}.
+    */
+    interface Walker {
+        /**
+        Called when a node is skipped over. Will only be called for
+        leaves when using {@link Pos.walk}.
+        */
+        skip(node: _Node, pos: number, parent: Pos.Plot, index: number): void;
+        /**
+        Called when a plot is entered.
+        */
+        enterPlot(node: _Plot, pos: number, parent: Pos.Plot, index: number): void | boolean;
+        /**
+        Called when leaving a plot.
+        */
+        leavePlot(tag: _Tag, pos: number, parent: Pos.Plot, index: number): void;
+    }
+    /**
+    Represents the position of a node, with information about its
+    parent plots.
+    */
+    class Node {
+        /**
+        The node's direct parent.
+        */
+        readonly parent: Pos.Plot | null;
+        /**
+        The node object.
+        */
+        readonly node: _Node;
+        /**
+        The node's index in its parent plot.
+        */
+        readonly index: number;
+        /**
+        @hidden
+        */
+        protected constructor(
+        /**
+        The node's direct parent.
+        */
+        parent: Pos.Plot | null, 
+        /**
+        The node object.
+        */
+        node: _Node, 
+        /**
+        @internal
+        */
+        pos: number, 
+        /**
+        The node's index in its parent plot.
+        */
+        index: number);
+        /**
+        The position before the node. Will raise an error if this is
+        the document top node.
+        */
+        get before(): number;
+        /**
+        The position after the node. Throws if this is a document.
+        */
+        get after(): number;
+        /**
+        The depth of this node (the number of parent nodes, not
+        counting the document).
+        */
+        get depth(): number;
+        /**
+        The document that this position points into.
+        */
+        get doc(): _Doc;
+        /**
+        Returns true if this is either a document node or the first
+        node in its parent.
+        */
+        get isFirst(): boolean;
+        /**
+        Returns true if this is a document node or the last node in its parent.
+        */
+        get isLast(): boolean;
+        /**
+        The node before this one, if any.
+        */
+        get nextSibling(): Node | null;
+        /**
+        The node after this node, if any.
+        */
+        get previousSibling(): Node | null;
+    }
+    /**
+    Subclass of {@link Pos.Node} that points at a plot node.
+    */
+    class Plot extends Pos.Node {
+        node: _Plot;
+        private constructor();
+        /**
+        The position at the start of this plot's content.
+        */
+        get start(): number;
+        /**
+        The position at end of this plot's content.
+        */
+        get end(): number;
+    }
+}
+
+declare abstract class BaseType<Param> {
+    /**
+    The name of this node type.
+    */
+    readonly name: string;
+    /**
+    Test whether this node has the given role.
+    */
+    hasRole(role: Node.Role): boolean;
+    /**
+    True when this is an inline node type.
+    */
+    get isInline(): boolean;
+    /**
+    True when this is a block node type.
+    */
+    get isBlock(): boolean;
+    abstract isLeaf: boolean;
+    abstract isPlot: boolean;
+    /**
+    Whether this node is {@link Node.Spec.selectable selectable}.
+    */
+    get isSelectable(): boolean;
+}
+declare abstract class BaseTag<Param> {
+    readonly param: Param;
+    readonly marks: Mark.Set;
+    abstract type: Node.Type<Param>;
+    constructor(param: Param, marks: Mark.Set);
+    mark<Value>(mark: Mark.Type<Value>): Value | undefined;
+    get name(): string;
+    abstract eq(other: Node | Node.Tag): boolean;
+    abstract isLeaf: boolean;
+    abstract isPlot: boolean;
+    get isText(): boolean;
+    is<T>(type: Leaf.Type<T>): this is Leaf<T>;
+    is<T>(type: Plot.Type<T>): this is Plot.Tag<T>;
+    toJSON(): Node.JSON;
+}
+/**
+A node in the document is either a plot (which may have content)
+or a leaf node.
+*/
+type Node = Plot | Leaf;
+declare namespace Node {
+    /**
+    The interface shared by both {@link Leaf} and {@link Plot}.
+    */
+    interface Shared {
+        /**
+        The name of this node's type.
+        */
+        name: string;
+        /**
+        The node's {@link Node.Tag tag}. For leaves, this is the leaf
+        itself, for plots, the {@link Plot.Tag plot tag}.
+        */
+        tag: Node.Tag;
+        /**
+        The length of this node. For a plot, this is its {@link
+        Plot.contentLength} plus 2 (for the open and close tokens),
+        for leaves this is 1, except for text leaves, where it is the
+        length of the text.
+        */
+        length: number;
+        /**
+        The set of marks for this node.
+        */
+        marks: Mark.Set;
+        /**
+        Get the value of the given mark for this node, if any.
+        */
+        mark<Value>(mark: Mark.Type<Value>): Value | undefined;
+        /**
+        Compare this node to another node.
+        */
+        eq(other: Node): boolean;
+        /**
+        Create a copy of this node with the given set of marks instead
+        of its current mark set.
+        */
+        withMarks(marks: Mark.Set): Node;
+        /**
+        True when this is a leaf node. TypeScript will automatically
+        narrow from {@link Node} to {@link Leaf} after you check this.
+        */
+        isLeaf: boolean;
+        /**
+        Tests whether this is a {@link Leaf.Text text leaf}.
+        */
+        isText: boolean;
+        /**
+        True when this is a {@link Plot}.
+        */
+        isPlot: boolean;
+        /**
+        Convert this node to its JSON-serializeable representation.
+        */
+        toJSON(): Node.JSON;
+    }
+    /**
+    A node type can be either a leaf type or a plot type.
+    */
+    type Type<T = unknown> = Leaf.Type<T> | Plot.Type<T>;
+    namespace Type {
+        /**
+        Used as input type by some functions acting on node types, so
+        that you can pass either a bare type or a singleton leaf or
+        plot tag.
+        */
+        type Ref<T> = Plot.Type<T> | Leaf.Type<T> | Plot.Tag<T> | Leaf<T>;
+        /**
+        Get the type referred to by a {@link Node.Type.Ref reference}.
+        */
+        function get<T>(ref: Ref<T>): Node.Type<T>;
+    }
+    /**
+    A tag is a node type with a parameter and a set of marks. For
+    leaves, the entire node is the tag. For plots, it is a separate
+    object in the {@link Plot.tag `tag` property}.
+    */
+    type Tag = Leaf | Plot.Tag;
+    namespace Tag {
+        /**
+        The interface shared by {@link Leaf leaves} and {@link
+        Plot.Tag plot tags}.
+        */
+        interface Shared<Param> {
+            /**
+            The type of the tag.
+            */
+            type: Node.Type<Param>;
+            /**
+            The tag parameter. Will be `null` for parameter-less types.
+            */
+            param: Param;
+            /**
+            The set of marks for this tag.
+            */
+            marks: Mark.Set;
+            /**
+            The name of the tag's type.
+            */
+            name: string;
+            /**
+            Find the value of the given given make type in this tag's
+            set of marks, or return `undefined` if it isn't present.
+            */
+            mark<Value>(mark: Mark.Type<Value>): Value | undefined;
+            /**
+            Compare this tag to another tag.
+            */
+            eq(other: Node.Tag): boolean;
+            /**
+            Test whether this is a leaf.
+            */
+            isLeaf: boolean;
+            /**
+            Test whether this is a plot tag.
+            */
+            isPlot: boolean;
+            /**
+            Test whether this tag is of the given type.
+            */
+            is<T>(type: Leaf.Type<T>): this is Leaf<T>;
+            is<T>(type: Plot.Type<T>): this is Plot.Tag<T>;
+            /**
+            Holds `true` when this is a text leaf.
+            */
+            isText: boolean;
+            /**
+            Convert this tag to a JSON-serializeable object.
+            */
+            toJSON(): Node.JSON;
+        }
+        /**
+        Deduce a tag type for a given node type or tag.
+        */
+        type For<Type extends Node.Type.Ref<any>> = Type extends Leaf.Type<infer T> ? Leaf<T> : Type extends Plot.Type<infer T> ? Plot.Tag<T> : Type;
+    }
+    /**
+    Shared fields between {@link Leaf.Spec} and {@link Plot.Spec}.
+    */
+    interface Spec<Param> {
+        /**
+        Whether this node is an inline or a block node. Defaults to
+        block.
+        */
+        inline?: boolean;
+        /**
+        The default parameter value for the node type. Only meaningful
+        when the type is being defined directly, rather than as a
+        singleton tag.
+        */
+        defaultParam?: Param;
+        /**
+        A function or type name used to validate this tag's parameter
+        value. This will be used when deserializing the attribute from
+        JSON. When a string, it should be a `|`-separated string of
+        primitive types (`"number"`, `"string"`, `"boolean"`, `"null"`,
+        and `"undefined"`). The library will raise an error when the
+        value is not one of those types. When a function, it should
+        raise an error if the value doesn't have the expected type or
+        shape.
+        */
+        validate?: string | ((param: Param) => void);
+        /**
+        Assign one or more groups to this node type. Groups are used
+        when specifying allowed content for a plot. Schema overrides
+        can {@link Schema.Override.nodeGroup change} a node's set of
+        groups.
+        */
+        group?: Group | readonly Group[];
+        /**
+        Roles to add to this node type, which mark it as having a
+        certain semantic role, such as being a list.
+        */
+        role?: Node.Role | readonly Node.Role[];
+        /**
+        The default DOM/HTML shape of this node. This will determine
+        what the node looks like, both in an editor an in serialized
+        HTML form. In most cases, this also specifies the way the node
+        is parsed when reading HTML content.
+        */
+        shape: Shape.Element<Param> | Shape.Structure<Param>;
+        /**
+        Extra parse rules to associate with this node type.
+        */
+        parseRules?: readonly parse.Rule.Element<Param>[];
+        /**
+        When set to `true`, nodes of this type, if they are a leaf or
+        atom, can be selected by clicking them or moving the selection
+        into them with the keyboard.
+        */
+        selectable?: boolean;
+    }
+    /**
+    The JSON representation for a node or tag.
+    */
+    interface JSON {
+        type: string;
+        param?: any;
+        marks?: {
+            [name: string]: any;
+        };
+        content?: readonly Node.JSON[];
+    }
+    /**
+    Groups are used to specify parent-child relationships between
+    nodes, and valid targets for marks. You can use predefined
+    groups provided as static properties on the class, or define
+    your own for custom categories.
+    */
+    class Group {
+        /**
+        Groups may have a parent group. Membership of a group
+        implies membership of its parent groups.
+        */
+        readonly parent: Group | undefined;
+        private tag;
+        private constructor();
+        /**
+        Define a custom node group.
+        */
+        static define(parent?: Group): Group;
+        /**
+        A group that contains every node type.
+        */
+        static All: Group;
+        /**
+        All inline nodes are automatically assigned to this group.
+        */
+        static Inline: Group;
+        /**
+        Block elements automatically get assigned to this group.
+        */
+        static Block: Group;
+        /**
+        The group of all leaf nodes.
+        */
+        static Leaf: Group;
+        /**
+        The group of all non-leaf nodes.
+        */
+        static Plot: Group;
+        /**
+        Block plots with inline content are tagged as textblocks.
+        */
+        static Textblock: Group;
+        /**
+        A group used for generic block content, such as paragraphs and
+        lists. The basic schema uses this as the content type for the
+        top level document, blockquotes, and list items.
+        */
+        static Content: Group;
+        /**
+        Group for the cell nodes in tables.
+        */
+        static TableCell: Group;
+        /**
+        Generic list item group.
+        */
+        static ListItem: Group;
+    }
+    /**
+    Describes a set of node types. Can be either a single tag or
+    type, which matches exactly that type (tags are assumed to be
+    singleton tags—only their type is used), a reference to a {@link
+    Node.Group node group}, or a combination of multiple of those.
+    An array indicates the union of all the groups in the array
+    (matches types that match any of the queries). An object with an
+    `and` property indicates an intersection (must match all the
+    queries).
+    */
+    type Query = Node.Tag | Node.Type | Group | readonly Node.Query[] | {
+        and: readonly Node.Query[];
+    };
+    /**
+    Roles are used to add some semantic information to node types.
+    You can define your own, and use the `hasRole` method to check
+    whether a given node has the role attached.
+    */
+    class Role {
+        private constructor();
+        /**
+        Define a new role.
+        */
+        static define(): Role;
+        /**
+        This role indicates that a plot contains code, and makes some
+        commands behave differently inside such a plot.
+        */
+        static Code: Role;
+        /**
+        Identifies a plot as a list container. This makes some
+        commands treat the plot specially.
+        */
+        static List: Role;
+        /**
+        A single leaf type in a schema may have the `LineBreak` role,
+        which identifies it as the canonical node that represents a
+        line break. Nodes marked as line breaks will be parsed from
+        and serialized to newline characters inside {@link
+        Plot.Spec.preserveWhitespace whitespace-preserving} nodes.
+        */
+        static LineBreak: Role;
+    }
+}
+/**
+A leaf node, which is a node with no content nodes. Used for
+things like text, images, line breaks, and so on. Counts as a
+{@link Node.Tag}.
+*/
+declare class Leaf<Param = unknown> extends BaseTag<Param> implements Node.Shared, Node.Tag.Shared<Param> {
+    /**
+    This leaf's type.
+    */
+    readonly type: Leaf.Type<Param>;
+    private constructor();
+    get tag(): this;
+    eq(other: Node | Node.Tag): boolean;
+    /**
+    Define a singleton leaf type, without parameter. If you need to
+    store a parameter value in each leaf of the type, use {@link
+    Leaf.Type.define} instead.
+    */
+    static define(name: string, spec: Leaf.Spec<null>): Leaf<null>;
+    withMarks(marks: Mark.Set): Leaf<Param>;
+    /**
+    In {@link Slice slices}, leaf nodes count as node {@link Token
+    tokens}.
+    */
+    get tokenType(): Token.Type.Node;
+    get isLeaf(): true;
+    get isPlot(): false;
+    get length(): number;
+    /**
+    Create a text node with the given text and mark set.
+    */
+    static text(text: string, marks?: Mark.Set): Leaf<string>;
+}
+declare namespace Leaf {
+    /**
+    Node type for leaves.
+    */
+    class Type<Param = unknown> extends BaseType<Param> {
+        /**
+        A default leaf for this type. Available if the leaf was
+        defined with {@link Leaf.define}, or a {@link
+        Node.Spec.defaultParam} was given.
+        */
+        default: Leaf<Param> | null;
+        /**
+        The spec used to define this type. Its type parameter is
+        cleared to avoid this field making the class invariant (in the
+        type system sense), which would prevent `Leaf.Type<unknown>`
+        from being a supertype of specific leaf types.
+        */
+        readonly spec: Leaf.Spec<any>;
+        private constructor();
+        /**
+        Define a new leaf type.
+        */
+        static define<T>(name: string, spec: Leaf.Spec<T>): Type<T>;
+        /**
+        Create a leaf with this type.
+        */
+        of(param: Param, marks?: Mark.Set): Leaf<Param>;
+        /**
+        Used to narrow {@link Node.Type} values to {@link Leaf}.
+        */
+        get isLeaf(): true;
+        /**
+        Leaves are not plots.
+        */
+        get isPlot(): false;
+    }
+    interface Spec<Param> extends Node.Spec<Param> {
+        /**
+        Can be used to make leaves of this type show up in the output
+        of {@link Plot.textContent}.
+        */
+        toText?: (node: Leaf) => string;
+    }
+    /**
+    The type of text leaves. Represents a series of characters with
+    a given set of marks. The only leaf with a length that isn't
+    always 1. Adjacent text leaves with the same marks are merged
+    automatically.
+    */
+    const Text: Leaf.Type<string>;
+}
+/**
+Plots delimit parts of the document, giving a special meaning to
+the nodes inside them. They are defined by a {@link Plot.Tag tag}
+and an array of {@link Plot.content content}.
+*/
+declare class Plot implements Node.Shared {
+    /**
+    The tag that identifies this plot.
+    */
+    readonly tag: Plot.Tag;
+    /**
+    The nodes in this plot.
+    */
+    readonly content: readonly Node[];
+    /**
+    The sum of the length of this plot's content nodes.
+    */
+    contentLength: number;
+    get name(): string;
+    /**
+    The type of this plot's tag.
+    */
+    get type(): Plot.Type<unknown>;
+    get marks(): Mark.Set;
+    get length(): number;
+    eq(other: Node): boolean;
+    /**
+    Compare the content of this plot to the content of the given
+    plot.
+    */
+    contentEq(other: Plot): boolean;
+    /**
+    @hidden
+    */
+    is<T>(type: Leaf.Type<T>): false;
+    get isText(): false;
+    /**
+    Tells you whether the content of this plot is inline.
+    */
+    get inlineContent(): boolean;
+    /**
+    True if this is a block node with inline content.
+    */
+    get isTextblock(): boolean;
+    get isLeaf(): false;
+    get isPlot(): true;
+    /**
+    True if this is a document node.
+    */
+    get isDoc(): boolean;
+    /**
+    Get the plot's first child, if any.
+    */
+    get firstChild(): Node | null;
+    /**
+    Get the plot's first child.
+    */
+    get lastChild(): Node | null;
+    /**
+    Iterate though the given range (or the entire document, when
+    given only one argument), and call the given function on every
+    node that overlaps the given range, outer nodes before inner
+    nodes. When the function returns `false` for a node, descendents
+    of that node are not iterated.
+    */
+    iterate(from: number, to: number, f: (node: Node, pos: number, parent: Plot | null, index: number) => boolean | void): void;
+    iterate(f: (node: Node, pos: number, parent: Plot | null, index: number) => boolean | void): void;
+    /**
+    Return the node that starts at the given offset from this node's
+    content start, if any. Will not return text nodes.
+    */
+    nodeAt(pos: number): Node | null;
+    /**
+    Return the plot at the given offset, if any.
+    */
+    plotAt(pos: number): Plot | null;
+    /**
+    Return the text content of this plot.
+    */
+    textContent(options?: {
+        /**
+        An optional start position, as an offset from the plot's
+        content start.
+        */
+        from?: number;
+        /**
+        An optional end position.
+        */
+        to?: number;
+        /**
+        Text to separate blocks with. Defaults to a single newline
+        character.
+        */
+        blockSeparator?: string;
+        /**
+        Override the way non-text leaves are converted to string.
+        */
+        leafText?: string | ((node: Leaf) => string);
+    }): string;
+    toJSON(): Node.JSON;
+    mark<Value>(mark: Mark.Type<Value>): Value | undefined;
+    withMarks(marks: Mark.Set): Plot;
+    /**
+    Plot nodes count as node {@link Token tokens} in a {@link
+    Slice}.
+    */
+    get tokenType(): Token.Type.Node;
+    /**
+    Define a singleton plot type. If the plot needs a parameter
+    value, use {@link Plot.Type.define} instead.
+    */
+    static define(name: string, spec: Plot.Spec<null>): Plot.Tag<null>;
+    /**
+    Define a document plot type. Exactly one of these must occur in a schema.
+    */
+    static defineDoc(spec: {
+        inlineContent?: Node.Query | true;
+        blockContent?: Node.Query;
+        canBeEmpty?: boolean;
+    }): Plot.Type<null>;
+}
+declare namespace Plot {
+    /**
+    The end token for a plot. Used in {@link Slice slices}.
+    */
+    const End: {
+        tokenType: Token.Type.Close;
+    };
+    /**
+    A plot tag holds the type of the plot, its parameter (if any),
+    and a set of marks.
+    */
+    class Tag<Param = unknown> extends BaseTag<Param> implements Node.Tag.Shared<Param> {
+        readonly type: Plot.Type<Param>;
+        private constructor();
+        eq(other: Node | Node.Tag): boolean;
+        /**
+        Create a plot with this tag and the given content.
+        */
+        create(content?: readonly Node[]): Plot;
+        /**
+        Create a copy of this tag with the given marks.
+        */
+        withMarks(marks: Mark.Set): Tag<Param>;
+        /**
+        Return a tag that represents content split off from the plot
+        with this tag. Will respect the {@link Mark.Spec.keepOnSplit}
+        mark property. `atEnd` should be set to true if the split
+        happens at the end of the plot's content.
+        */
+        split(atEnd: boolean): Tag<Param>;
+        /**
+        A plot tag counts as an open {@link Token token} in a {@link
+        Slice slice}.
+        */
+        get tokenType(): Token.Type.Open;
+        /**
+        True when this plot type contains inline content.
+        */
+        get inlineContent(): boolean;
+        /**
+        True when this is a block plot with inline content.
+        */
+        get isTextblock(): boolean;
+        get isLeaf(): false;
+        get isPlot(): true;
+        /**
+        Test whether this is a document plot.
+        */
+        get isDoc(): boolean;
+    }
+    /**
+    A type of {@link Plot plot}.
+    */
+    class Type<Param = unknown> extends BaseType<Param> {
+        /**
+        A default tag for this plot type.
+        */
+        readonly default: Plot.Tag<Param> | null;
+        /**
+        Whether the {@link Plot.Spec.isolating} flag is set on this
+        plot type.
+        */
+        readonly isolating: boolean;
+        /**
+        The plot's {@link Plot.Spec.defining} flag.
+        */
+        readonly defining: boolean;
+        /**
+        The plot's {@link Plot.Spec.neutral} flag.
+        */
+        readonly neutral: boolean;
+        /**
+        Whether whitespace should be preserved inside this plot.
+        */
+        readonly preserveWhitespace: boolean;
+        /**
+        The orientation of the content of the plot. Will be `"row"`
+        for plots with inline content, and defaults to `"column"` for
+        plots with block content unless explicitly {@link
+        Plot.Spec.orientation set}.
+        */
+        readonly orientation: "row" | "column";
+        /**
+        The spec used to define this plot type.
+        */
+        readonly spec: Plot.Spec<any>;
+        private constructor();
+        /**
+        Define a plot type.
+        */
+        static define<T>(name: string, spec: Plot.Spec<T>): Type<T>;
+        /**
+        Create a plot tag of this type with the given parameter and
+        mark set.
+        */
+        of(param: Param, marks?: Mark.Set): Tag<Param>;
+        /**
+        Tells you whether this plot type has inline content.
+        */
+        get inlineContent(): boolean;
+        /**
+        True if this is a block plot with inline content.
+        */
+        get isTextblock(): boolean;
+        /**
+        True if this is a document plot type.
+        */
+        get isDoc(): boolean;
+        /**
+        Tells you that this is not a leaf type.
+        */
+        get isLeaf(): false;
+        /**
+        This is a plot type. Can be used to narrow `Node.Type` to
+        `Plot.Type`.
+        */
+        get isPlot(): true;
+        /**
+        Tells you whether this plot type is allowed {@link
+        Plot.Spec.canBeEmpty to be empty}.
+        */
+        get canBeEmpty(): boolean;
+    }
+    /**
+    Object used to define a plot type.
+    */
+    interface Spec<Param> extends Node.Spec<Param> {
+        /**
+        When this node has block-level content, provide a query
+        matching the nodes it may contain here. You generally don't
+        want to use `Node.Group.Block` here, since specialized block
+        types (like table cells or list items) should probably only be
+        allowed in their designated parent plots.
+        */
+        blockContent?: Node.Query;
+        /**
+        When this node has inline content, provide a query specifying
+        valid content. If set to `true`, any inline node may appear in
+        this node.
+        */
+        inlineContent?: Node.Query | true;
+        /**
+        Plots with block content, by default, require at least one
+        child. You can set this to true to allow them to be empty.
+        Plots with inlne content can always be empty.
+        */
+        canBeEmpty?: boolean;
+        /**
+        Whether the sides of this plot act as a 'barrier' when {@link
+        state.GardSelection.nextNormalCursor normalizing} a cursor
+        position, which means that a separate cursor position exists
+        at its boundary. By default, nodes that are {@link
+        Plot.Spec.isolating isolating}, {@link
+        Plot.Spec.preserveWhitespace whitespace-preserving}, or both
+        a {@link Leaf leaf} and a block count as barriers.
+        */
+        cursorBarrier?: boolean;
+        /**
+        Indicates that this type of block is the default generic block
+        type in parent nodes where it may occur (which is appropriate
+        for, for example, paragraphs tags). Default blocks should not
+        have a required param. When not specified, the configuration
+        precedence order determines which child type is the default.
+        */
+        defaultBlock?: boolean;
+        /**
+        Controls whether whitespace inside this type of node should be
+        preserved. Disables whitespace collapsing and the replacement
+        of newlines with line break nodes in the parser and
+        serializer. Defaults to false, unless the node has the {@link
+        Node.Role.Code} role.
+        */
+        preserveWhitespace?: boolean;
+        /**
+        Isolating plots disallow some kinds of editing across their
+        borders (such as backspacing or unwrapping). A table cell is
+        an example of a node that you'd use this for.
+        */
+        isolating?: boolean;
+        /**
+        Block containers are, by default, assumed to arrange their
+        children vertically below each other (`"column"`). You can set this
+        to `"row"` to tell the editor that this container's children
+        are horizontally next to each other.
+        */
+        orientation?: "row" | "column";
+        /**
+        Defining nodes are preserved (when possible) when their content
+        is duplicated (dragged, pasted, etc) into a new position.
+        Defaults to false.
+        */
+        defining?: boolean;
+        /**
+        Neutral nodes may be completely replaced when their entire
+        content gets replaced. Defaults to `!`{@link
+        Plot.Spec.defining}.
+        */
+        neutral?: boolean;
+        /**
+        Whether block nodes of this type should be automatically
+        joined when they become adjacent through an edit. Defaults to
+        false. Note that editing commands need to explicitly call
+        {@link command.autoJoinBlocks} for joining to happen.
+        */
+        autoJoin?: boolean | ((before: Plot.Tag, after: Plot.Tag) => boolean);
+        /**
+        By default, splitting a textblock at the end will revert the new
+        block to the default type of textblock at that position. Setting
+        this to true on a textblock type will prevent that behavior.
+        */
+        preserveOnSplitAtEnd?: boolean;
+        /**
+        For inline nodes with inline content, this determines whether
+        there are normalized cursor positions directly inside the node.
+        The default is to only have cursor positions right outside the
+        node.
+        */
+        cursorInsideBounds?: boolean;
+    }
+    /**
+    Document plots are used as the top level plot in a document.
+    They offer some additional methods and, unlike normal plots,
+    their {@link Plot.Doc.length `length` property} reports only the
+    length of their content, without counting open/close tokens
+    (because those are not part of the document).
+    */
+    class Doc extends Plot {
+        /**
+        The document's schema.
+        */
+        readonly schema: Schema;
+        private constructor();
+        /**
+        The length of the document's content.
+        */
+        get length(): number;
+        /**
+        Resolve the given position in the document, returning an
+        object describing its context.
+        */
+        resolve(pos: number): Pos;
+        /**
+        Resolve the node at the given position, providing information
+        about its context.
+        */
+        resolveNode(pos: number): Pos.Node | null;
+        /**
+        Like {@link Plot.Doc.resolveNode}, but only resolves plot
+        nodes.
+        */
+        resolvePlot(pos: number): Pos.Plot | null;
+        /**
+        Get the context stack (the array of wrapping plot tags,
+        inner-to-outer) at the given position.
+        */
+        contextAt(pos: number, maxDepth?: number): readonly Plot.Tag[];
+        /**
+        Create a slice of the content between `from` and `to`.
+        */
+        slice(from: number, to?: number): Slice;
+    }
+}
+
+/**
+Exception type used for errors related to schema definition.
+*/
+declare class SchemaError extends Error {
+}
+/**
+Exception type used when validating content against a schema, when
+checking JSON input, or when validating change sets.
+*/
+declare class ValidationError extends Error {
+}
+
+type Modification = {
+    add: Mark;
+} | {
+    remove: Mark;
+};
+/**
+A change set contains a series of changes to a given document that
+produce a new document. They divide the document in a number of
+sections that are either kept as-is, have marks added or removed,
+or are replaced entirely by a {@link Slice} of new tokens.
+
+Change sets store the length of their start document and will
+raise an error if you try to apply them to a document with a
+different length.
+*/
+declare class ChangeSet {
+    /**
+    Pairs of integers, with the first one representing the length
+    of the section in the start document, the second either -1 for
+    a preserved, -2 for a marked range, or a non-negative
+    insertion length for a replacement.
+    */
+    readonly sections: ChangeSet.Sections;
+    private _length;
+    private _newLength;
+    private constructor();
+    /**
+    The length of the start document.
+    */
+    get length(): number;
+    /**
+    The length of the updated document.
+    */
+    get newLength(): number;
+    /**
+    Returns true if this set makes no changes.
+    */
+    get empty(): boolean;
+    /**
+    Compare this change set to another one.
+    */
+    eq(other: ChangeSet): boolean;
+    /**
+    Apply the changes to the given document, producing a new
+    document. Will raise an error if the document length doesn't
+    match or the change is not well-formed for this document.
+    
+    The result of this method is cached, so applying the same change
+    set to the same document multiple times is cheap.
+    */
+    apply(doc: Plot.Doc): Plot.Doc;
+    /**
+    Convert this change set to a JSON-serializeable representation.
+    */
+    toJSON(): ChangeSet.JSON;
+    /**
+    Parse a JSON representation into a change set.
+    */
+    static fromJSON(schema: Schema, json: ChangeSet.JSON): ChangeSet;
+    /**
+    Perform an [operational
+    transformation](https://en.wikipedia.org/wiki/Operational_transformation)
+    on this change and the given other change. Both changes should
+    start with the given document `doc`. Returns a modified version
+    of the change that can be applied _after_ the other change has
+    been applied to `doc`.
+    
+    By default, the semantics of conflicting changes are resolved as
+    if `this` came after `other`. That means content inserted in the
+    same position by both will put the content inserted by `this`
+    last. You can set `before` to true to invert this, making `this`
+    come before `other`. Setting this correctly is necessary to make
+    the result of independently applied transformed changes converge.
+    */
+    transform(doc: Plot.Doc, other: ChangeSet, before?: boolean): ChangeSet;
+    /**
+    Compose two change sets, where `other` starts from the document
+    produced by `this`, into a single change set.
+    */
+    compose(other: ChangeSet): ChangeSet;
+    /**
+    Compute the inverse of this change set. `doc` is the document
+    that the change starts from. For a given change `A`,
+    `doc.apply(A).apply(A.invert(doc))` equals `doc`.
+    */
+    invert(doc: Plot.Doc): ChangeSet;
+    /**
+    Returns the change itself if it can be applied to this document
+    and produce a valid new document, or a modified version of the
+    change that _is_ correct.
+    */
+    correct(doc: Plot.Doc, local?: boolean): ChangeSet;
+    /**
+    Map a document position through this change, returning either
+    the adjusted position, or `null` if a the tracked position is
+    deleted.
+    
+    The `assoc` parameter, which defaults to `-1`, decides to which
+    side the position sticks. When content is inserted precisely at
+    the mapped position, it will stay before it when `assoc == -1`,
+    and move after it when `assoc == 1`.
+    
+    By default, mapping will always return a new position, even if
+    all the content around the position was deleted. You can pass a
+    {@link ChangeSet.TrackMode tracking mode} to make it return null
+    when either the token before, the token after, or both tokens
+    around the position were deleted.
+    */
+    mapPos(pos: number, assoc?: -1 | 1): number;
+    mapPos(pos: number, assoc: -1 | 1, track?: ChangeSet.TrackMode): number | null;
+    /**
+    Scan through the content inserted by this change until a tag
+    that matches the predicate is found. If successful, return the
+    position (in the new document) of the tag. This can be useful
+    for when creating a new selection after a fitted change.
+    */
+    findInserted(pred: (tag: Node.Tag) => boolean): number | null;
+    /**
+    Returns true if any of the replaced ranges in this change set
+    overlaps or is adjacent to the given range.
+    */
+    touchesRange(from: number, to: number): boolean | "cover";
+    /**
+    Iterate over the ranges in this changeset, calling `replaced`
+    for ranges that have been replaced, and `preserved` for ranges
+    that are either preserved as-is (when `modifications` is null)
+    or only have marks modified.
+    */
+    iterChanges(replaced: (fromA: number, toA: number, fromB: number, toB: number, inserted: Slice) => void, preserved?: (fromA: number, toA: number, fromB: number, toB: number, modifications: readonly Modification[] | null) => void): void;
+    /**
+    Iterate over the sections of the document this change leaves
+    unchanged or which have only mark changes. `posA` provides the
+    position of the range in the original document, `posB` the
+    position in the changed document.
+    */
+    iterGaps(gap: (fromA: number, toA: number, fromB: number, toB: number) => void, change?: (fromA: number, toA: number, fromB: number, toB: number) => void): void;
+    /**
+    Iterate over the ranges changed (either replaced or modified) by
+    this change desc. Joins adjacent changed ranges together.
+    */
+    iterChangedRanges(range: (fromA: number, toA: number, fromB: number, toB: number) => void): void;
+    /**
+    Add skipped sections before and after this change set, so that
+    it can apply to a larger document. Mostly useful when
+    propagating changes from an editor displaying a smaller part of
+    a document into the full document.
+    */
+    pad(before: number, after: number): ChangeSet;
+    /**
+    Clip the set to only a sub-region. This can fail, if there are
+    replacements across the region's sides, in which case the
+    method returns null
+    */
+    clip(from: number, to: number): ChangeSet | null;
+    /**
+    Create a change set. All positions in the given change
+    description refer to positions in the starting document.
+    */
+    static create(doc: Plot.Doc, spec: ChangeSet.Spec): ChangeSet;
+    /**
+    Returns an empty change set for a document of the given length.
+    */
+    static empty(length: number): ChangeSet;
+    /**
+    Transform two change set starting from the same document over
+    each other, returning two transformed change sets. The returned
+    `a` can be applied after the `b` passed in, and the returned `b`
+    can be applied after the `a` passed in, resulting the same final
+    document on both sides. `a` is taken to happen before `b` when insertions
+    at the same position need to be merged.
+    
+    This method is slightly more efficient than transforming both steps
+    separately.
+    */
+    static transform(doc: Plot.Doc, a: ChangeSet, b: ChangeSet): {
+        a: ChangeSet;
+        b: ChangeSet;
+    };
+}
+declare namespace ChangeSet {
+    /**
+    Representation of a single document change, as used in {@link
+    ChangeSet.Spec}. Changes can either affect marks (when `add` or
+    `remove` is present), or replace a part of the document
+    (otherwise).
+    */
+    type Change = {
+        /**
+        The start position of the change.
+        */
+        from: number;
+        /**
+        The end position. When not given, this defaults to `from` for
+        replacement changes, and `from + 1` for changes that add or
+        remove marks.
+        */
+        to?: number;
+        /**
+        Replace the given range with this slice.
+        */
+        insert?: Slice | readonly Token[];
+        /**
+        For deletions or insertions where it isn't obvious that the
+        replacement will produce a valid document, set this to `true`
+        or a stack of context tags to make the library process the
+        replacement to make sure it fits. Context tags (passed with
+        the innermost tag first, as in {@link Plot.Doc.contextAt} may
+        be used as wrappers when fitting the slice.
+        */
+        fit?: boolean | readonly Plot.Tag[];
+        /**
+        Add the given mark to this change's range. Cannot be combined
+        with `insert`.
+        */
+        add?: Mark;
+        /**
+        Remove the given mark from this range.
+        */
+        remove?: Mark;
+    };
+    /**
+    This type is used to describe a {@link ChangeSet.create change
+    set}. A spec can be a single change, an existing change set, a
+    set of changes wrapped in a correction scope, or an array of the
+    same.
+    
+    The {@link ChangeSet.Change.from `from`} and {@link
+    ChangeSet.Change.to `to`} positions in the changes in a set spec
+    all refer to the origin document. It is not necessary to
+    'compensate' for earlier changes in those specified later. If,
+    for some reason, you have changes that should be applied after
+    each other, create multiple change sets and {@link
+    ChangeSet.compose compose} them.
+    
+    By default, the provider of changes vouches for their
+    correctness. It is possible to create change sets that will
+    error when you try to apply them, because applying them does not
+    create a well formed document.
+    
+    When making changes where you cannot guarantee that they fit,
+    you should either use {@link ChangeSet.Change.fit}, which will
+    try to change the range of a change to make it fit, or the
+    `{correct}` form, which will combine the changes it is given,
+    and then process them as a whole to make sure they produce a
+    valid document. The `local` flag indicates that the effect of
+    changes should be kept as narrow as possible—for example, that
+    nodes opened but not closed by them should not extend to cover
+    content after the change.
+    */
+    type Spec = ChangeSet.Change | {
+        correct: ChangeSet.Spec;
+        local?: boolean;
+    } | ChangeSet | readonly ChangeSet.Spec[];
+    /**
+    The sections in a change set are represented as an array, with
+    each pair of two numbers describing a changed section. The first
+    number is the length of the section in the old document. The
+    second number is `-1` for unchanged sections, `-2` for updated
+    sections, and a non-negative number (the length of the inserted
+    content) for replacements.
+    */
+    type Sections = readonly number[];
+    /**
+    The JSON representation of a change set.
+    */
+    type JSON = readonly (number | [number, Slice.JSON | readonly ModificationJSON[]])[];
+    /**
+    Modes available in {@link ChangeSet.mapPos} to control whether
+    `null` is returned on nearby deletions.
+    */
+    type TrackMode = "before" | "after" | "around";
+}
+type ModificationJSON = {
+    add: string;
+    value: any;
+} | {
+    remove: string;
+    value: any;
+};
+
+/**
+Serialize a document to an array of {@link Elt elements} and
+strings. These can be converted to a DOM structure with {@link
+Elt.Fragment.toDOM} or an HTML string with {@link
+Elt.Fragment.toHTML}. Will use the shapes specified in the {@link
+Node.Spec.shape node specs}, unless {@link
+serialize.Options.override overridden}.
+*/
+declare function serialize(doc: Plot.Doc, options?: serialize.Options): Elt.Fragment;
+declare namespace serialize {
+    /**
+    The options passed to serializer functions.
+    */
+    interface Options {
+        /**
+        Set this to true to replace nodes with the {@link
+        Node.Role.LineBreak `LineBreak`} role with newline characters.
+        */
+        emitNewlines?: boolean;
+        /**
+        Override the shape used for some tags. Return null to fall
+        back to the node's default shape.
+        */
+        override?: (tag: Node.Tag) => Elt | null;
+    }
+    /**
+    Serialize a single node.
+    */
+    function node(node: Node, options: serialize.Options): Elt | string;
+    /**
+    Serialize a slice.
+    */
+    function slice(slice: Slice, options: slice.Options): Elt.Fragment;
+    namespace slice {
+        /**
+        Options passed to {@link serialize.slice}.
+        */
+        interface Options extends serialize.Options {
+            /**
+            If given, the serializer will set this attribute to
+            `"start"`, `"end"`, or `"start end"` for nodes that are open
+            at the start and/or end of the slice.
+            */
+            openAttr?: string;
+            /**
+            The slice's context. Will be used to determine the type of
+            open nodes at the start of the slice.
+            */
+            context?: readonly Plot.Tag[];
+            /**
+            The amount of context nodes to include in the output.
+            Defaults to 0, meaning only use those that are open at the
+            start of the slice.
+            */
+            includeContext?: number;
+        }
+    }
+}
+
+export { Attributes, ChangeSet, Elt, Leaf, Mark, Node, Plot, Pos, Schema, SchemaError, Shape, Slice, Token, ValidationError, parse, serialize };