prosemirror-transform 1.4.0 → 1.5.0-beta.1

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) }
-}

package/src/map.js

@@ -1,264 +0,0 @@
-// Mappable:: interface
-// There are several things that positions can be mapped through.
-// Such objects conform to this interface.
-//
-//   map:: (pos: number, assoc: ?number) → number
-//   Map a position through this object. When given, `assoc` (should
-//   be -1 or 1, defaults to 1) determines with which side the
-//   position is associated, which determines in which direction to
-//   move when a chunk of content is inserted at the mapped position.
-//
-//   mapResult:: (pos: number, assoc: ?number) → MapResult
-//   Map a position, and return an object containing additional
-//   information about the mapping. The result's `deleted` field tells
-//   you whether the position was deleted (completely enclosed in a
-//   replaced range) during the mapping. When content on only one side
-//   is deleted, the position itself is only considered deleted when
-//   `assoc` points in the direction of the deleted content.
-
-// Recovery values encode a range index and an offset. They are
-// represented as numbers, because tons of them will be created when
-// mapping, for example, a large number of decorations. The number's
-// lower 16 bits provide the index, the remaining bits the offset.
-//
-// Note: We intentionally don't use bit shift operators to en- and
-// decode these, since those clip to 32 bits, which we might in rare
-// cases want to overflow. A 64-bit float can represent 48-bit
-// integers precisely.
-
-const lower16 = 0xffff
-const factor16 = Math.pow(2, 16)
-
-function makeRecover(index, offset) { return index + offset * factor16 }
-function recoverIndex(value) { return value & lower16 }
-function recoverOffset(value) { return (value - (value & lower16)) / factor16 }
-
-// ::- An object representing a mapped position with extra
-// information.
-export class MapResult {
-  constructor(pos, deleted = false, recover = null) {
-    // :: number The mapped version of the position.
-    this.pos = pos
-    // :: bool Tells you whether the position was deleted, that is,
-    // whether the step removed its surroundings from the document.
-    this.deleted = deleted
-    this.recover = recover
-  }
-}
-
-// :: class extends Mappable
-// A map describing the deletions and insertions made by a step, which
-// can be used to find the correspondence between positions in the
-// pre-step version of a document and the same position in the
-// post-step version.
-export class StepMap {
-  // :: ([number])
-  // Create a position map. The modifications to the document are
-  // represented as an array of numbers, in which each group of three
-  // represents a modified chunk as `[start, oldSize, newSize]`.
-  constructor(ranges, inverted = false) {
-    if (!ranges.length && StepMap.empty) return StepMap.empty
-    this.ranges = ranges
-    this.inverted = inverted
-  }
-
-  recover(value) {
-    let diff = 0, index = recoverIndex(value)
-    if (!this.inverted) for (let i = 0; i < index; i++)
-      diff += this.ranges[i * 3 + 2] - this.ranges[i * 3 + 1]
-    return this.ranges[index * 3] + diff + recoverOffset(value)
-  }
-
-  // : (number, ?number) → MapResult
-  mapResult(pos, assoc = 1) { return this._map(pos, assoc, false) }
-
-  // : (number, ?number) → number
-  map(pos, assoc = 1) { return this._map(pos, assoc, true) }
-
-  _map(pos, assoc, simple) {
-    let diff = 0, oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2
-    for (let i = 0; i < this.ranges.length; i += 3) {
-      let start = this.ranges[i] - (this.inverted ? diff : 0)
-      if (start > pos) break
-      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex], end = start + oldSize
-      if (pos <= end) {
-        let side = !oldSize ? assoc : pos == start ? -1 : pos == end ? 1 : assoc
-        let result = start + diff + (side < 0 ? 0 : newSize)
-        if (simple) return result
-        let recover = pos == (assoc < 0 ? start : end) ? null : makeRecover(i / 3, pos - start)
-        return new MapResult(result, assoc < 0 ? pos != start : pos != end, recover)
-      }
-      diff += newSize - oldSize
-    }
-    return simple ? pos + diff : new MapResult(pos + diff)
-  }
-
-  touches(pos, recover) {
-    let diff = 0, index = recoverIndex(recover)
-    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2
-    for (let i = 0; i < this.ranges.length; i += 3) {
-      let start = this.ranges[i] - (this.inverted ? diff : 0)
-      if (start > pos) break
-      let oldSize = this.ranges[i + oldIndex], end = start + oldSize
-      if (pos <= end && i == index * 3) return true
-      diff += this.ranges[i + newIndex] - oldSize
-    }
-    return false
-  }
-
-  // :: ((oldStart: number, oldEnd: number, newStart: number, newEnd: number))
-  // Calls the given function on each of the changed ranges included in
-  // this map.
-  forEach(f) {
-    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2
-    for (let i = 0, diff = 0; i < this.ranges.length; i += 3) {
-      let start = this.ranges[i], oldStart = start - (this.inverted ? diff : 0), newStart = start + (this.inverted ? 0 : diff)
-      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex]
-      f(oldStart, oldStart + oldSize, newStart, newStart + newSize)
-      diff += newSize - oldSize
-    }
-  }
-
-  // :: () → StepMap
-  // Create an inverted version of this map. The result can be used to
-  // map positions in the post-step document to the pre-step document.
-  invert() {
-    return new StepMap(this.ranges, !this.inverted)
-  }
-
-  toString() {
-    return (this.inverted ? "-" : "") + JSON.stringify(this.ranges)
-  }
-
-  // :: (n: number) → StepMap
-  // Create a map that moves all positions by offset `n` (which may be
-  // negative). This can be useful when applying steps meant for a
-  // sub-document to a larger document, or vice-versa.
-  static offset(n) {
-    return n == 0 ? StepMap.empty : new StepMap(n < 0 ? [0, -n, 0] : [0, 0, n])
-  }
-}
-
-// :: StepMap
-// A StepMap that contains no changed ranges.
-StepMap.empty = new StepMap([])
-
-// :: class extends Mappable
-// A mapping represents a pipeline of zero or more [step
-// maps](#transform.StepMap). It has special provisions for losslessly
-// handling mapping positions through a series of steps in which some
-// steps are inverted versions of earlier steps. (This comes up when
-// ‘[rebasing](/docs/guide/#transform.rebasing)’ steps for
-// collaboration or history management.)
-export class Mapping {
-  // :: (?[StepMap])
-  // Create a new mapping with the given position maps.
-  constructor(maps, mirror, from, to) {
-    // :: [StepMap]
-    // The step maps in this mapping.
-    this.maps = maps || []
-    // :: number
-    // The starting position in the `maps` array, used when `map` or
-    // `mapResult` is called.
-    this.from = from || 0
-    // :: number
-    // The end position in the `maps` array.
-    this.to = to == null ? this.maps.length : to
-    this.mirror = mirror
-  }
-
-  // :: (?number, ?number) → Mapping
-  // Create a mapping that maps only through a part of this one.
-  slice(from = 0, to = this.maps.length) {
-    return new Mapping(this.maps, this.mirror, from, to)
-  }
-
-  copy() {
-    return new Mapping(this.maps.slice(), this.mirror && this.mirror.slice(), this.from, this.to)
-  }
-
-  // :: (StepMap, ?number)
-  // Add a step map to the end of this mapping. If `mirrors` is
-  // given, it should be the index of the step map that is the mirror
-  // image of this one.
-  appendMap(map, mirrors) {
-    this.to = this.maps.push(map)
-    if (mirrors != null) this.setMirror(this.maps.length - 1, mirrors)
-  }
-
-  // :: (Mapping)
-  // Add all the step maps in a given mapping to this one (preserving
-  // mirroring information).
-  appendMapping(mapping) {
-    for (let i = 0, startSize = this.maps.length; i < mapping.maps.length; i++) {
-      let mirr = mapping.getMirror(i)
-      this.appendMap(mapping.maps[i], mirr != null && mirr < i ? startSize + mirr : null)
-    }
-  }
-
-  // :: (number) → ?number
-  // Finds the offset of the step map that mirrors the map at the
-  // given offset, in this mapping (as per the second argument to
-  // `appendMap`).
-  getMirror(n) {
-    if (this.mirror) for (let i = 0; i < this.mirror.length; i++)
-      if (this.mirror[i] == n) return this.mirror[i + (i % 2 ? -1 : 1)]
-  }
-
-  setMirror(n, m) {
-    if (!this.mirror) this.mirror = []
-    this.mirror.push(n, m)
-  }
-
-  // :: (Mapping)
-  // Append the inverse of the given mapping to this one.
-  appendMappingInverted(mapping) {
-    for (let i = mapping.maps.length - 1, totalSize = this.maps.length + mapping.maps.length; i >= 0; i--) {
-      let mirr = mapping.getMirror(i)
-      this.appendMap(mapping.maps[i].invert(), mirr != null && mirr > i ? totalSize - mirr - 1 : null)
-    }
-  }
-
-  // :: () → Mapping
-  // Create an inverted version of this mapping.
-  invert() {
-    let inverse = new Mapping
-    inverse.appendMappingInverted(this)
-    return inverse
-  }
-
-  // : (number, ?number) → number
-  // Map a position through this mapping.
-  map(pos, assoc = 1) {
-    if (this.mirror) return this._map(pos, assoc, true)
-    for (let i = this.from; i < this.to; i++)
-      pos = this.maps[i].map(pos, assoc)
-    return pos
-  }
-
-  // : (number, ?number) → MapResult
-  // Map a position through this mapping, returning a mapping
-  // result.
-  mapResult(pos, assoc = 1) { return this._map(pos, assoc, false) }
-
-  _map(pos, assoc, simple) {
-    let deleted = false
-
-    for (let i = this.from; i < this.to; i++) {
-      let map = this.maps[i], result = map.mapResult(pos, assoc)
-      if (result.recover != null) {
-        let corr = this.getMirror(i)
-        if (corr != null && corr > i && corr < this.to) {
-          i = corr
-          pos = this.maps[corr].recover(result.recover)
-          continue
-        }
-      }
-
-      if (result.deleted) deleted = true
-      pos = result.pos
-    }
-
-    return simple ? pos : new MapResult(pos, deleted)
-  }
-}

