prosemirror-transform 1.4.0 → 1.5.0-beta.1

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

@@ -1,33 +1,31 @@
-import {Slice} from "prosemirror-model"
+import {Slice, Node, Schema} from "prosemirror-model"
 
 import {Step, StepResult} from "./step"
-import {StepMap} from "./map"
+import {StepMap, Mappable} from "./map"
 
-// ::- Replace a part of the document with a slice of new content.
+/// Replace a part of the document with a slice of new content.
 export class ReplaceStep extends Step {
-  // :: (number, number, Slice, ?bool)
-  // The given `slice` should fit the 'gap' between `from` and
-  // `to`—the depths must line up, and the surrounding nodes must be
-  // able to be joined with the open sides of the slice. When
-  // `structure` is true, the step will fail if the content between
-  // from and to is not just a sequence of closing and then opening
-  // tokens (this is to guard against rebased replace steps
-  // overwriting something they weren't supposed to).
-  constructor(from, to, slice, structure) {
+  /// The given `slice` should fit the 'gap' between `from` and
+  /// `to`—the depths must line up, and the surrounding nodes must be
+  /// able to be joined with the open sides of the slice. When
+  /// `structure` is true, the step will fail if the content between
+  /// from and to is not just a sequence of closing and then opening
+  /// tokens (this is to guard against rebased replace steps
+  /// overwriting something they weren't supposed to).
+  constructor(
+    /// The start position of the replaced range.
+    readonly from: number,
+    /// The end position of the replaced range.
+    readonly to: number,
+    /// The slice to insert.
+    readonly slice: Slice,
+    /// @internal
+    readonly structure = false
+  ) {
     super()
-    // :: number
-    // The start position of the replaced range.
-    this.from = from
-    // :: number
-    // The end position of the replaced range.
-    this.to = to
-    // :: Slice
-    // The slice to insert.
-    this.slice = slice
-    this.structure = !!structure
-  }
-
-  apply(doc) {
+  }
+
+  apply(doc: Node) {
     if (this.structure && contentBetween(doc, this.from, this.to))
       return StepResult.fail("Structure replace would overwrite content")
     return StepResult.fromReplace(doc, this.from, this.to, this.slice)
@@ -37,17 +35,17 @@ export class ReplaceStep extends Step {
     return new StepMap([this.from, this.to - this.from, this.slice.size])
   }
 
-  invert(doc) {
+  invert(doc: Node) {
     return new ReplaceStep(this.from, this.from + this.slice.size, doc.slice(this.from, this.to))
   }
 
-  map(mapping) {
+  map(mapping: Mappable) {
     let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1)
     if (from.deleted && to.deleted) return null
     return new ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice)
   }
 
-  merge(other) {
+  merge(other: Step) {
     if (!(other instanceof ReplaceStep) || other.structure || this.structure) return null
 
     if (this.from + this.slice.size == other.from && !this.slice.openEnd && !other.slice.openStart) {
@@ -63,14 +61,15 @@ export class ReplaceStep extends Step {
     }
   }
 
-  toJSON() {
-    let json = {stepType: "replace", from: this.from, to: this.to}
+  toJSON(): any {
+    let json: any = {stepType: "replace", from: this.from, to: this.to}
     if (this.slice.size) json.slice = this.slice.toJSON()
     if (this.structure) json.structure = true
     return json
   }
 
-  static fromJSON(schema, json) {
+  /// @internal
+  static fromJSON(schema: Schema, json: any) {
     if (typeof json.from != "number" || typeof json.to != "number")
       throw new RangeError("Invalid input for ReplaceStep.fromJSON")
     return new ReplaceStep(json.from, json.to, Slice.fromJSON(schema, json.slice), !!json.structure)
@@ -79,40 +78,35 @@ export class ReplaceStep extends Step {
 
 Step.jsonID("replace", ReplaceStep)
 
-// ::- Replace a part of the document with a slice of content, but
-// preserve a range of the replaced content by moving it into the
-// slice.
+/// Replace a part of the document with a slice of content, but
+/// preserve a range of the replaced content by moving it into the
+/// slice.
 export class ReplaceAroundStep extends Step {
-  // :: (number, number, number, number, Slice, number, ?bool)
-  // Create a replace-around step with the given range and gap.
-  // `insert` should be the point in the slice into which the content
-  // of the gap should be moved. `structure` has the same meaning as
-  // it has in the [`ReplaceStep`](#transform.ReplaceStep) class.
-  constructor(from, to, gapFrom, gapTo, slice, insert, structure) {
+  /// Create a replace-around step with the given range and gap.
+  /// `insert` should be the point in the slice into which the content
+  /// of the gap should be moved. `structure` has the same meaning as
+  /// it has in the [`ReplaceStep`](#transform.ReplaceStep) class.
+  constructor(
+    /// The start position of the replaced range.
+    readonly from: number,
+    /// The end position of the replaced range.
+    readonly to: number,
+    /// The start of preserved range.
+    readonly gapFrom: number,
+    /// The end of preserved range.
+    readonly gapTo: number,
+    /// The slice to insert.
+    readonly slice: Slice,
+    /// The position in the slice where the preserved range should be
+    /// inserted.
+    readonly insert: number,
+    /// @internal
+    readonly structure = false
+  ) {
     super()
-    // :: number
-    // The start position of the replaced range.
-    this.from = from
-    // :: number
-    // The end position of the replaced range.
-    this.to = to
-    // :: number
-    // The start of preserved range.
-    this.gapFrom = gapFrom
-    // :: number
-    // The end of preserved range.
-    this.gapTo = gapTo
-    // :: Slice
-    // The slice to insert.
-    this.slice = slice
-    // :: number
-    // The position in the slice where the preserved range should be
-    // inserted.
-    this.insert = insert
-    this.structure = !!structure
-  }
-
-  apply(doc) {
+  }
+
+  apply(doc: Node) {
     if (this.structure && (contentBetween(doc, this.from, this.gapFrom) ||
                            contentBetween(doc, this.gapTo, this.to)))
       return StepResult.fail("Structure gap-replace would overwrite content")
@@ -130,7 +124,7 @@ export class ReplaceAroundStep extends Step {
                         this.gapTo, this.to - this.gapTo, this.slice.size - this.insert])
   }
 
-  invert(doc) {
+  invert(doc: Node) {
     let gap = this.gapTo - this.gapFrom
     return new ReplaceAroundStep(this.from, this.from + this.slice.size + gap,
                                  this.from + this.insert, this.from + this.insert + gap,
@@ -138,22 +132,23 @@ export class ReplaceAroundStep extends Step {
                                  this.gapFrom - this.from, this.structure)
   }
 
-  map(mapping) {
+  map(mapping: Mappable) {
     let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1)
     let gapFrom = mapping.map(this.gapFrom, -1), gapTo = mapping.map(this.gapTo, 1)
     if ((from.deleted && to.deleted) || gapFrom < from.pos || gapTo > to.pos) return null
     return new ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure)
   }
 
-  toJSON() {
-    let json = {stepType: "replaceAround", from: this.from, to: this.to,
-                gapFrom: this.gapFrom, gapTo: this.gapTo, insert: this.insert}
+  toJSON(): any {
+    let json: any = {stepType: "replaceAround", from: this.from, to: this.to,
+                     gapFrom: this.gapFrom, gapTo: this.gapTo, insert: this.insert}
     if (this.slice.size) json.slice = this.slice.toJSON()
     if (this.structure) json.structure = true
     return json
   }
 
-  static fromJSON(schema, json) {
+  /// @internal
+  static fromJSON(schema: Schema, json: any) {
     if (typeof json.from != "number" || typeof json.to != "number" ||
         typeof json.gapFrom != "number" || typeof json.gapTo != "number" || typeof json.insert != "number")
       throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON")
@@ -164,7 +159,7 @@ export class ReplaceAroundStep extends Step {
 
 Step.jsonID("replaceAround", ReplaceAroundStep)
 
-function contentBetween(doc, from, to) {
+function contentBetween(doc: Node, from: number, to: number) {
   let $from = doc.resolve(from), dist = to - from, depth = $from.depth
   while (dist > 0 && depth > 0 && $from.indexAfter(depth) == $from.node(depth).childCount) {
     depth--

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)