@blade-hq/agent-react 2612.0.0-beta.5 → 2612.0.0-beta.7

package/node_modules/prosemirror-model/src/schema.ts

@@ -0,0 +1,705 @@
+import OrderedMap from "orderedmap"
+
+import {Node, TextNode} from "./node"
+import {Fragment} from "./fragment"
+import {Mark} from "./mark"
+import {ContentMatch} from "./content"
+import {DOMOutputSpec} from "./to_dom"
+import {ParseRule, TagParseRule} from "./from_dom"
+
+/// An object holding the attributes of a node.
+export type Attrs = {readonly [attr: string]: any}
+
+// For node types where all attrs have a default value (or which don't
+// have any attributes), build up a single reusable default attribute
+// object, and use it for all nodes that don't specify specific
+// attributes.
+function defaultAttrs(attrs: {[name: string]: Attribute}) {
+  let defaults = Object.create(null)
+  for (let attrName in attrs) {
+    let attr = attrs[attrName]
+    if (!attr.hasDefault) return null
+    defaults[attrName] = attr.default
+  }
+  return defaults
+}
+
+function computeAttrs(attrs: {[name: string]: Attribute}, value: Attrs | null) {
+  let built = Object.create(null)
+  for (let name in attrs) {
+    let given = value && value[name]
+    if (given === undefined) {
+      let attr = attrs[name]
+      if (attr.hasDefault) given = attr.default
+      else throw new RangeError("No value supplied for attribute " + name)
+    }
+    built[name] = given
+  }
+  return built
+}
+
+export function checkAttrs(attrs: {[name: string]: Attribute}, values: Attrs, type: string, name: string) {
+  for (let name in values)
+    if (!(name in attrs)) throw new RangeError(`Unsupported attribute ${name} for ${type} of type ${name}`)
+  for (let name in attrs) {
+    let attr = attrs[name]
+    if (attr.validate) attr.validate(values[name])
+  }
+}
+
+function initAttrs(typeName: string, attrs?: {[name: string]: AttributeSpec}) {
+  let result: {[name: string]: Attribute} = Object.create(null)
+  if (attrs) for (let name in attrs) result[name] = new Attribute(typeName, name, attrs[name])
+  return result
+}
+
+/// Node types are objects allocated once per `Schema` and used to
+/// [tag](#model.Node.type) `Node` instances. They contain information
+/// about the node type, such as its name and what kind of node it
+/// represents.
+export class NodeType {
+  /// @internal
+  groups: readonly string[]
+  /// @internal
+  attrs: {[name: string]: Attribute}
+  /// @internal
+  defaultAttrs: Attrs
+
+  /// @internal
+  constructor(
+    /// The name the node type has in this schema.
+    readonly name: string,
+    /// A link back to the `Schema` the node type belongs to.
+    readonly schema: Schema,
+    /// The spec that this type is based on
+    readonly spec: NodeSpec
+  ) {
+    this.groups = spec.group ? spec.group.split(" ") : []
+    this.attrs = initAttrs(name, spec.attrs)
+    this.defaultAttrs = defaultAttrs(this.attrs)
+
+    // Filled in later
+    ;(this as any).contentMatch = null
+    ;(this as any).inlineContent = null
+
+    this.isBlock = !(spec.inline || name == "text")
+    this.isText = name == "text"
+  }
+
+  /// True if this node type has inline content.
+  declare inlineContent: boolean
+  /// True if this is a block type
+  isBlock: boolean
+  /// True if this is the text node type.
+  isText: boolean
+
+  /// True if this is an inline type.
+  get isInline() { return !this.isBlock }
+
+  /// True if this is a textblock type, a block that contains inline
+  /// content.
+  get isTextblock() { return this.isBlock && this.inlineContent }
+
+  /// True for node types that allow no content.
+  get isLeaf() { return this.contentMatch == ContentMatch.empty }
+
+  /// True when this node is an atom, i.e. when it does not have
+  /// directly editable content.
+  get isAtom() { return this.isLeaf || !!this.spec.atom }
+
+  /// Return true when this node type is part of the given
+  /// [group](#model.NodeSpec.group).
+  isInGroup(group: string) {
+    return this.groups.indexOf(group) > -1
+  }
+
+  /// The starting match of the node type's content expression.
+  declare contentMatch: ContentMatch
+
+  /// The set of marks allowed in this node. `null` means all marks
+  /// are allowed.
+  markSet: readonly MarkType[] | null = null
+
+  /// The node type's [whitespace](#model.NodeSpec.whitespace) option.
+  get whitespace(): "pre" | "normal" {
+    return this.spec.whitespace || (this.spec.code ? "pre" : "normal")
+  }
+
+  /// Tells you whether this node type has any required attributes.
+  hasRequiredAttrs() {
+    for (let n in this.attrs) if (this.attrs[n].isRequired) return true
+    return false
+  }
+
+  /// Indicates whether this node allows some of the same content as
+  /// the given node type.
+  compatibleContent(other: NodeType) {
+    return this == other || this.contentMatch.compatible(other.contentMatch)
+  }
+
+  /// @internal
+  computeAttrs(attrs: Attrs | null): Attrs {
+    if (!attrs && this.defaultAttrs) return this.defaultAttrs
+    else return computeAttrs(this.attrs, attrs)
+  }
+
+  /// Create a `Node` of this type. The given attributes are
+  /// checked and defaulted (you can pass `null` to use the type's
+  /// defaults entirely, if no required attributes exist). `content`
+  /// may be a `Fragment`, a node, an array of nodes, or
+  /// `null`. Similarly `marks` may be `null` to default to the empty
+  /// set of marks.
+  create(attrs: Attrs | null = null, content?: Fragment | Node | readonly Node[] | null, marks?: readonly Mark[]) {
+    if (this.isText) throw new Error("NodeType.create can't construct text nodes")
+    return new Node(this, this.computeAttrs(attrs), Fragment.from(content), Mark.setFrom(marks))
+  }
+
+  /// Like [`create`](#model.NodeType.create), but check the given content
+  /// against the node type's content restrictions, and throw an error
+  /// if it doesn't match.
+  createChecked(attrs: Attrs | null = null, content?: Fragment | Node | readonly Node[] | null, marks?: readonly Mark[]) {
+    content = Fragment.from(content)
+    this.checkContent(content)
+    return new Node(this, this.computeAttrs(attrs), content, Mark.setFrom(marks))
+  }
+
+  /// Like [`create`](#model.NodeType.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. If no fitting wrapping can be found,
+  /// return null. Note that, due to the fact that required nodes can
+  /// always be created, this will always succeed if you pass null or
+  /// `Fragment.empty` as content.
+  createAndFill(attrs: Attrs | null = null, content?: Fragment | Node | readonly Node[] | null, marks?: readonly Mark[]) {
+    attrs = this.computeAttrs(attrs)
+    content = Fragment.from(content)
+    if (content.size) {
+      let before = this.contentMatch.fillBefore(content)
+      if (!before) return null
+      content = before.append(content)
+    }
+    let matched = this.contentMatch.matchFragment(content)
+    let after = matched && matched.fillBefore(Fragment.empty, true)
+    if (!after) return null
+    return new Node(this, attrs, (content as Fragment).append(after), Mark.setFrom(marks))
+  }
+
+  /// Returns true if the given fragment is valid content for this node
+  /// type.
+  validContent(content: Fragment) {
+    let result = this.contentMatch.matchFragment(content)
+    if (!result || !result.validEnd) return false
+    for (let i = 0; i < content.childCount; i++)
+      if (!this.allowsMarks(content.child(i).marks)) return false
+    return true
+  }
+
+  /// Throws a RangeError if the given fragment is not valid content for this
+  /// node type.
+  /// @internal
+  checkContent(content: Fragment) {
+    if (!this.validContent(content))
+      throw new RangeError(`Invalid content for node ${this.name}: ${content.toString().slice(0, 50)}`)
+  }
+
+  /// @internal
+  checkAttrs(attrs: Attrs) {
+    checkAttrs(this.attrs, attrs, "node", this.name)
+  }
+
+  /// Check whether the given mark type is allowed in this node.
+  allowsMarkType(markType: MarkType) {
+    return this.markSet == null || this.markSet.indexOf(markType) > -1
+  }
+
+  /// Test whether the given set of marks are allowed in this node.
+  allowsMarks(marks: readonly Mark[]) {
+    if (this.markSet == null) return true
+    for (let i = 0; i < marks.length; i++) if (!this.allowsMarkType(marks[i].type)) return false
+    return true
+  }
+
+  /// Removes the marks that are not allowed in this node from the given set.
+  allowedMarks(marks: readonly Mark[]): readonly Mark[] {
+    if (this.markSet == null) return marks
+    let copy
+    for (let i = 0; i < marks.length; i++) {
+      if (!this.allowsMarkType(marks[i].type)) {
+        if (!copy) copy = marks.slice(0, i)
+      } else if (copy) {
+        copy.push(marks[i])
+      }
+    }
+    return !copy ? marks : copy.length ? copy : Mark.none
+  }
+
+  /// @internal
+  static compile<Nodes extends string>(nodes: OrderedMap<NodeSpec>, schema: Schema<Nodes>): {readonly [name in Nodes]: NodeType} {
+    let result = Object.create(null)
+    nodes.forEach((name, spec) => result[name] = new NodeType(name, schema, spec))
+
+    let topType = schema.spec.topNode || "doc"
+    if (!result[topType]) throw new RangeError("Schema is missing its top node type ('" + topType + "')")
+    if (!result.text) throw new RangeError("Every schema needs a 'text' type")
+    for (let _ in result.text.attrs) throw new RangeError("The text node type should not have attributes")
+
+    return result
+  }
+}
+
+function validateType(typeName: string, attrName: string, type: string) {
+  let types = type.split("|")
+  return (value: any) => {
+    let name = value === null ? "null" : typeof value
+    if (types.indexOf(name) < 0) throw new RangeError(`Expected value of type ${types} for attribute ${attrName} on type ${typeName}, got ${name}`)
+  }
+}
+
+// Attribute descriptors
+
+class Attribute {
+  hasDefault: boolean
+  default: any
+  validate: undefined | ((value: any) => void)
+
+  constructor(typeName: string, attrName: string, options: AttributeSpec) {
+    this.hasDefault = Object.prototype.hasOwnProperty.call(options, "default")
+    this.default = options.default
+    this.validate = typeof options.validate == "string" ? validateType(typeName, attrName, options.validate) : options.validate
+  }
+
+  get isRequired() {
+    return !this.hasDefault
+  }
+}
+
+// Marks
+
+/// Like nodes, marks (which are associated with nodes to signify
+/// things like emphasis or being part of a link) are
+/// [tagged](#model.Mark.type) with type objects, which are
+/// instantiated once per `Schema`.
+export class MarkType {
+  /// @internal
+  attrs: {[name: string]: Attribute}
+  /// @internal
+  declare excluded: readonly MarkType[]
+  /// @internal
+  instance: Mark | null
+
+  /// @internal
+  constructor(
+    /// The name of the mark type.
+    readonly name: string,
+    /// @internal
+    readonly rank: number,
+    /// The schema that this mark type instance is part of.
+    readonly schema: Schema,
+    /// The spec on which the type is based.
+    readonly spec: MarkSpec
+  ) {
+    this.attrs = initAttrs(name, spec.attrs)
+    ;(this as any).excluded = null
+    let defaults = defaultAttrs(this.attrs)
+    this.instance = defaults ? new Mark(this, defaults) : null
+  }
+
+  /// Create a mark of this type. `attrs` may be `null` or an object
+  /// containing only some of the mark's attributes. The others, if
+  /// they have defaults, will be added.
+  create(attrs: Attrs | null = null) {
+    if (!attrs && this.instance) return this.instance
+    return new Mark(this, computeAttrs(this.attrs, attrs))
+  }
+
+  /// @internal
+  static compile(marks: OrderedMap<MarkSpec>, schema: Schema) {
+    let result = Object.create(null), rank = 0
+    marks.forEach((name, spec) => result[name] = new MarkType(name, rank++, schema, spec))
+    return result
+  }
+
+  /// When there is a mark of this type in the given set, a new set
+  /// without it is returned. Otherwise, the input set is returned.
+  removeFromSet(set: readonly Mark[]): readonly Mark[] {
+    for (var i = 0; i < set.length; i++) if (set[i].type == this) {
+      set = set.slice(0, i).concat(set.slice(i + 1))
+      i--
+    }
+    return set
+  }
+
+  /// Tests whether there is a mark of this type in the given set.
+  isInSet(set: readonly Mark[]): Mark | undefined {
+    for (let i = 0; i < set.length; i++)
+      if (set[i].type == this) return set[i]
+  }
+
+  /// @internal
+  checkAttrs(attrs: Attrs) {
+    checkAttrs(this.attrs, attrs, "mark", this.name)
+  }
+
+  /// Queries whether a given mark type is
+  /// [excluded](#model.MarkSpec.excludes) by this one.
+  excludes(other: MarkType) {
+    return this.excluded.indexOf(other) > -1
+  }
+}
+
+/// An object describing a schema, as passed to the [`Schema`](#model.Schema)
+/// constructor.
+export interface SchemaSpec<Nodes extends string = any, Marks extends string = any> {
+  /// The node types in this schema. Maps names to
+  /// [`NodeSpec`](#model.NodeSpec) objects that describe the node type
+  /// associated with that name. Their order is significant—it
+  /// determines which [parse rules](#model.NodeSpec.parseDOM) take
+  /// precedence by default, and which nodes come first in a given
+  /// [group](#model.NodeSpec.group).
+  nodes: {[name in Nodes]: NodeSpec} | OrderedMap<NodeSpec>,
+
+  /// The mark types that exist in this schema. The order in which they
+  /// are provided determines the order in which [mark
+  /// sets](#model.Mark.addToSet) are sorted and in which [parse
+  /// rules](#model.MarkSpec.parseDOM) are tried.
+  marks?: {[name in Marks]: MarkSpec} | OrderedMap<MarkSpec>
+
+  /// The name of the default top-level node for the schema. Defaults
+  /// to `"doc"`.
+  topNode?: string
+}
+
+/// A description of a node type, used when defining a schema.
+export interface NodeSpec {
+  /// The content expression for this node, as described in the [schema
+  /// guide](/docs/guide/#schema.content_expressions). When not given,
+  /// the node does not allow any content.
+  content?: string
+
+  /// The marks that are allowed inside of this node. May be a
+  /// space-separated string referring to mark names or groups, `"_"`
+  /// to explicitly allow all marks, or `""` to disallow marks. When
+  /// not given, nodes with inline content default to allowing all
+  /// marks, other nodes default to not allowing marks.
+  marks?: string
+
+  /// The group or space-separated groups to which this node belongs,
+  /// which can be referred to in the content expressions for the
+  /// schema.
+  group?: string
+
+  /// Should be set to true for inline nodes. (Implied for text nodes.)
+  inline?: boolean
+
+  /// Can be set to true to indicate that, though this isn't a [leaf
+  /// node](#model.NodeType.isLeaf), it doesn't have directly editable
+  /// content and should be treated as a single unit in the view.
+  atom?: boolean
+
+  /// The attributes that nodes of this type get.
+  attrs?: {[name: string]: AttributeSpec}
+
+  /// Controls whether nodes of this type can be selected as a [node
+  /// selection](#state.NodeSelection). Defaults to true for non-text
+  /// nodes.
+  selectable?: boolean
+
+  /// Determines whether nodes of this type can be dragged without
+  /// being selected. Defaults to false.
+  draggable?: boolean
+
+  /// Can be used to indicate that this node contains code, which
+  /// causes some commands to behave differently.
+  code?: boolean
+
+  /// Controls way whitespace in this a node is parsed. The default is
+  /// `"normal"`, which causes the [DOM parser](#model.DOMParser) to
+  /// collapse whitespace in normal mode, and normalize it (replacing
+  /// newlines and such with spaces) otherwise. `"pre"` causes the
+  /// parser to preserve spaces inside the node. When this option isn't
+  /// given, but [`code`](#model.NodeSpec.code) is true, `whitespace`
+  /// will default to `"pre"`. Note that this option doesn't influence
+  /// the way the node is rendered—that should be handled by `toDOM`
+  /// and/or styling.
+  whitespace?: "pre" | "normal"
+
+  /// Determines whether this node is considered an important parent
+  /// node during replace operations (such as paste). Non-defining (the
+  /// default) nodes get dropped when their entire content is replaced,
+  /// whereas defining nodes persist and wrap the inserted content.
+  definingAsContext?: boolean
+
+  /// In inserted content the defining parents of the content are
+  /// preserved when possible. Typically, non-default-paragraph
+  /// textblock types, and possibly list items, are marked as defining.
+  definingForContent?: boolean
+
+  /// When enabled, enables both
+  /// [`definingAsContext`](#model.NodeSpec.definingAsContext) and
+  /// [`definingForContent`](#model.NodeSpec.definingForContent).
+  defining?: boolean
+
+  /// When enabled (default is false), the sides of nodes of this type
+  /// count as boundaries that regular editing operations, like
+  /// backspacing or lifting, won't cross. An example of a node that
+  /// should probably have this enabled is a table cell.
+  isolating?: boolean
+
+  /// Defines the default way a node of this type should be serialized
+  /// to DOM/HTML (as used by
+  /// [`DOMSerializer.fromSchema`](#model.DOMSerializer^fromSchema)).
+  /// Should return a DOM node or an [array
+  /// structure](#model.DOMOutputSpec) that describes one, with an
+  /// optional number zero (“hole”) in it to indicate where the node's
+  /// content should be inserted.
+  ///
+  /// For text nodes, the default is to create a text DOM node. Though
+  /// it is possible to create a serializer where text is rendered
+  /// differently, this is not supported inside the editor, so you
+  /// shouldn't override that in your text node spec.
+  toDOM?: (node: Node) => DOMOutputSpec
+
+  /// Associates DOM parser information with this node, which can be
+  /// used by [`DOMParser.fromSchema`](#model.DOMParser^fromSchema) to
+  /// automatically derive a parser. The `node` field in the rules is
+  /// implied (the name of this node will be filled in automatically).
+  /// If you supply your own parser, you do not need to also specify
+  /// parsing rules in your schema.
+  parseDOM?: readonly TagParseRule[]
+
+  /// Defines the default way a node of this type should be serialized
+  /// to a string representation for debugging (e.g. in error messages).
+  toDebugString?: (node: Node) => string
+
+  /// Defines the default way a [leaf node](#model.NodeType.isLeaf) of
+  /// this type should be serialized to a string (as used by
+  /// [`Node.textBetween`](#model.Node.textBetween) and
+  /// [`Node.textContent`](#model.Node.textContent)).
+  leafText?: (node: Node) => string
+
+  /// A single inline node in a schema can be set to be a linebreak
+  /// equivalent. When converting between block types that support the
+  /// node and block types that don't but have
+  /// [`whitespace`](#model.NodeSpec.whitespace) set to `"pre"`,
+  /// [`setBlockType`](#transform.Transform.setBlockType) will convert
+  /// between newline characters to or from linebreak nodes as
+  /// appropriate.
+  linebreakReplacement?: boolean
+
+  /// Node specs may include arbitrary properties that can be read by
+  /// other code via [`NodeType.spec`](#model.NodeType.spec).
+  [key: string]: any
+}
+
+/// Used to define marks when creating a schema.
+export interface MarkSpec {
+  /// The attributes that marks of this type get.
+  attrs?: {[name: string]: AttributeSpec}
+
+  /// 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
+
+  /// Determines which other marks this mark can coexist with. Should
+  /// be a space-separated strings naming other marks or groups of marks.
+  /// When a mark is [added](#model.Mark.addToSet) to a set, all marks
+  /// that it excludes are removed in the process. If the set contains
+  /// any mark that excludes the new mark but is not, itself, excluded
+  /// by the new mark, the mark can not be added an the set. You can
+  /// use the value `"_"` to indicate that the mark excludes all
+  /// marks in the schema.
+  ///
+  /// Defaults to only being exclusive with marks of the same type. You
+  /// can set it to an empty string (or any string not containing the
+  /// mark's own name) to allow multiple marks of a given type to
+  /// coexist (as long as they have different attributes).
+  excludes?: string
+
+  /// The group or space-separated groups to which this mark belongs.
+  group?: string
+
+  /// Determines whether marks of this type can span multiple adjacent
+  /// nodes when serialized to DOM/HTML. Defaults to true.
+  spanning?: boolean
+
+  /// Marks the content of this span as being code, which causes some
+  /// commands and extensions to treat it differently.
+  code?: boolean
+
+  /// Defines the default way marks of this type should be serialized
+  /// to DOM/HTML. When the resulting spec contains a hole, that is
+  /// where the marked content is placed. Otherwise, it is appended to
+  /// the top node.
+  toDOM?: (mark: Mark, inline: boolean) => DOMOutputSpec
+
+  /// Associates DOM parser information with this mark (see the
+  /// corresponding [node spec field](#model.NodeSpec.parseDOM)). The
+  /// `mark` field in the rules is implied.
+  parseDOM?: readonly ParseRule[]
+
+  /// Mark specs can include additional properties that can be
+  /// inspected through [`MarkType.spec`](#model.MarkType.spec) when
+  /// working with the mark.
+  [key: string]: any
+}
+
+/// Used to [define](#model.NodeSpec.attrs) attributes on nodes or
+/// marks.
+export interface AttributeSpec {
+  /// The default value for this attribute, to use when no explicit
+  /// value is provided. Attributes that have no default must be
+  /// provided whenever a node or mark of a type that has them is
+  /// created.
+  default?: any
+  /// A function or type name used to validate values of this
+  /// attribute. This will be used when deserializing the attribute
+  /// from JSON, and when running [`Node.check`](#model.Node.check).
+  /// When a function, it should raise an exception if the value isn't
+  /// of the expected type or shape. When a string, it should be a
+  /// `|`-separated string of primitive types (`"number"`, `"string"`,
+  /// `"boolean"`, `"null"`, and `"undefined"`), and the library will
+  /// raise an error when the value is not one of those types.
+  validate?: string | ((value: any) => void)
+}
+
+/// A document schema. Holds [node](#model.NodeType) and [mark
+/// type](#model.MarkType) objects for the nodes and marks that may
+/// occur in conforming documents, and provides functionality for
+/// creating and deserializing such documents.
+///
+/// When given, the type parameters provide the names of the nodes and
+/// marks in this schema.
+export class Schema<Nodes extends string = any, Marks extends string = any> {
+  /// The [spec](#model.SchemaSpec) on which the schema is based,
+  /// with the added guarantee that its `nodes` and `marks`
+  /// properties are
+  /// [`OrderedMap`](https://github.com/marijnh/orderedmap) instances
+  /// (not raw objects).
+  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](#model.NodeSpec.linebreakReplacement) node defined
+  /// in this schema, if any.
+  linebreakReplacement: NodeType | null = null
+
+  /// Construct a schema from a schema [specification](#model.SchemaSpec).
+  constructor(spec: SchemaSpec<Nodes, Marks>) {
+    let instanceSpec = this.spec = {} as any
+    for (let prop in spec) instanceSpec[prop] = (spec as any)[prop]
+    instanceSpec.nodes = OrderedMap.from(spec.nodes),
+    instanceSpec.marks = OrderedMap.from(spec.marks || {}),
+
+    this.nodes = NodeType.compile(this.spec.nodes, this)
+    this.marks = MarkType.compile(this.spec.marks, this)
+
+    let contentExprCache = Object.create(null)
+    for (let prop in this.nodes) {
+      if (prop in this.marks)
+        throw new RangeError(prop + " can not be both a node and a mark")
+      let type = this.nodes[prop], contentExpr = type.spec.content || "", markExpr = type.spec.marks
+      type.contentMatch = contentExprCache[contentExpr] ||
+        (contentExprCache[contentExpr] = ContentMatch.parse(contentExpr, this.nodes))
+      ;(type as any).inlineContent = type.contentMatch.inlineContent
+      if (type.spec.linebreakReplacement) {
+        if (this.linebreakReplacement) throw new RangeError("Multiple linebreak nodes defined")
+        if (!type.isInline || !type.isLeaf) throw new RangeError("Linebreak replacement nodes must be inline leaf nodes")
+        this.linebreakReplacement = type
+      }
+      type.markSet = markExpr == "_" ? null :
+        markExpr ? gatherMarks(this, markExpr.split(" ")) :
+        markExpr == "" || !type.inlineContent ? [] : null
+    }
+    for (let prop in this.marks) {
+      let type = this.marks[prop], excl = type.spec.excludes
+      type.excluded = excl == null ? [type] : excl == "" ? [] : gatherMarks(this, excl.split(" "))
+    }
+
+    this.nodeFromJSON = json => Node.fromJSON(this, json)
+    this.markFromJSON = json => Mark.fromJSON(this, json)
+    this.topNodeType = this.nodes[this.spec.topNode || "doc"]
+    this.cached.wrappings = Object.create(null)
+  }
+
+  /// The type of the [default top node](#model.SchemaSpec.topNode)
+  /// for this schema.
+  topNodeType: NodeType
+
+  /// An object for storing whatever values modules may want to
+  /// compute and cache per schema. (If you want to store something
+  /// in it, try to use property names unlikely to clash.)
+  cached: {[key: string]: any} = Object.create(null)
+
+  /// Create a node in this schema. The `type` may be a string or a
+  /// `NodeType` instance. Attributes will be extended with defaults,
+  /// `content` may be a `Fragment`, `null`, a `Node`, or an array of
+  /// nodes.
+  node(type: string | NodeType,
+       attrs: Attrs | null = null,
+       content?: Fragment | Node | readonly Node[],
+       marks?: readonly Mark[]) {
+    if (typeof type == "string")
+      type = this.nodeType(type)
+    else if (!(type instanceof NodeType))
+      throw new RangeError("Invalid node type: " + type)
+    else if (type.schema != this)
+      throw new RangeError("Node type from different schema used (" + type.name + ")")
+
+    return type.createChecked(attrs, content, marks)
+  }
+
+  /// Create a text node in the schema. Empty text nodes are not
+  /// allowed.
+  text(text: string, marks?: readonly Mark[] | null): Node {
+    let type = this.nodes.text
+    return new TextNode(type, type.defaultAttrs, text, Mark.setFrom(marks))
+  }
+
+  /// Create a mark with the given type and attributes.
+  mark(type: string | MarkType, attrs?: Attrs | null) {
+    if (typeof type == "string") type = this.marks[type]
+    return type.create(attrs)
+  }
+
+  /// Deserialize a node from its JSON representation. This method is
+  /// bound.
+  nodeFromJSON: (json: any) => Node
+
+  /// Deserialize a mark from its JSON representation. This method is
+  /// bound.
+  markFromJSON: (json: any) => Mark
+
+  /// @internal
+  nodeType(name: string) {
+    let found = this.nodes[name]
+    if (!found) throw new RangeError("Unknown node type: " + name)
+    return found
+  }
+}
+
+function gatherMarks(schema: Schema, marks: readonly string[]) {
+  let found: MarkType[] = []
+  for (let i = 0; i < marks.length; i++) {
+    let name = marks[i], mark = schema.marks[name], ok = mark
+    if (mark) {
+      found.push(mark)
+    } else {
+      for (let prop in schema.marks) {
+        let mark = schema.marks[prop]
+        if (name == "_" || (mark.spec.group && mark.spec.group.split(" ").indexOf(name) > -1))
+          found.push(ok = mark)
+      }
+    }
+    if (!ok) throw new SyntaxError("Unknown mark type: '" + marks[i] + "'")
+  }
+  return found
+}