package/src/step.js

@@ -1,110 +0,0 @@
-import {ReplaceError} from "prosemirror-model"
-
-import {StepMap} from "./map"
-
-function mustOverride() { throw new Error("Override me") }
-
-const stepsByID = 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 class Step {
-  // :: (doc: Node) → StepResult
-  // 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.
-  apply(_doc) { return mustOverride() }
-
-  // :: () → StepMap
-  // 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() { return StepMap.empty }
-
-  // :: (doc: Node) → Step
-  // Create an inverted version of this step. Needs the document as it
-  // was before the step as argument.
-  invert(_doc) { return mustOverride() }
-
-  // :: (mapping: Mappable) → ?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.
-  map(_mapping) { return mustOverride() }
-
-  // :: (other: Step) → ?Step
-  // 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) { return null }
-
-  // :: () → Object
-  // 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.
-  toJSON() { return mustOverride() }
-
-  // :: (Schema, Object) → Step
-  // Deserialize a step from its JSON representation. Will call
-  // through to the step class' own implementation of this method.
-  static fromJSON(schema, json) {
-    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)
-  }
-
-  // :: (string, constructor<Step>)
-  // 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, stepClass) {
-    if (id in stepsByID) throw new RangeError("Duplicate use of step JSON ID " + id)
-    stepsByID[id] = stepClass
-    stepClass.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 {
-  // : (?Node, ?string)
-  constructor(doc, failed) {
-    // :: ?Node The transformed document.
-    this.doc = doc
-    // :: ?string Text providing information about a failed step.
-    this.failed = failed
-  }
-
-  // :: (Node) → StepResult
-  // Create a successful step result.
-  static ok(doc) { return new StepResult(doc, null) }
-
-  // :: (string) → StepResult
-  // Create a failed step result.
-  static fail(message) { return new StepResult(null, message) }
-
-  // :: (Node, number, number, Slice) → StepResult
-  // 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, from, to, 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/transform.js

@@ -1,71 +0,0 @@
-import {Mapping} from "./map"
-
-export function TransformError(message) {
-  let err = Error.call(this, message)
-  err.__proto__ = TransformError.prototype
-  return err
-}
-
-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 {
-  // :: (Node)
-  // Create a transform that starts with the given document.
-  constructor(doc) {
-    // :: Node
-    // The current document (the result of applying the steps in the
-    // transform).
-    this.doc = doc
-    // :: [Step]
-    // The steps in this transform.
-    this.steps = []
-    // :: [Node]
-    // The documents before each of the steps.
-    this.docs = []
-    // :: Mapping
-    // A mapping with the maps for each of the steps in this transform.
-    this.mapping = new Mapping
-  }
-
-  // :: Node The starting document.
-  get before() { return this.docs.length ? this.docs[0] : this.doc }
-
-  // :: (step: Step) → this
-  // Apply a new step in this transform, saving the result. Throws an
-  // error when the step fails.
-  step(object) {
-    let result = this.maybeStep(object)
-    if (result.failed) throw new TransformError(result.failed)
-    return this
-  }
-
-  // :: (Step) → StepResult
-  // Try to apply a step in this transformation, ignoring it if it
-  // fails. Returns the step result.
-  maybeStep(step) {
-    let result = step.apply(this.doc)
-    if (!result.failed) this.addStep(step, result.doc)
-    return result
-  }
-
-  // :: bool
-  // True when the document has been changed (when there are any
-  // steps).
-  get docChanged() {
-    return this.steps.length > 0
-  }
-
-  addStep(step, doc) {
-    this.docs.push(this.doc)
-    this.steps.push(step)
-    this.mapping.appendMap(step.getMap())
-    this.doc = doc
-  }
-}