prosemirror-transform 1.4.1 → 1.5.0

package/src/step.ts

@@ -0,0 +1,97 @@
+import {ReplaceError, Schema, Slice, Node} from "prosemirror-model"
+
+import {StepMap, Mappable} from "./map"
+
+const stepsByID: {[id: string]: {fromJSON(schema: Schema, json: any): Step}} = Object.create(null)
+
+/// A step object represents an atomic change. It generally applies
+/// only to the document it was created for, since the positions
+/// stored in it will only make sense for that document.
+///
+/// New steps are defined by creating classes that extend `Step`,
+/// overriding the `apply`, `invert`, `map`, `getMap` and `fromJSON`
+/// methods, and registering your class with a unique
+/// JSON-serialization identifier using
+/// [`Step.jsonID`](#transform.Step^jsonID).
+export abstract class Step {
+  /// Applies this step to the given document, returning a result
+  /// object that either indicates failure, if the step can not be
+  /// applied to this document, or indicates success by containing a
+  /// transformed document.
+  abstract apply(doc: Node): StepResult
+
+  /// Get the step map that represents the changes made by this step,
+  /// and which can be used to transform between positions in the old
+  /// and the new document.
+  getMap(): StepMap { return StepMap.empty }
+
+  /// Create an inverted version of this step. Needs the document as it
+  /// was before the step as argument.
+  abstract invert(doc: Node): Step
+
+  /// Map this step through a mappable thing, returning either a
+  /// version of that step with its positions adjusted, or `null` if
+  /// the step was entirely deleted by the mapping.
+  abstract map(mapping: Mappable): Step | null
+
+  /// Try to merge this step with another one, to be applied directly
+  /// after it. Returns the merged step when possible, null if the
+  /// steps can't be merged.
+  merge(other: Step): Step | null { return null }
+
+  /// Create a JSON-serializeable representation of this step. When
+  /// defining this for a custom subclass, make sure the result object
+  /// includes the step type's [JSON id](#transform.Step^jsonID) under
+  /// the `stepType` property.
+  abstract toJSON(): any
+
+  /// Deserialize a step from its JSON representation. Will call
+  /// through to the step class' own implementation of this method.
+  static fromJSON(schema: Schema, json: any): Step {
+    if (!json || !json.stepType) throw new RangeError("Invalid input for Step.fromJSON")
+    let type = stepsByID[json.stepType]
+    if (!type) throw new RangeError(`No step type ${json.stepType} defined`)
+    return type.fromJSON(schema, json)
+  }
+
+  /// To be able to serialize steps to JSON, each step needs a string
+  /// ID to attach to its JSON representation. Use this method to
+  /// register an ID for your step classes. Try to pick something
+  /// that's unlikely to clash with steps from other modules.
+  static jsonID(id: string, stepClass: {fromJSON(schema: Schema, json: any): Step}) {
+    if (id in stepsByID) throw new RangeError("Duplicate use of step JSON ID " + id)
+    stepsByID[id] = stepClass
+    ;(stepClass as any).prototype.jsonID = id
+    return stepClass
+  }
+}
+
+/// The result of [applying](#transform.Step.apply) a step. Contains either a
+/// new document or a failure value.
+export class StepResult {
+  /// @internal
+  constructor(
+    /// The transformed document, if successful.
+    readonly doc: Node | null,
+    /// The failure message, if unsuccessful.
+    readonly failed: string | null
+  ) {}
+
+  /// Create a successful step result.
+  static ok(doc: Node) { return new StepResult(doc, null) }
+
+  /// Create a failed step result.
+  static fail(message: string) { return new StepResult(null, message) }
+
+  /// Call [`Node.replace`](#model.Node.replace) with the given
+  /// arguments. Create a successful result if it succeeds, and a
+  /// failed one if it throws a `ReplaceError`.
+  static fromReplace(doc: Node, from: number, to: number, slice: Slice) {
+    try {
+      return StepResult.ok(doc.replace(from, to, slice))
+    } catch (e) {
+      if (e instanceof ReplaceError) return StepResult.fail(e.message)
+      throw e
+    }
+  }
+}

package/src/{structure.js → structure.ts}

