prosemirror-transform 1.5.0-beta.1 → 1.7.0

package/dist/index.es.js

@@ -1,1702 +0,0 @@
-import { ReplaceError, Slice, Fragment, MarkType } from 'prosemirror-model';
-
-// 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.
-
-var lower16 = 0xffff;
-var 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.
-var MapResult = function MapResult(pos, deleted, recover) {
-  if ( deleted === void 0 ) deleted = false;
-  if ( recover === void 0 ) 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.
-var StepMap = function StepMap(ranges, inverted) {
-  if ( inverted === void 0 ) inverted = false;
-
-  if (!ranges.length && StepMap.empty) { return StepMap.empty }
-  this.ranges = ranges;
-  this.inverted = inverted;
-};
-
-StepMap.prototype.recover = function recover (value) {
-  var diff = 0, index = recoverIndex(value);
-  if (!this.inverted) { for (var 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
-StepMap.prototype.mapResult = function mapResult (pos, assoc) {
-  if ( assoc === void 0 ) assoc = 1;
- return this._map(pos, assoc, false) };
-
-// : (number, ?number) → number
-StepMap.prototype.map = function map (pos, assoc) {
-  if ( assoc === void 0 ) assoc = 1;
- return this._map(pos, assoc, true) };
-
-StepMap.prototype._map = function _map (pos, assoc, simple) {
-  var diff = 0, oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-  for (var i = 0; i < this.ranges.length; i += 3) {
-    var start = this.ranges[i] - (this.inverted ? diff : 0);
-    if (start > pos) { break }
-    var oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex], end = start + oldSize;
-    if (pos <= end) {
-      var side = !oldSize ? assoc : pos == start ? -1 : pos == end ? 1 : assoc;
-      var result = start + diff + (side < 0 ? 0 : newSize);
-      if (simple) { return result }
-      var 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)
-};
-
-StepMap.prototype.touches = function touches (pos, recover) {
-  var diff = 0, index = recoverIndex(recover);
-  var oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-  for (var i = 0; i < this.ranges.length; i += 3) {
-    var start = this.ranges[i] - (this.inverted ? diff : 0);
-    if (start > pos) { break }
-    var 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.
-StepMap.prototype.forEach = function forEach (f) {
-  var oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-  for (var i = 0, diff = 0; i < this.ranges.length; i += 3) {
-    var start = this.ranges[i], oldStart = start - (this.inverted ? diff : 0), newStart = start + (this.inverted ? 0 : diff);
-    var 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.
-StepMap.prototype.invert = function invert () {
-  return new StepMap(this.ranges, !this.inverted)
-};
-
-StepMap.prototype.toString = function 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.
-StepMap.offset = function 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.)
-var Mapping = function Mapping(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.
-Mapping.prototype.slice = function slice (from, to) {
-    if ( from === void 0 ) from = 0;
-    if ( to === void 0 ) to = this.maps.length;
-
-  return new Mapping(this.maps, this.mirror, from, to)
-};
-
-Mapping.prototype.copy = function 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.
-Mapping.prototype.appendMap = function 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).
-Mapping.prototype.appendMapping = function appendMapping (mapping) {
-  for (var i = 0, startSize = this.maps.length; i < mapping.maps.length; i++) {
-    var 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`).
-Mapping.prototype.getMirror = function getMirror (n) {
-  if (this.mirror) { for (var i = 0; i < this.mirror.length; i++)
-    { if (this.mirror[i] == n) { return this.mirror[i + (i % 2 ? -1 : 1)] } } }
-};
-
-Mapping.prototype.setMirror = function setMirror (n, m) {
-  if (!this.mirror) { this.mirror = []; }
-  this.mirror.push(n, m);
-};
-
-// :: (Mapping)
-// Append the inverse of the given mapping to this one.
-Mapping.prototype.appendMappingInverted = function appendMappingInverted (mapping) {
-  for (var i = mapping.maps.length - 1, totalSize = this.maps.length + mapping.maps.length; i >= 0; i--) {
-    var 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.
-Mapping.prototype.invert = function invert () {
-  var inverse = new Mapping;
-  inverse.appendMappingInverted(this);
-  return inverse
-};
-
-// : (number, ?number) → number
-// Map a position through this mapping.
-Mapping.prototype.map = function map (pos, assoc) {
-    if ( assoc === void 0 ) assoc = 1;
-
-  if (this.mirror) { return this._map(pos, assoc, true) }
-  for (var 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.
-Mapping.prototype.mapResult = function mapResult (pos, assoc) {
-  if ( assoc === void 0 ) assoc = 1;
- return this._map(pos, assoc, false) };
-
-Mapping.prototype._map = function _map (pos, assoc, simple) {
-  var deleted = false;
-
-  for (var i = this.from; i < this.to; i++) {
-    var map = this.maps[i], result = map.mapResult(pos, assoc);
-    if (result.recover != null) {
-      var 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)
-};
-
-function TransformError(message) {
-  var 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.
-var Transform = function Transform(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;
-};
-
-var prototypeAccessors$1 = { before: { configurable: true },docChanged: { configurable: true } };
-
-// :: Node The starting document.
-prototypeAccessors$1.before.get = function () { 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.
-Transform.prototype.step = function step (object) {
-  var 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.
-Transform.prototype.maybeStep = function maybeStep (step) {
-  var 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).
-prototypeAccessors$1.docChanged.get = function () {
-  return this.steps.length > 0
-};
-
-Transform.prototype.addStep = function addStep (step, doc) {
-  this.docs.push(this.doc);
-  this.steps.push(step);
-  this.mapping.appendMap(step.getMap());
-  this.doc = doc;
-};
-
-Object.defineProperties( Transform.prototype, prototypeAccessors$1 );
-
-function mustOverride() { throw new Error("Override me") }
-
-var 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).
-var Step = function Step () {};
-
-Step.prototype.apply = function 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.
-Step.prototype.getMap = function 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.
-Step.prototype.invert = function 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.
-Step.prototype.map = function 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.
-Step.prototype.merge = function 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.
-Step.prototype.toJSON = function 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.
-Step.fromJSON = function fromJSON (schema, json) {
-  if (!json || !json.stepType) { throw new RangeError("Invalid input for Step.fromJSON") }
-  var 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.
-Step.jsonID = function 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.
-var StepResult = function StepResult(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.
-StepResult.ok = function ok (doc) { return new StepResult(doc, null) };
-
-// :: (string) → StepResult
-// Create a failed step result.
-StepResult.fail = function 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`.
-StepResult.fromReplace = function 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
-  }
-};
-
-// ::- Replace a part of the document with a slice of new content.
-var ReplaceStep = /*@__PURE__*/(function (Step) {
-  function ReplaceStep(from, to, slice, structure) {
-    Step.call(this);
-    // :: 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;
-  }
-
-  if ( Step ) ReplaceStep.__proto__ = Step;
-  ReplaceStep.prototype = Object.create( Step && Step.prototype );
-  ReplaceStep.prototype.constructor = ReplaceStep;
-
-  ReplaceStep.prototype.apply = function apply (doc) {
-    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)
-  };
-
-  ReplaceStep.prototype.getMap = function getMap () {
-    return new StepMap([this.from, this.to - this.from, this.slice.size])
-  };
-
-  ReplaceStep.prototype.invert = function invert (doc) {
-    return new ReplaceStep(this.from, this.from + this.slice.size, doc.slice(this.from, this.to))
-  };
-
-  ReplaceStep.prototype.map = function map (mapping) {
-    var 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)
-  };
-
-  ReplaceStep.prototype.merge = function merge (other) {
-    if (!(other instanceof ReplaceStep) || other.structure || this.structure) { return null }
-
-    if (this.from + this.slice.size == other.from && !this.slice.openEnd && !other.slice.openStart) {
-      var slice = this.slice.size + other.slice.size == 0 ? Slice.empty
-          : new Slice(this.slice.content.append(other.slice.content), this.slice.openStart, other.slice.openEnd);
-      return new ReplaceStep(this.from, this.to + (other.to - other.from), slice, this.structure)
-    } else if (other.to == this.from && !this.slice.openStart && !other.slice.openEnd) {
-      var slice$1 = this.slice.size + other.slice.size == 0 ? Slice.empty
-          : new Slice(other.slice.content.append(this.slice.content), other.slice.openStart, this.slice.openEnd);
-      return new ReplaceStep(other.from, this.to, slice$1, this.structure)
-    } else {
-      return null
-    }
-  };
-
-  ReplaceStep.prototype.toJSON = function toJSON () {
-    var json = {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
-  };
-
-  ReplaceStep.fromJSON = function fromJSON (schema, json) {
-    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)
-  };
-
-  return ReplaceStep;
-}(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.
-var ReplaceAroundStep = /*@__PURE__*/(function (Step) {
-  function ReplaceAroundStep(from, to, gapFrom, gapTo, slice, insert, structure) {
-    Step.call(this);
-    // :: 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;
-  }
-
-  if ( Step ) ReplaceAroundStep.__proto__ = Step;
-  ReplaceAroundStep.prototype = Object.create( Step && Step.prototype );
-  ReplaceAroundStep.prototype.constructor = ReplaceAroundStep;
-
-  ReplaceAroundStep.prototype.apply = function apply (doc) {
-    if (this.structure && (contentBetween(doc, this.from, this.gapFrom) ||
-                           contentBetween(doc, this.gapTo, this.to)))
-      { return StepResult.fail("Structure gap-replace would overwrite content") }
-
-    var gap = doc.slice(this.gapFrom, this.gapTo);
-    if (gap.openStart || gap.openEnd)
-      { return StepResult.fail("Gap is not a flat range") }
-    var inserted = this.slice.insertAt(this.insert, gap.content);
-    if (!inserted) { return StepResult.fail("Content does not fit in gap") }
-    return StepResult.fromReplace(doc, this.from, this.to, inserted)
-  };
-
-  ReplaceAroundStep.prototype.getMap = function getMap () {
-    return new StepMap([this.from, this.gapFrom - this.from, this.insert,
-                        this.gapTo, this.to - this.gapTo, this.slice.size - this.insert])
-  };
-
-  ReplaceAroundStep.prototype.invert = function invert (doc) {
-    var 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,
-                                 doc.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from),
-                                 this.gapFrom - this.from, this.structure)
-  };
-
-  ReplaceAroundStep.prototype.map = function map (mapping) {
-    var from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    var 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)
-  };
-
-  ReplaceAroundStep.prototype.toJSON = function toJSON () {
-    var json = {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
-  };
-
-  ReplaceAroundStep.fromJSON = function fromJSON (schema, json) {
-    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") }
-    return new ReplaceAroundStep(json.from, json.to, json.gapFrom, json.gapTo,
-                                 Slice.fromJSON(schema, json.slice), json.insert, !!json.structure)
-  };
-
-  return ReplaceAroundStep;
-}(Step));
-
-Step.jsonID("replaceAround", ReplaceAroundStep);
-
-function contentBetween(doc, from, to) {
-  var $from = doc.resolve(from), dist = to - from, depth = $from.depth;
-  while (dist > 0 && depth > 0 && $from.indexAfter(depth) == $from.node(depth).childCount) {
-    depth--;
-    dist--;
-  }
-  if (dist > 0) {
-    var next = $from.node(depth).maybeChild($from.indexAfter(depth));
-    while (dist > 0) {
-      if (!next || next.isLeaf) { return true }
-      next = next.firstChild;
-      dist--;
-    }
-  }
-  return false
-}
-
-function canCut(node, start, end) {
-  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.
-function liftTarget(range) {
-  var parent = range.parent;
-  var content = parent.content.cutByIndex(range.startIndex, range.endIndex);
-  for (var depth = range.depth;; --depth) {
-    var node = range.$from.node(depth);
-    var index = range.$from.index(depth), endIndex = range.$to.indexAfter(depth);
-    if (depth < range.depth && node.canReplace(index, endIndex, content))
-      { return depth }
-    if (depth == 0 || node.type.spec.isolating || !canCut(node, index, endIndex)) { break }
-  }
-}
-
-// :: (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) {
-  var $from = range.$from;
-  var $to = range.$to;
-  var depth = range.depth;
-
-  var gapStart = $from.before(depth + 1), gapEnd = $to.after(depth + 1);
-  var start = gapStart, end = gapEnd;
-
-  var before = Fragment.empty, openStart = 0;
-  for (var d = depth, splitting = false; d > target; d--)
-    { if (splitting || $from.index(d) > 0) {
-      splitting = true;
-      before = Fragment.from($from.node(d).copy(before));
-      openStart++;
-    } else {
-      start--;
-    } }
-  var after = Fragment.empty, openEnd = 0;
-  for (var d$1 = depth, splitting$1 = false; d$1 > target; d$1--)
-    { if (splitting$1 || $to.after(d$1 + 1) < $to.end(d$1)) {
-      splitting$1 = true;
-      after = Fragment.from($to.node(d$1).copy(after));
-      openEnd++;
-    } else {
-      end++;
-    } }
-
-  return this.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`.
-function findWrapping(range, nodeType, attrs, innerRange) {
-  if ( innerRange === void 0 ) innerRange = range;
-
-  var around = findWrappingOutside(range, nodeType);
-  var inner = around && findWrappingInside(innerRange, nodeType);
-  if (!inner) { return null }
-  return around.map(withAttrs).concat({type: nodeType, attrs: attrs}).concat(inner.map(withAttrs))
-}
-
-function withAttrs(type) { return {type: type, attrs: null} }
-
-function findWrappingOutside(range, type) {
-  var parent = range.parent;
-  var startIndex = range.startIndex;
-  var endIndex = range.endIndex;
-  var around = parent.contentMatchAt(startIndex).findWrapping(type);
-  if (!around) { return null }
-  var outer = around.length ? around[0] : type;
-  return parent.canReplaceWith(startIndex, endIndex, outer) ? around : null
-}
-
-function findWrappingInside(range, type) {
-  var parent = range.parent;
-  var startIndex = range.startIndex;
-  var endIndex = range.endIndex;
-  var inner = parent.child(startIndex);
-  var inside = type.contentMatch.findWrapping(inner.type);
-  if (!inside) { return null }
-  var lastType = inside.length ? inside[inside.length - 1] : type;
-  var innerMatch = lastType.contentMatch;
-  for (var 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) {
-  var content = Fragment.empty;
-  for (var i = wrappers.length - 1; i >= 0; i--) {
-    if (content.size) {
-      var match = wrappers[i].type.contentMatch.matchFragment(content);
-      if (!match || !match.validEnd)
-        { throw new RangeError("Wrapper type given to Transform.wrap does not form valid content of its parent wrapper") }
-    }
-    content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
-  }
-
-  var start = range.start, end = range.end;
-  return this.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, type, attrs) {
-  var this$1$1 = this;
-  if ( to === void 0 ) to = from;
-
-  if (!type.isTextblock) { throw new RangeError("Type given to setBlockType should be a textblock") }
-  var mapFrom = this.steps.length;
-  this.doc.nodesBetween(from, to, function (node, pos) {
-    if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType(this$1$1.doc, this$1$1.mapping.slice(mapFrom).map(pos), type)) {
-      // Ensure all markup that isn't allowed in the new node type is cleared
-      this$1$1.clearIncompatible(this$1$1.mapping.slice(mapFrom).map(pos, 1), type);
-      var mapping = this$1$1.mapping.slice(mapFrom);
-      var startM = mapping.map(pos, 1), endM = mapping.map(pos + node.nodeSize, 1);
-      this$1$1.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) {
-  var $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) {
-  var node = this.doc.nodeAt(pos);
-  if (!node) { throw new RangeError("No node at given position") }
-  if (!type) { type = node.type; }
-  var newNode = type.create(attrs, null, marks || node.marks);
-  if (node.isLeaf)
-    { return this.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))
-};
-
-// :: (Node, number, number, ?[?{type: NodeType, attrs: ?Object}]) → bool
-// Check whether splitting at the given position is allowed.
-function canSplit(doc, pos, depth, typesAfter) {
-  if ( depth === void 0 ) depth = 1;
-
-  var $pos = doc.resolve(pos), base = $pos.depth - depth;
-  var innerType = (typesAfter && typesAfter[typesAfter.length - 1]) || $pos.parent;
-  if (base < 0 || $pos.parent.type.spec.isolating ||
-      !$pos.parent.canReplace($pos.index(), $pos.parent.childCount) ||
-      !innerType.type.validContent($pos.parent.content.cutByIndex($pos.index(), $pos.parent.childCount)))
-    { return false }
-  for (var d = $pos.depth - 1, i = depth - 2; d > base; d--, i--) {
-    var node = $pos.node(d), index$1 = $pos.index(d);
-    if (node.type.spec.isolating) { return false }
-    var rest = node.content.cutByIndex(index$1, node.childCount);
-    var after = (typesAfter && typesAfter[i]) || node;
-    if (after != node) { rest = rest.replaceChild(0, after.type.create(after.attrs)); }
-    if (!node.canReplace(index$1 + 1, node.childCount) || !after.type.validContent(rest))
-      { return false }
-  }
-  var index = $pos.indexAfter(base);
-  var baseType = typesAfter && typesAfter[0];
-  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, typesAfter) {
-  if ( depth === void 0 ) depth = 1;
-
-  var $pos = this.doc.resolve(pos), before = Fragment.empty, after = Fragment.empty;
-  for (var d = $pos.depth, e = $pos.depth - depth, i = depth - 1; d > e; d--, i--) {
-    before = Fragment.from($pos.node(d).copy(before));
-    var 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))
-};
-
-// :: (Node, number) → bool
-// Test whether the blocks before and after a given position can be
-// joined.
-function canJoin(doc, pos) {
-  var $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)
-}
-
-// :: (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.
-function joinPoint(doc, pos, dir) {
-  if ( dir === void 0 ) dir = -1;
-
-  var $pos = doc.resolve(pos);
-  for (var d = $pos.depth;; d--) {
-    var before = (void 0), after = (void 0), index = $pos.index(d);
-    if (d == $pos.depth) {
-      before = $pos.nodeBefore;
-      after = $pos.nodeAfter;
-    } else if (dir > 0) {
-      before = $pos.node(d + 1);
-      index++;
-      after = $pos.node(d).maybeChild(index);
-    } else {
-      before = $pos.node(d).maybeChild(index - 1);
-      after = $pos.node(d + 1);
-    }
-    if (before && !before.isTextblock && joinable(before, after) &&
-        $pos.node(d).canReplace(index, index + 1)) { return pos }
-    if (d == 0) { break }
-    pos = dir < 0 ? $pos.before(d) : $pos.after(d);
-  }
-}
-
-// :: (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) {
-  if ( depth === void 0 ) depth = 1;
-
-  var step = new ReplaceStep(pos - depth, pos + depth, Slice.empty, true);
-  return this.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.
-function insertPoint(doc, pos, nodeType) {
-  var $pos = doc.resolve(pos);
-  if ($pos.parent.canReplaceWith($pos.index(), $pos.index(), nodeType)) { return pos }
-
-  if ($pos.parentOffset == 0)
-    { for (var d = $pos.depth - 1; d >= 0; d--) {
-      var index = $pos.index(d);
-      if ($pos.node(d).canReplaceWith(index, index, nodeType)) { return $pos.before(d + 1) }
-      if (index > 0) { return null }
-    } }
-  if ($pos.parentOffset == $pos.parent.content.size)
-    { for (var d$1 = $pos.depth - 1; d$1 >= 0; d$1--) {
-      var index$1 = $pos.indexAfter(d$1);
-      if ($pos.node(d$1).canReplaceWith(index$1, index$1, nodeType)) { return $pos.after(d$1 + 1) }
-      if (index$1 < $pos.node(d$1).childCount) { 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.
-function dropPoint(doc, pos, slice) {
-  var $pos = doc.resolve(pos);
-  if (!slice.content.size) { return pos }
-  var content = slice.content;
-  for (var i = 0; i < slice.openStart; i++) { content = content.firstChild.content; }
-  for (var pass = 1; pass <= (slice.openStart == 0 && slice.size ? 2 : 1); pass++) {
-    for (var d = $pos.depth; d >= 0; d--) {
-      var bias = d == $pos.depth ? 0 : $pos.pos <= ($pos.start(d + 1) + $pos.end(d + 1)) / 2 ? -1 : 1;
-      var insertPos = $pos.index(d) + (bias > 0 ? 1 : 0);
-      var parent = $pos.node(d), fits = false;
-      if (pass == 1) {
-        fits = parent.canReplace(insertPos, insertPos, content);
-      } else {
-        var wrapping = parent.contentMatchAt(insertPos).findWrapping(content.firstChild.type);
-        fits = wrapping && parent.canReplaceWith(insertPos, insertPos, wrapping[0]);
-      }
-      if (fits)
-        { return bias == 0 ? $pos.pos : bias < 0 ? $pos.before(d + 1) : $pos.after(d + 1) }
-    }
-  }
-  return null
-}
-
-function mapFragment(fragment, f, parent) {
-  var mapped = [];
-  for (var i = 0; i < fragment.childCount; i++) {
-    var child = fragment.child(i);
-    if (child.content.size) { child = child.copy(mapFragment(child.content, f, child)); }
-    if (child.isInline) { child = f(child, parent, i); }
-    mapped.push(child);
-  }
-  return Fragment.fromArray(mapped)
-}
-
-// ::- Add a mark to all inline content between two positions.
-var AddMarkStep = /*@__PURE__*/(function (Step) {
-  function AddMarkStep(from, to, mark) {
-    Step.call(this);
-    // :: number
-    // The start of the marked range.
-    this.from = from;
-    // :: number
-    // The end of the marked range.
-    this.to = to;
-    // :: Mark
-    // The mark to add.
-    this.mark = mark;
-  }
-
-  if ( Step ) AddMarkStep.__proto__ = Step;
-  AddMarkStep.prototype = Object.create( Step && Step.prototype );
-  AddMarkStep.prototype.constructor = AddMarkStep;
-
-  AddMarkStep.prototype.apply = function apply (doc) {
-    var this$1$1 = this;
-
-    var oldSlice = doc.slice(this.from, this.to), $from = doc.resolve(this.from);
-    var parent = $from.node($from.sharedDepth(this.to));
-    var slice = new Slice(mapFragment(oldSlice.content, function (node, parent) {
-      if (!node.isAtom || !parent.type.allowsMarkType(this$1$1.mark.type)) { return node }
-      return node.mark(this$1$1.mark.addToSet(node.marks))
-    }, parent), oldSlice.openStart, oldSlice.openEnd);
-    return StepResult.fromReplace(doc, this.from, this.to, slice)
-  };
-
-  AddMarkStep.prototype.invert = function invert () {
-    return new RemoveMarkStep(this.from, this.to, this.mark)
-  };
-
-  AddMarkStep.prototype.map = function map (mapping) {
-    var from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    if (from.deleted && to.deleted || from.pos >= to.pos) { return null }
-    return new AddMarkStep(from.pos, to.pos, this.mark)
-  };
-
-  AddMarkStep.prototype.merge = function merge (other) {
-    if (other instanceof AddMarkStep &&
-        other.mark.eq(this.mark) &&
-        this.from <= other.to && this.to >= other.from)
-      { return new AddMarkStep(Math.min(this.from, other.from),
-                             Math.max(this.to, other.to), this.mark) }
-  };
-
-  AddMarkStep.prototype.toJSON = function toJSON () {
-    return {stepType: "addMark", mark: this.mark.toJSON(),
-            from: this.from, to: this.to}
-  };
-
-  AddMarkStep.fromJSON = function fromJSON (schema, json) {
-    if (typeof json.from != "number" || typeof json.to != "number")
-      { throw new RangeError("Invalid input for AddMarkStep.fromJSON") }
-    return new AddMarkStep(json.from, json.to, schema.markFromJSON(json.mark))
-  };
-
-  return AddMarkStep;
-}(Step));
-
-Step.jsonID("addMark", AddMarkStep);
-
-// ::- Remove a mark from all inline content between two positions.
-var RemoveMarkStep = /*@__PURE__*/(function (Step) {
-  function RemoveMarkStep(from, to, mark) {
-    Step.call(this);
-    // :: number
-    // The start of the unmarked range.
-    this.from = from;
-    // :: number
-    // The end of the unmarked range.
-    this.to = to;
-    // :: Mark
-    // The mark to remove.
-    this.mark = mark;
-  }
-
-  if ( Step ) RemoveMarkStep.__proto__ = Step;
-  RemoveMarkStep.prototype = Object.create( Step && Step.prototype );
-  RemoveMarkStep.prototype.constructor = RemoveMarkStep;
-
-  RemoveMarkStep.prototype.apply = function apply (doc) {
-    var this$1$1 = this;
-
-    var oldSlice = doc.slice(this.from, this.to);
-    var slice = new Slice(mapFragment(oldSlice.content, function (node) {
-      return node.mark(this$1$1.mark.removeFromSet(node.marks))
-    }), oldSlice.openStart, oldSlice.openEnd);
-    return StepResult.fromReplace(doc, this.from, this.to, slice)
-  };
-
-  RemoveMarkStep.prototype.invert = function invert () {
-    return new AddMarkStep(this.from, this.to, this.mark)
-  };
-
-  RemoveMarkStep.prototype.map = function map (mapping) {
-    var from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    if (from.deleted && to.deleted || from.pos >= to.pos) { return null }
-    return new RemoveMarkStep(from.pos, to.pos, this.mark)
-  };
-
-  RemoveMarkStep.prototype.merge = function merge (other) {
-    if (other instanceof RemoveMarkStep &&
-        other.mark.eq(this.mark) &&
-        this.from <= other.to && this.to >= other.from)
-      { return new RemoveMarkStep(Math.min(this.from, other.from),
-                                Math.max(this.to, other.to), this.mark) }
-  };
-
-  RemoveMarkStep.prototype.toJSON = function toJSON () {
-    return {stepType: "removeMark", mark: this.mark.toJSON(),
-            from: this.from, to: this.to}
-  };
-
-  RemoveMarkStep.fromJSON = function fromJSON (schema, json) {
-    if (typeof json.from != "number" || typeof json.to != "number")
-      { throw new RangeError("Invalid input for RemoveMarkStep.fromJSON") }
-    return new RemoveMarkStep(json.from, json.to, schema.markFromJSON(json.mark))
-  };
-
-  return RemoveMarkStep;
-}(Step));
-
-Step.jsonID("removeMark", RemoveMarkStep);
-
-// :: (number, number, Mark) → this
-// Add the given mark to the inline content between `from` and `to`.
-Transform.prototype.addMark = function(from, to, mark) {
-  var this$1$1 = this;
-
-  var removed = [], added = [], removing = null, adding = null;
-  this.doc.nodesBetween(from, to, function (node, pos, parent) {
-    if (!node.isInline) { return }
-    var marks = node.marks;
-    if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
-      var start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
-      var newSet = mark.addToSet(marks);
-
-      for (var i = 0; i < marks.length; i++) {
-        if (!marks[i].isInSet(newSet)) {
-          if (removing && removing.to == start && removing.mark.eq(marks[i]))
-            { removing.to = end; }
-          else
-            { removed.push(removing = new RemoveMarkStep(start, end, marks[i])); }
-        }
-      }
-
-      if (adding && adding.to == start)
-        { adding.to = end; }
-      else
-        { added.push(adding = new AddMarkStep(start, end, mark)); }
-    }
-  });
-
-  removed.forEach(function (s) { return this$1$1.step(s); });
-  added.forEach(function (s) { return this$1$1.step(s); });
-  return this
-};
-
-// :: (number, number, ?union<Mark, MarkType>) → 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.
-Transform.prototype.removeMark = function(from, to, mark) {
-  var this$1$1 = this;
-  if ( mark === void 0 ) mark = null;
-
-  var matched = [], step = 0;
-  this.doc.nodesBetween(from, to, function (node, pos) {
-    if (!node.isInline) { return }
-    step++;
-    var toRemove = null;
-    if (mark instanceof MarkType) {
-      var set = node.marks, found;
-      while (found = mark.isInSet(set)) {
-(toRemove || (toRemove = [])).push(found);
-        set = found.removeFromSet(set);
-      }
-    } else if (mark) {
-      if (mark.isInSet(node.marks)) { toRemove = [mark]; }
-    } else {
-      toRemove = node.marks;
-    }
-    if (toRemove && toRemove.length) {
-      var end = Math.min(pos + node.nodeSize, to);
-      for (var i = 0; i < toRemove.length; i++) {
-        var style = toRemove[i], found$1 = (void 0);
-        for (var j = 0; j < matched.length; j++) {
-          var m = matched[j];
-          if (m.step == step - 1 && style.eq(matched[j].style)) { found$1 = m; }
-        }
-        if (found$1) {
-          found$1.to = end;
-          found$1.step = step;
-        } else {
-          matched.push({style: style, from: Math.max(pos, from), to: end, step: step});
-        }
-      }
-    }
-  });
-  matched.forEach(function (m) { return this$1$1.step(new RemoveMarkStep(m.from, m.to, m.style)); });
-  return this
-};
-
-// :: (number, NodeType, ?ContentMatch) → 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.
-Transform.prototype.clearIncompatible = function(pos, parentType, match) {
-  if ( match === void 0 ) match = parentType.contentMatch;
-
-  var node = this.doc.nodeAt(pos);
-  var delSteps = [], cur = pos + 1;
-  for (var i = 0; i < node.childCount; i++) {
-    var child = node.child(i), end = cur + child.nodeSize;
-    var allowed = match.matchType(child.type, child.attrs);
-    if (!allowed) {
-      delSteps.push(new ReplaceStep(cur, end, Slice.empty));
-    } else {
-      match = allowed;
-      for (var j = 0; j < child.marks.length; j++) { if (!parentType.allowsMarkType(child.marks[j].type))
-        { this.step(new RemoveMarkStep(cur, end, child.marks[j])); } }
-    }
-    cur = end;
-  }
-  if (!match.validEnd) {
-    var fill = match.fillBefore(Fragment.empty, true);
-    this.replace(cur, cur, new Slice(fill, 0, 0));
-  }
-  for (var i$1 = delSteps.length - 1; i$1 >= 0; i$1--) { this.step(delSteps[i$1]); }
-  return this
-};
-
-// :: (Node, number, ?number, ?Slice) → ?Step
-// ‘Fit’ a slice into a given position in the document, producing a
-// [step](#transform.Step) that inserts it. Will return null if
-// there's no meaningful way to insert the slice here, or inserting it
-// would be a no-op (an empty slice over an empty range).
-function replaceStep(doc, from, to, slice) {
-  if ( to === void 0 ) to = from;
-  if ( slice === void 0 ) slice = Slice.empty;
-
-  if (from == to && !slice.size) { return null }
-
-  var $from = doc.resolve(from), $to = doc.resolve(to);
-  // Optimization -- avoid work if it's obvious that it's not needed.
-  if (fitsTrivially($from, $to, slice)) { return new ReplaceStep(from, to, slice) }
-  return new Fitter($from, $to, slice).fit()
-}
-
-// :: (number, ?number, ?Slice) → this
-// Replace the part of the document between `from` and `to` with the
-// given `slice`.
-Transform.prototype.replace = function(from, to, slice) {
-  if ( to === void 0 ) to = from;
-  if ( slice === void 0 ) slice = Slice.empty;
-
-  var step = replaceStep(this.doc, from, to, slice);
-  if (step) { this.step(step); }
-  return this
-};
-
-// :: (number, number, union<Fragment, Node, [Node]>) → this
-// Replace the given range with the given content, which may be a
-// fragment, node, or array of nodes.
-Transform.prototype.replaceWith = function(from, to, content) {
-  return this.replace(from, to, new Slice(Fragment.from(content), 0, 0))
-};
-
-// :: (number, number) → this
-// Delete the content between the given positions.
-Transform.prototype.delete = function(from, to) {
-  return this.replace(from, to, Slice.empty)
-};
-
-// :: (number, union<Fragment, Node, [Node]>) → this
-// Insert the given content at the given position.
-Transform.prototype.insert = function(pos, content) {
-  return this.replaceWith(pos, pos, content)
-};
-
-function fitsTrivially($from, $to, slice) {
-  return !slice.openStart && !slice.openEnd && $from.start() == $to.start() &&
-    $from.parent.canReplace($from.index(), $to.index(), slice.content)
-}
-
-// Algorithm for 'placing' the elements of a slice into a gap:
-//
-// We consider the content of each node that is open to the left to be
-// independently placeable. I.e. in <p("foo"), p("bar")>, when the
-// paragraph on the left is open, "foo" can be placed (somewhere on
-// the left side of the replacement gap) independently from p("bar").
-//
-// This class tracks the state of the placement progress in the
-// following properties:
-//
-//  - `frontier` holds a stack of `{type, match}` objects that
-//    represent the open side of the replacement. It starts at
-//    `$from`, then moves forward as content is placed, and is finally
-//    reconciled with `$to`.
-//
-//  - `unplaced` is a slice that represents the content that hasn't
-//    been placed yet.
-//
-//  - `placed` is a fragment of placed content. Its open-start value
-//    is implicit in `$from`, and its open-end value in `frontier`.
-var Fitter = function Fitter($from, $to, slice) {
-  this.$to = $to;
-  this.$from = $from;
-  this.unplaced = slice;
-
-  this.frontier = [];
-  for (var i = 0; i <= $from.depth; i++) {
-    var node = $from.node(i);
-    this.frontier.push({
-      type: node.type,
-      match: node.contentMatchAt($from.indexAfter(i))
-    });
-  }
-
-  this.placed = Fragment.empty;
-  for (var i$1 = $from.depth; i$1 > 0; i$1--)
-    { this.placed = Fragment.from($from.node(i$1).copy(this.placed)); }
-};
-
-var prototypeAccessors = { depth: { configurable: true } };
-
-prototypeAccessors.depth.get = function () { return this.frontier.length - 1 };
-
-Fitter.prototype.fit = function fit () {
-  // As long as there's unplaced content, try to place some of it.
-  // If that fails, either increase the open score of the unplaced
-  // slice, or drop nodes from it, and then try again.
-  while (this.unplaced.size) {
-    var fit = this.findFittable();
-    if (fit) { this.placeNodes(fit); }
-    else { this.openMore() || this.dropNode(); }
-  }
-  // When there's inline content directly after the frontier _and_
-  // directly after `this.$to`, we must generate a `ReplaceAround`
-  // step that pulls that content into the node after the frontier.
-  // That means the fitting must be done to the end of the textblock
-  // node after `this.$to`, not `this.$to` itself.
-  var moveInline = this.mustMoveInline(), placedSize = this.placed.size - this.depth - this.$from.depth;
-  var $from = this.$from, $to = this.close(moveInline < 0 ? this.$to : $from.doc.resolve(moveInline));
-  if (!$to) { return null }
-
-  // If closing to `$to` succeeded, create a step
-  var content = this.placed, openStart = $from.depth, openEnd = $to.depth;
-  while (openStart && openEnd && content.childCount == 1) { // Normalize by dropping open parent nodes
-    content = content.firstChild.content;
-    openStart--; openEnd--;
-  }
-  var slice = new Slice(content, openStart, openEnd);
-  if (moveInline > -1)
-    { return new ReplaceAroundStep($from.pos, moveInline, this.$to.pos, this.$to.end(), slice, placedSize) }
-  if (slice.size || $from.pos != this.$to.pos) // Don't generate no-op steps
-    { return new ReplaceStep($from.pos, $to.pos, slice) }
-};
-
-// Find a position on the start spine of `this.unplaced` that has
-// content that can be moved somewhere on the frontier. Returns two
-// depths, one for the slice and one for the frontier.
-Fitter.prototype.findFittable = function findFittable () {
-  // Only try wrapping nodes (pass 2) after finding a place without
-  // wrapping failed.
-  for (var pass = 1; pass <= 2; pass++) {
-    for (var sliceDepth = this.unplaced.openStart; sliceDepth >= 0; sliceDepth--) {
-      var fragment = (void 0), parent = (void 0);
-      if (sliceDepth) {
-        parent = contentAt(this.unplaced.content, sliceDepth - 1).firstChild;
-        fragment = parent.content;
-      } else {
-        fragment = this.unplaced.content;
-      }
-      var first = fragment.firstChild;
-      for (var frontierDepth = this.depth; frontierDepth >= 0; frontierDepth--) {
-        var ref = this.frontier[frontierDepth];
-          var type = ref.type;
-          var match = ref.match;
-          var wrap = (void 0), inject = (void 0);
-        // In pass 1, if the next node matches, or there is no next
-        // node but the parents look compatible, we've found a
-        // place.
-        if (pass == 1 && (first ? match.matchType(first.type) || (inject = match.fillBefore(Fragment.from(first), false))
-                          : type.compatibleContent(parent.type)))
-          { return {sliceDepth: sliceDepth, frontierDepth: frontierDepth, parent: parent, inject: inject} }
-        // In pass 2, look for a set of wrapping nodes that make
-        // `first` fit here.
-        else if (pass == 2 && first && (wrap = match.findWrapping(first.type)))
-          { return {sliceDepth: sliceDepth, frontierDepth: frontierDepth, parent: parent, wrap: wrap} }
-        // Don't continue looking further up if the parent node
-        // would fit here.
-        if (parent && match.matchType(parent.type)) { break }
-      }
-    }
-  }
-};
-
-Fitter.prototype.openMore = function openMore () {
-  var ref = this.unplaced;
-    var content = ref.content;
-    var openStart = ref.openStart;
-    var openEnd = ref.openEnd;
-  var inner = contentAt(content, openStart);
-  if (!inner.childCount || inner.firstChild.isLeaf) { return false }
-  this.unplaced = new Slice(content, openStart + 1,
-                            Math.max(openEnd, inner.size + openStart >= content.size - openEnd ? openStart + 1 : 0));
-  return true
-};
-
-Fitter.prototype.dropNode = function dropNode () {
-  var ref = this.unplaced;
-    var content = ref.content;
-    var openStart = ref.openStart;
-    var openEnd = ref.openEnd;
-  var inner = contentAt(content, openStart);
-  if (inner.childCount <= 1 && openStart > 0) {
-    var openAtEnd = content.size - openStart <= openStart + inner.size;
-    this.unplaced = new Slice(dropFromFragment(content, openStart - 1, 1), openStart - 1,
-                              openAtEnd ? openStart - 1 : openEnd);
-  } else {
-    this.unplaced = new Slice(dropFromFragment(content, openStart, 1), openStart, openEnd);
-  }
-};
-
-// : ({sliceDepth: number, frontierDepth: number, parent: ?Node, wrap: ?[NodeType], inject: ?Fragment})
-// Move content from the unplaced slice at `sliceDepth` to the
-// frontier node at `frontierDepth`. Close that frontier node when
-// applicable.
-Fitter.prototype.placeNodes = function placeNodes (ref) {
-    var sliceDepth = ref.sliceDepth;
-    var frontierDepth = ref.frontierDepth;
-    var parent = ref.parent;
-    var inject = ref.inject;
-    var wrap = ref.wrap;
-
-  while (this.depth > frontierDepth) { this.closeFrontierNode(); }
-  if (wrap) { for (var i = 0; i < wrap.length; i++) { this.openFrontierNode(wrap[i]); } }
-
-  var slice = this.unplaced, fragment = parent ? parent.content : slice.content;
-  var openStart = slice.openStart - sliceDepth;
-  var taken = 0, add = [];
-  var ref$1 = this.frontier[frontierDepth];
-    var match = ref$1.match;
-    var type = ref$1.type;
-  if (inject) {
-    for (var i$1 = 0; i$1 < inject.childCount; i$1++) { add.push(inject.child(i$1)); }
-    match = match.matchFragment(inject);
-  }
-  // Computes the amount of (end) open nodes at the end of the
-  // fragment. When 0, the parent is open, but no more. When
-  // negative, nothing is open.
-  var openEndCount = (fragment.size + sliceDepth) - (slice.content.size - slice.openEnd);
-  // Scan over the fragment, fitting as many child nodes as
-  // possible.
-  while (taken < fragment.childCount) {
-    var next = fragment.child(taken), matches = match.matchType(next.type);
-    if (!matches) { break }
-    taken++;
-    if (taken > 1 || openStart == 0 || next.content.size) { // Drop empty open nodes
-      match = matches;
-      add.push(closeNodeStart(next.mark(type.allowedMarks(next.marks)), taken == 1 ? openStart : 0,
-                              taken == fragment.childCount ? openEndCount : -1));
-    }
-  }
-  var toEnd = taken == fragment.childCount;
-  if (!toEnd) { openEndCount = -1; }
-
-  this.placed = addToFragment(this.placed, frontierDepth, Fragment.from(add));
-  this.frontier[frontierDepth].match = match;
-
-  // If the parent types match, and the entire node was moved, and
-  // it's not open, close this frontier node right away.
-  if (toEnd && openEndCount < 0 && parent && parent.type == this.frontier[this.depth].type && this.frontier.length > 1)
-    { this.closeFrontierNode(); }
-
-  // Add new frontier nodes for any open nodes at the end.
-  for (var i$2 = 0, cur = fragment; i$2 < openEndCount; i$2++) {
-    var node = cur.lastChild;
-    this.frontier.push({type: node.type, match: node.contentMatchAt(node.childCount)});
-    cur = node.content;
-  }
-
-  // Update `this.unplaced`. Drop the entire node from which we
-  // placed it we got to its end, otherwise just drop the placed
-  // nodes.
-  this.unplaced = !toEnd ? new Slice(dropFromFragment(slice.content, sliceDepth, taken), slice.openStart, slice.openEnd)
-    : sliceDepth == 0 ? Slice.empty
-    : new Slice(dropFromFragment(slice.content, sliceDepth - 1, 1),
-                sliceDepth - 1, openEndCount < 0 ? slice.openEnd : sliceDepth - 1);
-};
-
-Fitter.prototype.mustMoveInline = function mustMoveInline () {
-  if (!this.$to.parent.isTextblock) { return -1 }
-  var top = this.frontier[this.depth], level;
-  if (!top.type.isTextblock || !contentAfterFits(this.$to, this.$to.depth, top.type, top.match, false) ||
-      (this.$to.depth == this.depth && (level = this.findCloseLevel(this.$to)) && level.depth == this.depth)) { return -1 }
-
-  var ref = this.$to;
-    var depth = ref.depth;
-    var after = this.$to.after(depth);
-  while (depth > 1 && after == this.$to.end(--depth)) { ++after; }
-  return after
-};
-
-Fitter.prototype.findCloseLevel = function findCloseLevel ($to) {
-  scan: for (var i = Math.min(this.depth, $to.depth); i >= 0; i--) {
-    var ref = this.frontier[i];
-      var match = ref.match;
-      var type = ref.type;
-    var dropInner = i < $to.depth && $to.end(i + 1) == $to.pos + ($to.depth - (i + 1));
-    var fit = contentAfterFits($to, i, type, match, dropInner);
-    if (!fit) { continue }
-    for (var d = i - 1; d >= 0; d--) {
-      var ref$1 = this.frontier[d];
-        var match$1 = ref$1.match;
-        var type$1 = ref$1.type;
-      var matches = contentAfterFits($to, d, type$1, match$1, true);
-      if (!matches || matches.childCount) { continue scan }
-    }
-    return {depth: i, fit: fit, move: dropInner ? $to.doc.resolve($to.after(i + 1)) : $to}
-  }
-};
-
-Fitter.prototype.close = function close ($to) {
-  var close = this.findCloseLevel($to);
-  if (!close) { return null }
-
-  while (this.depth > close.depth) { this.closeFrontierNode(); }
-  if (close.fit.childCount) { this.placed = addToFragment(this.placed, close.depth, close.fit); }
-  $to = close.move;
-  for (var d = close.depth + 1; d <= $to.depth; d++) {
-    var node = $to.node(d), add = node.type.contentMatch.fillBefore(node.content, true, $to.index(d));
-    this.openFrontierNode(node.type, node.attrs, add);
-  }
-  return $to
-};
-
-Fitter.prototype.openFrontierNode = function openFrontierNode (type, attrs, content) {
-  var top = this.frontier[this.depth];
-  top.match = top.match.matchType(type);
-  this.placed = addToFragment(this.placed, this.depth, Fragment.from(type.create(attrs, content)));
-  this.frontier.push({type: type, match: type.contentMatch});
-};
-
-Fitter.prototype.closeFrontierNode = function closeFrontierNode () {
-  var open = this.frontier.pop();
-  var add = open.match.fillBefore(Fragment.empty, true);
-  if (add.childCount) { this.placed = addToFragment(this.placed, this.frontier.length, add); }
-};
-
-Object.defineProperties( Fitter.prototype, prototypeAccessors );
-
-function dropFromFragment(fragment, depth, count) {
-  if (depth == 0) { return fragment.cutByIndex(count) }
-  return fragment.replaceChild(0, fragment.firstChild.copy(dropFromFragment(fragment.firstChild.content, depth - 1, count)))
-}
-
-function addToFragment(fragment, depth, content) {
-  if (depth == 0) { return fragment.append(content) }
-  return fragment.replaceChild(fragment.childCount - 1,
-                               fragment.lastChild.copy(addToFragment(fragment.lastChild.content, depth - 1, content)))
-}
-
-function contentAt(fragment, depth) {
-  for (var i = 0; i < depth; i++) { fragment = fragment.firstChild.content; }
-  return fragment
-}
-
-function closeNodeStart(node, openStart, openEnd) {
-  if (openStart <= 0) { return node }
-  var frag = node.content;
-  if (openStart > 1)
-    { frag = frag.replaceChild(0, closeNodeStart(frag.firstChild, openStart - 1, frag.childCount == 1 ? openEnd - 1 : 0)); }
-  if (openStart > 0) {
-    frag = node.type.contentMatch.fillBefore(frag).append(frag);
-    if (openEnd <= 0) { frag = frag.append(node.type.contentMatch.matchFragment(frag).fillBefore(Fragment.empty, true)); }
-  }
-  return node.copy(frag)
-}
-
-function contentAfterFits($to, depth, type, match, open) {
-  var node = $to.node(depth), index = open ? $to.indexAfter(depth) : $to.index(depth);
-  if (index == node.childCount && !type.compatibleContent(node.type)) { return null }
-  var fit = match.fillBefore(node.content, true, index);
-  return fit && !invalidMarks(type, node.content, index) ? fit : null
-}
-
-function invalidMarks(type, fragment, start) {
-  for (var i = start; i < fragment.childCount; i++)
-    { if (!type.allowsMarks(fragment.child(i).marks)) { return true } }
-  return false
-}
-
-function definesContent(type) {
-  return type.spec.defining || type.spec.definingForContent
-}
-
-// :: (number, number, Slice) → this
-// 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.
-Transform.prototype.replaceRange = function(from, to, slice) {
-  if (!slice.size) { return this.deleteRange(from, to) }
-
-  var $from = this.doc.resolve(from), $to = this.doc.resolve(to);
-  if (fitsTrivially($from, $to, slice))
-    { return this.step(new ReplaceStep(from, to, slice)) }
-
-  var targetDepths = coveredDepths($from, this.doc.resolve(to));
-  // Can't replace the whole document, so remove 0 if it's present
-  if (targetDepths[targetDepths.length - 1] == 0) { targetDepths.pop(); }
-  // Negative numbers represent not expansion over the whole node at
-  // that depth, but replacing from $from.before(-D) to $to.pos.
-  var preferredTarget = -($from.depth + 1);
-  targetDepths.unshift(preferredTarget);
-  // This loop picks a preferred target depth, if one of the covering
-  // depths is not outside of a defining node, and adds negative
-  // depths for any depth that has $from at its start and does not
-  // cross a defining node.
-  for (var d = $from.depth, pos = $from.pos - 1; d > 0; d--, pos--) {
-    var spec = $from.node(d).type.spec;
-    if (spec.defining || spec.definingAsContext || spec.isolating) { break }
-    if (targetDepths.indexOf(d) > -1) { preferredTarget = d; }
-    else if ($from.before(d) == pos) { targetDepths.splice(1, 0, -d); }
-  }
-  // Try to fit each possible depth of the slice into each possible
-  // target depth, starting with the preferred depths.
-  var preferredTargetIndex = targetDepths.indexOf(preferredTarget);
-
-  var leftNodes = [], preferredDepth = slice.openStart;
-  for (var content = slice.content, i = 0;; i++) {
-    var node = content.firstChild;
-    leftNodes.push(node);
-    if (i == slice.openStart) { break }
-    content = node.content;
-  }
-
-  // Back up preferredDepth to cover defining textblocks directly
-  // above it, possibly skipping a non-defining textblock.
-  for (var d$1 = preferredDepth - 1; d$1 >= 0; d$1--) {
-    var type = leftNodes[d$1].type, def = definesContent(type);
-    if (def && $from.node(preferredTargetIndex).type != type) { preferredDepth = d$1; }
-    else if (def || !type.isTextblock) { break }
-  }
-
-  for (var j = slice.openStart; j >= 0; j--) {
-    var openDepth = (j + preferredDepth + 1) % (slice.openStart + 1);
-    var insert = leftNodes[openDepth];
-    if (!insert) { continue }
-    for (var i$1 = 0; i$1 < targetDepths.length; i$1++) {
-      // Loop over possible expansion levels, starting with the
-      // preferred one
-      var targetDepth = targetDepths[(i$1 + preferredTargetIndex) % targetDepths.length], expand = true;
-      if (targetDepth < 0) { expand = false; targetDepth = -targetDepth; }
-      var parent = $from.node(targetDepth - 1), index = $from.index(targetDepth - 1);
-      if (parent.canReplaceWith(index, index, insert.type, insert.marks))
-        { return this.replace($from.before(targetDepth), expand ? $to.after(targetDepth) : to,
-                            new Slice(closeFragment(slice.content, 0, slice.openStart, openDepth),
-                                      openDepth, slice.openEnd)) }
-    }
-  }
-
-  var startSteps = this.steps.length;
-  for (var i$2 = targetDepths.length - 1; i$2 >= 0; i$2--) {
-    this.replace(from, to, slice);
-    if (this.steps.length > startSteps) { break }
-    var depth = targetDepths[i$2];
-    if (depth < 0) { continue }
-    from = $from.before(depth); to = $to.after(depth);
-  }
-  return this
-};
-
-function closeFragment(fragment, depth, oldOpen, newOpen, parent) {
-  if (depth < oldOpen) {
-    var first = fragment.firstChild;
-    fragment = fragment.replaceChild(0, first.copy(closeFragment(first.content, depth + 1, oldOpen, newOpen, first)));
-  }
-  if (depth > newOpen) {
-    var match = parent.contentMatchAt(0);
-    var start = match.fillBefore(fragment).append(fragment);
-    fragment = start.append(match.matchFragment(start).fillBefore(Fragment.empty, true));
-  }
-  return fragment
-}
-
-// :: (number, number, Node) → 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.
-Transform.prototype.replaceRangeWith = function(from, to, node) {
-  if (!node.isInline && from == to && this.doc.resolve(from).parent.content.size) {
-    var point = insertPoint(this.doc, from, node.type);
-    if (point != null) { from = to = point; }
-  }
-  return this.replaceRange(from, to, new Slice(Fragment.from(node), 0, 0))
-};
-
-// :: (number, number) → this
-// Delete the given range, expanding it to cover fully covered
-// parent nodes until a valid replace is found.
-Transform.prototype.deleteRange = function(from, to) {
-  var $from = this.doc.resolve(from), $to = this.doc.resolve(to);
-  var covered = coveredDepths($from, $to);
-  for (var i = 0; i < covered.length; i++) {
-    var depth = covered[i], last = i == covered.length - 1;
-    if ((last && depth == 0) || $from.node(depth).type.contentMatch.validEnd)
-      { return this.delete($from.start(depth), $to.end(depth)) }
-    if (depth > 0 && (last || $from.node(depth - 1).canReplace($from.index(depth - 1), $to.indexAfter(depth - 1))))
-      { return this.delete($from.before(depth), $to.after(depth)) }
-  }
-  for (var d = 1; d <= $from.depth && d <= $to.depth; d++) {
-    if (from - $from.start(d) == $from.depth - d && to > $from.end(d) && $to.end(d) - to != $to.depth - d)
-      { return this.delete($from.before(d), to) }
-  }
-  return this.delete(from, to)
-};
-
-// : (ResolvedPos, ResolvedPos) → [number]
-// Returns an array of all depths for which $from - $to spans the
-// whole content of the nodes at that depth.
-function coveredDepths($from, $to) {
-  var result = [], minDepth = Math.min($from.depth, $to.depth);
-  for (var d = minDepth; d >= 0; d--) {
-    var start = $from.start(d);
-    if (start < $from.pos - ($from.depth - d) ||
-        $to.end(d) > $to.pos + ($to.depth - d) ||
-        $from.node(d).type.spec.isolating ||
-        $to.node(d).type.spec.isolating) { break }
-    if (start == $to.start(d) ||
-        (d == $from.depth && d == $to.depth && $from.parent.inlineContent && $to.parent.inlineContent &&
-         d && $to.start(d - 1) == start - 1))
-      { result.push(d); }
-  }
-  return result
-}
-
-export { AddMarkStep, MapResult, Mapping, RemoveMarkStep, ReplaceAroundStep, ReplaceStep, Step, StepMap, StepResult, Transform, TransformError, canJoin, canSplit, dropPoint, findWrapping, insertPoint, joinPoint, liftTarget, replaceStep };
-//# sourceMappingURL=index.es.js.map