@@ -1,18 +1,17 @@
-import {Slice, Fragment} from "prosemirror-model"
+import {Slice, Fragment, NodeRange, NodeType, Node, Mark, Attrs, ContentMatch} from "prosemirror-model"
 
 import {Transform} from "./transform"
 import {ReplaceStep, ReplaceAroundStep} from "./replace_step"
 
-function canCut(node, start, end) {
+function canCut(node: Node, start: number, end: number) {
   return (start == 0 || node.canReplace(start, node.childCount)) &&
     (end == node.childCount || node.canReplace(0, end))
 }
 
-// :: (NodeRange) → ?number
-// Try to find a target depth to which the content in the given range
-// can be lifted. Will not go across
-// [isolating](#model.NodeSpec.isolating) parent nodes.
-export function liftTarget(range) {
+/// Try to find a target depth to which the content in the given range
+/// can be lifted. Will not go across
+/// [isolating](#model.NodeSpec.isolating) parent nodes.
+export function liftTarget(range: NodeRange): number | null {
   let parent = range.parent
   let content = parent.content.cutByIndex(range.startIndex, range.endIndex)
   for (let depth = range.depth;; --depth) {
@@ -22,15 +21,10 @@ export function liftTarget(range) {
       return depth
     if (depth == 0 || node.type.spec.isolating || !canCut(node, index, endIndex)) break
   }
+  return null
 }
 
-// :: (NodeRange, number) → this
-// Split the content in the given range off from its parent, if there
-// is sibling content before or after it, and move it up the tree to
-// the depth specified by `target`. You'll probably want to use
-// [`liftTarget`](#transform.liftTarget) to compute `target`, to make
-// sure the lift is valid.
-Transform.prototype.lift = function(range, target) {
+export function lift(tr: Transform, range: NodeRange, target: number) {
   let {$from, $to, depth} = range
 
   let gapStart = $from.before(depth + 1), gapEnd = $to.after(depth + 1)
@@ -55,28 +49,33 @@ Transform.prototype.lift = function(range, target) {
       end++
     }
 
-  return this.step(new ReplaceAroundStep(start, end, gapStart, gapEnd,
-                                         new Slice(before.append(after), openStart, openEnd),
-                                         before.size - openStart, true))
+  tr.step(new ReplaceAroundStep(start, end, gapStart, gapEnd,
+                                new Slice(before.append(after), openStart, openEnd),
+                                before.size - openStart, true))
 }
 
-// :: (NodeRange, NodeType, ?Object, ?NodeRange) → ?[{type: NodeType, attrs: ?Object}]
-// Try to find a valid way to wrap the content in the given range in a
-// node of the given type. May introduce extra nodes around and inside
-// the wrapper node, if necessary. Returns null if no valid wrapping
-// could be found. When `innerRange` is given, that range's content is
-// used as the content to fit into the wrapping, instead of the
-// content of `range`.
-export function findWrapping(range, nodeType, attrs, innerRange = range) {
+/// Try to find a valid way to wrap the content in the given range in a
+/// node of the given type. May introduce extra nodes around and inside
+/// the wrapper node, if necessary. Returns null if no valid wrapping
+/// could be found. When `innerRange` is given, that range's content is
+/// used as the content to fit into the wrapping, instead of the
+/// content of `range`.
+export function findWrapping(
+  range: NodeRange,
+  nodeType: NodeType,
+  attrs: Attrs | null = null,
+  innerRange = range
+): {type: NodeType, attrs: Attrs | null}[] | null {
   let around = findWrappingOutside(range, nodeType)
   let inner = around && findWrappingInside(innerRange, nodeType)
   if (!inner) return null
-  return around.map(withAttrs).concat({type: nodeType, attrs}).concat(inner.map(withAttrs))
+  return (around!.map(withAttrs) as {type: NodeType, attrs: Attrs | null}[])
+    .concat({type: nodeType, attrs}).concat(inner.map(withAttrs))
 }
 
-function withAttrs(type) { return {type, attrs: null} }
+function withAttrs(type: NodeType) { return {type, attrs: null} }
 
-function findWrappingOutside(range, type) {
+function findWrappingOutside(range: NodeRange, type: NodeType) {
   let {parent, startIndex, endIndex} = range
   let around = parent.contentMatchAt(startIndex).findWrapping(type)
   if (!around) return null
@@ -84,24 +83,20 @@ function findWrappingOutside(range, type) {
   return parent.canReplaceWith(startIndex, endIndex, outer) ? around : null
 }
 
-function findWrappingInside(range, type) {
+function findWrappingInside(range: NodeRange, type: NodeType) {
   let {parent, startIndex, endIndex} = range
   let inner = parent.child(startIndex)
   let inside = type.contentMatch.findWrapping(inner.type)
   if (!inside) return null
   let lastType = inside.length ? inside[inside.length - 1] : type
-  let innerMatch = lastType.contentMatch
+  let innerMatch: ContentMatch | null = lastType.contentMatch
   for (let i = startIndex; innerMatch && i < endIndex; i++)
     innerMatch = innerMatch.matchType(parent.child(i).type)
   if (!innerMatch || !innerMatch.validEnd) return null
   return inside
 }
 
-// :: (NodeRange, [{type: NodeType, attrs: ?Object}]) → this
-// Wrap the given [range](#model.NodeRange) in the given set of wrappers.
-// The wrappers are assumed to be valid in this position, and should
-// probably be computed with [`findWrapping`](#transform.findWrapping).
-Transform.prototype.wrap = function(range, wrappers) {
+export function wrap(tr: Transform, range: NodeRange, wrappers: readonly {type: NodeType, attrs?: Attrs | null}[]) {
   let content = Fragment.empty
   for (let i = wrappers.length - 1; i >= 0; i--) {
     if (content.size) {
@@ -113,55 +108,51 @@ Transform.prototype.wrap = function(range, wrappers) {
   }
 
   let start = range.start, end = range.end
-  return this.step(new ReplaceAroundStep(start, end, start, end, new Slice(content, 0, 0), wrappers.length, true))
+  tr.step(new ReplaceAroundStep(start, end, start, end, new Slice(content, 0, 0), wrappers.length, true))
 }
 
-// :: (number, ?number, NodeType, ?Object) → this
-// Set the type of all textblocks (partly) between `from` and `to` to
-// the given node type with the given attributes.
-Transform.prototype.setBlockType = function(from, to = from, type, attrs) {
+export function setBlockType(tr: Transform, from: number, to: number, type: NodeType, attrs: Attrs | null) {
   if (!type.isTextblock) throw new RangeError("Type given to setBlockType should be a textblock")
-  let mapFrom = this.steps.length
-  this.doc.nodesBetween(from, to, (node, pos) => {
-    if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType(this.doc, this.mapping.slice(mapFrom).map(pos), type)) {
+  let mapFrom = tr.steps.length
+  tr.doc.nodesBetween(from, to, (node, pos) => {
+    if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
       // Ensure all markup that isn't allowed in the new node type is cleared
-      this.clearIncompatible(this.mapping.slice(mapFrom).map(pos, 1), type)
-      let mapping = this.mapping.slice(mapFrom)
+      tr.clearIncompatible(tr.mapping.slice(mapFrom).map(pos, 1), type)
+      let mapping = tr.mapping.slice(mapFrom)
       let startM = mapping.map(pos, 1), endM = mapping.map(pos + node.nodeSize, 1)
-      this.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1,
+      tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1,
                                       new Slice(Fragment.from(type.create(attrs, null, node.marks)), 0, 0), 1, true))
       return false
     }
   })
-  return this
 }
 
-function canChangeType(doc, pos, type) {
+function canChangeType(doc: Node, pos: number, type: NodeType) {
   let $pos = doc.resolve(pos), index = $pos.index()
   return $pos.parent.canReplaceWith(index, index + 1, type)
 }
 
-// :: (number, ?NodeType, ?Object, ?[Mark]) → this
-// Change the type, attributes, and/or marks of the node at `pos`.
-// When `type` isn't given, the existing node type is preserved,
-Transform.prototype.setNodeMarkup = function(pos, type, attrs, marks) {
-  let node = this.doc.nodeAt(pos)
+/// Change the type, attributes, and/or marks of the node at `pos`.
+/// When `type` isn't given, the existing node type is preserved,
+export function setNodeMarkup(tr: Transform, pos: number, type: NodeType | undefined | null,
+                              attrs: Attrs | null, marks: readonly Mark[]) {
+  let node = tr.doc.nodeAt(pos)
   if (!node) throw new RangeError("No node at given position")
   if (!type) type = node.type
   let newNode = type.create(attrs, null, marks || node.marks)
   if (node.isLeaf)
-    return this.replaceWith(pos, pos + node.nodeSize, newNode)
+    return tr.replaceWith(pos, pos + node.nodeSize, newNode)
 
   if (!type.validContent(node.content))
     throw new RangeError("Invalid content for node type " + type.name)
 
-  return this.step(new ReplaceAroundStep(pos, pos + node.nodeSize, pos + 1, pos + node.nodeSize - 1,
-                                         new Slice(Fragment.from(newNode), 0, 0), 1, true))
+  tr.step(new ReplaceAroundStep(pos, pos + node.nodeSize, pos + 1, pos + node.nodeSize - 1,
+                                new Slice(Fragment.from(newNode), 0, 0), 1, true))
 }
 
-// :: (Node, number, number, ?[?{type: NodeType, attrs: ?Object}]) → bool
-// Check whether splitting at the given position is allowed.
-export function canSplit(doc, pos, depth = 1, typesAfter) {
+/// Check whether splitting at the given position is allowed.
+export function canSplit(doc: Node, pos: number, depth = 1,
+                         typesAfter?: (null | {type: NodeType, attrs?: Attrs | null})[]): boolean {
   let $pos = doc.resolve(pos), base = $pos.depth - depth
   let innerType = (typesAfter && typesAfter[typesAfter.length - 1]) || $pos.parent
   if (base < 0 || $pos.parent.type.spec.isolating ||
@@ -182,40 +173,32 @@ export function canSplit(doc, pos, depth = 1, typesAfter) {
   return $pos.node(base).canReplaceWith(index, index, baseType ? baseType.type : $pos.node(base + 1).type)
 }
 
-// :: (number, ?number, ?[?{type: NodeType, attrs: ?Object}]) → this
-// Split the node at the given position, and optionally, if `depth` is
-// greater than one, any number of nodes above that. By default, the
-// parts split off will inherit the node type of the original node.
-// This can be changed by passing an array of types and attributes to
-// use after the split.
-Transform.prototype.split = function(pos, depth = 1, typesAfter) {
-  let $pos = this.doc.resolve(pos), before = Fragment.empty, after = Fragment.empty
+export function split(tr: Transform, pos: number, depth = 1, typesAfter?: (null | {type: NodeType, attrs?: Attrs | null})[]) {
+  let $pos = tr.doc.resolve(pos), before = Fragment.empty, after = Fragment.empty
   for (let d = $pos.depth, e = $pos.depth - depth, i = depth - 1; d > e; d--, i--) {
     before = Fragment.from($pos.node(d).copy(before))
     let typeAfter = typesAfter && typesAfter[i]
     after = Fragment.from(typeAfter ? typeAfter.type.create(typeAfter.attrs, after) : $pos.node(d).copy(after))
   }
-  return this.step(new ReplaceStep(pos, pos, new Slice(before.append(after), depth, depth), true))
+  tr.step(new ReplaceStep(pos, pos, new Slice(before.append(after), depth, depth), true))
 }
 
-// :: (Node, number) → bool
-// Test whether the blocks before and after a given position can be
-// joined.
-export function canJoin(doc, pos) {
+/// Test whether the blocks before and after a given position can be
+/// joined.
+export function canJoin(doc: Node, pos: number): boolean {
   let $pos = doc.resolve(pos), index = $pos.index()
   return joinable($pos.nodeBefore, $pos.nodeAfter) &&
     $pos.parent.canReplace(index, index + 1)
 }
 
-function joinable(a, b) {
-  return a && b && !a.isLeaf && a.canAppend(b)
+function joinable(a: Node | null, b: Node | null) {
+  return !!(a && b && !a.isLeaf && a.canAppend(b))
 }
 
-// :: (Node, number, ?number) → ?number
-// Find an ancestor of the given position that can be joined to the
-// block before (or after if `dir` is positive). Returns the joinable
-// point, if any.
-export function joinPoint(doc, pos, dir = -1) {
+/// Find an ancestor of the given position that can be joined to the
+/// block before (or after if `dir` is positive). Returns the joinable
+/// point, if any.
+export function joinPoint(doc: Node, pos: number, dir = -1) {
   let $pos = doc.resolve(pos)
   for (let d = $pos.depth;; d--) {
     let before, after, index = $pos.index(d)
@@ -237,20 +220,16 @@ export function joinPoint(doc, pos, dir = -1) {
   }
 }
 
-// :: (number, ?number) → this
-// Join the blocks around the given position. If depth is 2, their
-// last and first siblings are also joined, and so on.
-Transform.prototype.join = function(pos, depth = 1) {
+export function join(tr: Transform, pos: number, depth: number) {
   let step = new ReplaceStep(pos - depth, pos + depth, Slice.empty, true)
-  return this.step(step)
+  tr.step(step)
 }
 
-// :: (Node, number, NodeType) → ?number
-// Try to find a point where a node of the given type can be inserted
-// near `pos`, by searching up the node hierarchy when `pos` itself
-// isn't a valid place but is at the start or end of a node. Return
-// null if no position was found.
-export function insertPoint(doc, pos, nodeType) {
+/// Try to find a point where a node of the given type can be inserted
+/// near `pos`, by searching up the node hierarchy when `pos` itself
+/// isn't a valid place but is at the start or end of a node. Return
+/// null if no position was found.
+export function insertPoint(doc: Node, pos: number, nodeType: NodeType): number | null {
   let $pos = doc.resolve(pos)
   if ($pos.parent.canReplaceWith($pos.index(), $pos.index(), nodeType)) return pos
 
@@ -266,27 +245,27 @@ export function insertPoint(doc, pos, nodeType) {
       if ($pos.node(d).canReplaceWith(index, index, nodeType)) return $pos.after(d + 1)
       if (index < $pos.node(d).childCount) return null
     }
+  return null
 }
 
-// :: (Node, number, Slice) → ?number
-// Finds a position at or around the given position where the given
-// slice can be inserted. Will look at parent nodes' nearest boundary
-// and try there, even if the original position wasn't directly at the
-// start or end of that node. Returns null when no position was found.
-export function dropPoint(doc, pos, slice) {
+/// Finds a position at or around the given position where the given
+/// slice can be inserted. Will look at parent nodes' nearest boundary
+/// and try there, even if the original position wasn't directly at the
+/// start or end of that node. Returns null when no position was found.
+export function dropPoint(doc: Node, pos: number, slice: Slice): number | null {
   let $pos = doc.resolve(pos)
   if (!slice.content.size) return pos
   let content = slice.content
-  for (let i = 0; i < slice.openStart; i++) content = content.firstChild.content
+  for (let i = 0; i < slice.openStart; i++) content = content.firstChild!.content
   for (let pass = 1; pass <= (slice.openStart == 0 && slice.size ? 2 : 1); pass++) {
     for (let d = $pos.depth; d >= 0; d--) {
       let bias = d == $pos.depth ? 0 : $pos.pos <= ($pos.start(d + 1) + $pos.end(d + 1)) / 2 ? -1 : 1
       let insertPos = $pos.index(d) + (bias > 0 ? 1 : 0)
-      let parent = $pos.node(d), fits = false
+      let parent = $pos.node(d), fits: boolean | null = false
       if (pass == 1) {
         fits = parent.canReplace(insertPos, insertPos, content)
       } else {
-        let wrapping = parent.contentMatchAt(insertPos).findWrapping(content.firstChild.type)
+        let wrapping = parent.contentMatchAt(insertPos).findWrapping(content.firstChild!.type)
         fits = wrapping && parent.canReplaceWith(insertPos, insertPos, wrapping[0])
       }
       if (fits)

package/src/transform.ts

@@ -0,0 +1,212 @@
+import {Node, NodeType, Mark, MarkType, ContentMatch, Slice, Fragment, NodeRange, Attrs} from "prosemirror-model"
+
+import {Mapping} from "./map"
+import {Step} from "./step"
+import {addMark, removeMark, clearIncompatible} from "./mark"
+import {replaceStep, replaceRange, replaceRangeWith, deleteRange} from "./replace"
+import {lift, wrap, setBlockType, setNodeMarkup, split, join} from "./structure"
+
+/// @internal
+export let TransformError = class extends Error {}
+
+TransformError = function TransformError(this: any, message: string) {
+  let err = Error.call(this, message)
+  ;(err as any).__proto__ = TransformError.prototype
+  return err
+} as any
+
+TransformError.prototype = Object.create(Error.prototype)
+TransformError.prototype.constructor = TransformError
+TransformError.prototype.name = "TransformError"
+
+/// Abstraction to build up and track an array of
+/// [steps](#transform.Step) representing a document transformation.
+///
+/// Most transforming methods return the `Transform` object itself, so
+/// that they can be chained.
+export class Transform {
+  /// The steps in this transform.
+  readonly steps: Step[] = []
+  /// The documents before each of the steps.
+  readonly docs: Node[] = []
+  /// A mapping with the maps for each of the steps in this transform.
+  readonly mapping: Mapping = new Mapping
+
+  /// Create a transform that starts with the given document.
+  constructor(
+    /// The current document (the result of applying the steps in the
+    /// transform).
+    public doc: Node
+  ) {}
+
+  /// The starting document.
+  get before() { return this.docs.length ? this.docs[0] : this.doc }
+
+  /// Apply a new step in this transform, saving the result. Throws an
+  /// error when the step fails.
+  step(step: Step) {
+    let result = this.maybeStep(step)
+    if (result.failed) throw new TransformError(result.failed)
+    return this
+  }
+
+  /// Try to apply a step in this transformation, ignoring it if it
+  /// fails. Returns the step result.
+  maybeStep(step: Step) {
+    let result = step.apply(this.doc)
+    if (!result.failed) this.addStep(step, result.doc!)
+    return result
+  }
+
+  /// True when the document has been changed (when there are any
+  /// steps).
+  get docChanged() {
+    return this.steps.length > 0
+  }
+
+  /// @internal
+  addStep(step: Step, doc: Node) {
+    this.docs.push(this.doc)
+    this.steps.push(step)
+    this.mapping.appendMap(step.getMap())
+    this.doc = doc
+  }
+
+  /// Replace the part of the document between `from` and `to` with the
+  /// given `slice`.
+  replace(from: number, to = from, slice = Slice.empty): this {
+    let step = replaceStep(this.doc, from, to, slice)
+    if (step) this.step(step)
+    return this
+  }
+
+  /// Replace the given range with the given content, which may be a
+  /// fragment, node, or array of nodes.
+  replaceWith(from: number, to: number, content: Fragment | Node | readonly Node[]): this {
+    return this.replace(from, to, new Slice(Fragment.from(content), 0, 0))
+  }
+
+  /// Delete the content between the given positions.
+  delete(from: number, to: number): this {
+    return this.replace(from, to, Slice.empty)
+  }
+
+  /// Insert the given content at the given position.
+  insert(pos: number, content: Fragment | Node | readonly Node[]): this {
+    return this.replaceWith(pos, pos, content)
+  }
+
+  /// Replace a range of the document with a given slice, using
+  /// `from`, `to`, and the slice's
+  /// [`openStart`](#model.Slice.openStart) property as hints, rather
+  /// than fixed start and end points. This method may grow the
+  /// replaced area or close open nodes in the slice in order to get a
+  /// fit that is more in line with WYSIWYG expectations, by dropping
+  /// fully covered parent nodes of the replaced region when they are
+  /// marked [non-defining as
+  /// context](#model.NodeSpec.definingAsContext), or including an
+  /// open parent node from the slice that _is_ marked as [defining
+  /// its content](#model.NodeSpec.definingForContent).
+  ///
+  /// This is the method, for example, to handle paste. The similar
+  /// [`replace`](#transform.Transform.replace) method is a more
+  /// primitive tool which will _not_ move the start and end of its given
+  /// range, and is useful in situations where you need more precise
+  /// control over what happens.
+  replaceRange(from: number, to: number, slice: Slice): this {
+    replaceRange(this, from, to, slice)
+    return this
+  }
+
+  /// Replace the given range with a node, but use `from` and `to` as
+  /// hints, rather than precise positions. When from and to are the same
+  /// and are at the start or end of a parent node in which the given
+  /// node doesn't fit, this method may _move_ them out towards a parent
+  /// that does allow the given node to be placed. When the given range
+  /// completely covers a parent node, this method may completely replace
+  /// that parent node.
+  replaceRangeWith(from: number, to: number, node: Node): this {
+    replaceRangeWith(this, from, to, node)
+    return this
+  }
+
+  /// Delete the given range, expanding it to cover fully covered
+  /// parent nodes until a valid replace is found.
+  deleteRange(from: number, to: number): this {
+    deleteRange(this, from, to)
+    return this
+  }
+
+  /// Split the content in the given range off from its parent, if there
+  /// is sibling content before or after it, and move it up the tree to
+  /// the depth specified by `target`. You'll probably want to use
+  /// [`liftTarget`](#transform.liftTarget) to compute `target`, to make
+  /// sure the lift is valid.
+  lift(range: NodeRange, target: number): this {
+    lift(this, range, target)
+    return this
+  }
+
+  /// Join the blocks around the given position. If depth is 2, their
+  /// last and first siblings are also joined, and so on.
+  join(pos: number, depth: number = 1): this {
+    join(this, pos, depth)
+    return this
+  }
+
+  /// Wrap the given [range](#model.NodeRange) in the given set of wrappers.
+  /// The wrappers are assumed to be valid in this position, and should
+  /// probably be computed with [`findWrapping`](#transform.findWrapping).
+  wrap(range: NodeRange, wrappers: readonly {type: NodeType, attrs?: Attrs | null}[]): this {
+    wrap(this, range, wrappers)
+    return this
+  }
+
+  /// Set the type of all textblocks (partly) between `from` and `to` to
+  /// the given node type with the given attributes.
+  setBlockType(from: number, to = from, type: NodeType, attrs: Attrs | null = null): this {
+    setBlockType(this, from, to, type, attrs)
+    return this
+  }
+
+  /// Change the type, attributes, and/or marks of the node at `pos`.
+  /// When `type` isn't given, the existing node type is preserved,
+  setNodeMarkup(pos: number, type?: NodeType | null, attrs: Attrs | null = null, marks: readonly Mark[] = []): this {
+    setNodeMarkup(this, pos, type, attrs, marks)
+    return this
+  }
+
+  /// Split the node at the given position, and optionally, if `depth` is
+  /// greater than one, any number of nodes above that. By default, the
+  /// parts split off will inherit the node type of the original node.
+  /// This can be changed by passing an array of types and attributes to
+  /// use after the split.
+  split(pos: number, depth = 1, typesAfter?: (null | {type: NodeType, attrs?: Attrs | null})[]) {
+    split(this, pos, depth, typesAfter)
+    return this
+  }
+
+  /// Add the given mark to the inline content between `from` and `to`.
+  addMark(from: number, to: number, mark: Mark): this {
+    addMark(this, from, to, mark)
+    return this
+  }
+
+  /// Remove marks from inline nodes between `from` and `to`. When
+  /// `mark` is a single mark, remove precisely that mark. When it is
+  /// a mark type, remove all marks of that type. When it is null,
+  /// remove all marks of any type.
+  removeMark(from: number, to: number, mark?: Mark | MarkType | null) {
+    removeMark(this, from, to, mark)
+    return this
+  }
+
+  /// Removes all marks and nodes from the content of the node at
+  /// `pos` that don't match the given new parent node type. Accepts
+  /// an optional starting [content match](#model.ContentMatch) as
+  /// third argument.
+  clearIncompatible(pos: number, parentType: NodeType, match?: ContentMatch) {
+    clearIncompatible(this, pos, parentType, match)
+    return this
+  }
+}

package/rollup.config.js

@@ -1,14 +0,0 @@
-module.exports = {
-  input: './src/index.js',
-  output: [{
-    file: 'dist/index.js',
-    format: 'cjs',
-    sourcemap: true
-  }, {
-    file: 'dist/index.es.js',
-    format: 'es',
-    sourcemap: true
-  }],
-  plugins: [require('@rollup/plugin-buble')()],
-  external(id) { return id[0] != "." && !require("path").isAbsolute(id) }
-}