prosemirror.state

gistfile1.txt

(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
// ::- Persistent data structure representing an ordered mapping from
// strings to values, with some convenient update methods.
function OrderedMap(content) {
  this.content = content;
}

OrderedMap.prototype = {
  constructor: OrderedMap,

  find: function (key) {
    for (var i = 0; i < this.content.length; i += 2) if (this.content[i] === key) return i;
    return -1;
  },

  // :: (string) → ?any
  // Retrieve the value stored under `key`, or return undefined when
  // no such key exists.
  get: function (key) {
    var found = this.find(key);
    return found == -1 ? undefined : this.content[found + 1];
  },

  // :: (string, any, ?string) → OrderedMap
  // Create a new map by replacing the value of `key` with a new
  // value, or adding a binding to the end of the map. If `newKey` is
  // given, the key of the binding will be replaced with that key.
  update: function (key, value, newKey) {
    var self = newKey && newKey != key ? this.remove(newKey) : this;
    var found = self.find(key),
        content = self.content.slice();
    if (found == -1) {
      content.push(newKey || key, value);
    } else {
      content[found + 1] = value;
      if (newKey) content[found] = newKey;
    }
    return new OrderedMap(content);
  },

  // :: (string) → OrderedMap
  // Return a map with the given key removed, if it existed.
  remove: function (key) {
    var found = this.find(key);
    if (found == -1) return this;
    var content = this.content.slice();
    content.splice(found, 2);
    return new OrderedMap(content);
  },

  // :: (string, any) → OrderedMap
  // Add a new key to the start of the map.
  addToStart: function (key, value) {
    return new OrderedMap([key, value].concat(this.remove(key).content));
  },

  // :: (string, any) → OrderedMap
  // Add a new key to the end of the map.
  addToEnd: function (key, value) {
    var content = this.remove(key).content.slice();
    content.push(key, value);
    return new OrderedMap(content);
  },

  // :: (string, string, any) → OrderedMap
  // Add a key after the given key. If `place` is not found, the new
  // key is added to the end.
  addBefore: function (place, key, value) {
    var without = this.remove(key),
        content = without.content.slice();
    var found = without.find(place);
    content.splice(found == -1 ? content.length : found, 0, key, value);
    return new OrderedMap(content);
  },

  // :: ((key: string, value: any))
  // Call the given function for each key/value pair in the map, in
  // order.
  forEach: function (f) {
    for (var i = 0; i < this.content.length; i += 2) f(this.content[i], this.content[i + 1]);
  },

  // :: (union<Object, OrderedMap>) → OrderedMap
  // Create a new map by prepending the keys in this map that don't
  // appear in `map` before the keys in `map`.
  prepend: function (map) {
    map = OrderedMap.from(map);
    if (!map.size) return this;
    return new OrderedMap(map.content.concat(this.subtract(map).content));
  },

  // :: (union<Object, OrderedMap>) → OrderedMap
  // Create a new map by appending the keys in this map that don't
  // appear in `map` after the keys in `map`.
  append: function (map) {
    map = OrderedMap.from(map);
    if (!map.size) return this;
    return new OrderedMap(this.subtract(map).content.concat(map.content));
  },

  // :: (union<Object, OrderedMap>) → OrderedMap
  // Create a map containing all the keys in this map that don't
  // appear in `map`.
  subtract: function (map) {
    var result = this;
    map = OrderedMap.from(map);
    for (var i = 0; i < map.content.length; i += 2) result = result.remove(map.content[i]);
    return result;
  },

  // :: number
  // The amount of keys in this map.
  get size() {
    return this.content.length >> 1;
  }
};

// :: (?union<Object, OrderedMap>) → OrderedMap
// Return a map with the given content. If null, create an empty
// map. If given an ordered map, return that map itself. If given an
// object, create a map from the object's properties.
OrderedMap.from = function (value) {
  if (value instanceof OrderedMap) return value;
  var content = [];
  if (value) for (var prop in value) content.push(prop, value[prop]);
  return new OrderedMap(content);
};

module.exports = OrderedMap;

},{}],2:[function(require,module,exports){
function compareDeep(a, b) {
  if (a === b) {
    return true;
  }
  if (!(a && typeof a == "object") || !(b && typeof b == "object")) {
    return false;
  }
  var array = Array.isArray(a);
  if (Array.isArray(b) != array) {
    return false;
  }
  if (array) {
    if (a.length != b.length) {
      return false;
    }
    for (var i = 0; i < a.length; i++) {
      if (!compareDeep(a[i], b[i])) {
        return false;
      }
    }
  } else {
    for (var p in a) {
      if (!(p in b) || !compareDeep(a[p], b[p])) {
        return false;
      }
    }
    for (var p$1 in b) {
      if (!(p$1 in a)) {
        return false;
      }
    }
  }
  return true;
}
exports.compareDeep = compareDeep;

},{}],3:[function(require,module,exports){
var ref = require("./fragment");
var Fragment = ref.Fragment;
var ref$1 = require("./mark");
var Mark = ref$1.Mark;

var ContentExpr = function (nodeType, elements, inlineContent) {
  this.nodeType = nodeType;
  this.elements = elements;
  this.inlineContent = inlineContent;
};

var prototypeAccessors = { isLeaf: {} };

prototypeAccessors.isLeaf.get = function () {
  return this.elements.length == 0;
};

// : (?Object) → ContentMatch
// The content match at the start of this expression.
ContentExpr.prototype.start = function (attrs) {
  return new ContentMatch(this, attrs, 0, 0);
};

// : (NodeType, ?Object, ?Object) → ?ContentMatch
// Try to find a match that matches the given node, anywhere in the
// expression. (Useful when synthesizing a match for a node that's
// open to the left.)
ContentExpr.prototype.atType = function (parentAttrs, type, attrs, marks) {
  var this$1 = this;
  if (marks === void 0) marks = Mark.none;

  for (var i = 0; i < this.elements.length; i++) {
    if (this$1.elements[i].matchesType(type, attrs, marks, parentAttrs, this$1)) {
      return new ContentMatch(this$1, parentAttrs, i, 0);
    }
  }
};

ContentExpr.prototype.matches = function (attrs, fragment, from, to) {
  return this.start(attrs).matchToEnd(fragment, from, to);
};

// Get a position in a known-valid fragment. If this is a simple
// (single-element) expression, we don't have to do any matching,
// and can simply skip to the position with count `index`.
ContentExpr.prototype.getMatchAt = function (attrs, fragment, index) {
  if (index === void 0) index = fragment.childCount;

  if (this.elements.length == 1) {
    return new ContentMatch(this, attrs, 0, index);
  } else {
    return this.start(attrs).matchFragment(fragment, 0, index);
  }
};

ContentExpr.prototype.checkReplace = function (attrs, content, from, to, replacement, start, end) {
  var this$1 = this;
  if (replacement === void 0) replacement = Fragment.empty;
  if (start === void 0) start = 0;
  if (end === void 0) end = replacement.childCount;

  // Check for simple case, where the expression only has a single element
  // (Optimization to avoid matching more than we need)
  if (this.elements.length == 1) {
    var elt = this.elements[0];
    if (!checkCount(elt, content.childCount - (to - from) + (end - start), attrs, this)) {
      return false;
    }
    for (var i = start; i < end; i++) {
      if (!elt.matches(replacement.child(i), attrs, this$1)) {
        return false;
      }
    }
    return true;
  }

  var match = this.getMatchAt(attrs, content, from).matchFragment(replacement, start, end);
  return match ? match.matchToEnd(content, to) : false;
};

ContentExpr.prototype.checkReplaceWith = function (attrs, content, from, to, type, typeAttrs, marks) {
  if (this.elements.length == 1) {
    var elt = this.elements[0];
    if (!checkCount(elt, content.childCount - (to - from) + 1, attrs, this)) {
      return false;
    }
    return elt.matchesType(type, typeAttrs, marks, attrs, this);
  }

  var match = this.getMatchAt(attrs, content, from).matchType(type, typeAttrs, marks);
  return match ? match.matchToEnd(content, to) : false;
};

ContentExpr.prototype.compatible = function (other) {
  var this$1 = this;

  for (var i = 0; i < this.elements.length; i++) {
    var elt = this$1.elements[i];
    for (var j = 0; j < other.elements.length; j++) {
      if (other.elements[j].compatible(elt)) {
        return true;
      }
    }
  }
  return false;
};

ContentExpr.prototype.generateContent = function (attrs) {
  return this.start(attrs).fillBefore(Fragment.empty, true);
};

ContentExpr.parse = function (nodeType, expr) {
  var this$1 = this;

  var elements = [],
      pos = 0,
      inline = null;
  for (;;) {
    pos += /^\s*/.exec(expr.slice(pos))[0].length;
    if (pos == expr.length) {
      break;
    }

    var types = /^(?:(\w+)|\(\s*(\w+(?:\s*\|\s*\w+)*)\s*\))/.exec(expr.slice(pos));
    if (!types) {
      throw new SyntaxError("Invalid content expression '" + expr + "' at " + pos);
    }
    pos += types[0].length;
    var attrs = /^\[([^\]]+)\]/.exec(expr.slice(pos));
    if (attrs) {
      pos += attrs[0].length;
    }
    var marks = /^<(?:(_)|\s*(\w+(?:\s+\w+)*)\s*)>/.exec(expr.slice(pos));
    if (marks) {
      pos += marks[0].length;
    }
    var repeat = /^(?:([+*?])|\{\s*(\d+|\.\w+)\s*(,\s*(\d+|\.\w+)?)?\s*\})/.exec(expr.slice(pos));
    if (repeat) {
      pos += repeat[0].length;
    }

    var nodeTypes = expandTypes(nodeType.schema, types[1] ? [types[1]] : types[2].split(/\s*\|\s*/));
    for (var i = 0; i < nodeTypes.length; i++) {
      if (inline == null) {
        inline = nodeTypes[i].isInline;
      } else if (inline != nodeTypes[i].isInline) {
        throw new SyntaxError("Mixing inline and block content in a single node");
      }
    }
    var attrSet = !attrs ? null : parseAttrs(nodeType, attrs[1]);
    var markSet = !marks ? false : marks[1] ? true : this$1.gatherMarks(nodeType.schema, marks[2].split(/\s+/));
    var ref = parseRepeat(nodeType, repeat);
    var min = ref.min;
    var max = ref.max;
    if (min != 0 && (nodeTypes[0].hasRequiredAttrs(attrSet) || nodeTypes[0].isText)) {
      throw new SyntaxError("Node type " + types[0] + " in type " + nodeType.name + " is required, but has non-optional attributes");
    }
    var newElt = new ContentElement(nodeTypes, attrSet, markSet, min, max);
    for (var i$1 = elements.length - 1; i$1 >= 0; i$1--) {
      var prev = elements[i$1];
      if (prev.min != prev.max && prev.overlaps(newElt)) {
        throw new SyntaxError("Possibly ambiguous overlapping adjacent content expressions in '" + expr + "'");
      }
      if (prev.min != 0) {
        break;
      }
    }
    elements.push(newElt);
  }

  return new ContentExpr(nodeType, elements, !!inline);
};

ContentExpr.gatherMarks = function (schema, marks) {
  var found = [];
  for (var i = 0; i < marks.length; i++) {
    var name = marks[i],
        mark = schema.marks[name],
        ok = mark;
    if (mark) {
      found.push(mark);
    } else {
      for (var prop in schema.marks) {
        var mark$1 = schema.marks[prop];
        if (name == "_" || mark$1.spec.group && mark$1.spec.group.split(" ").indexOf(name) > -1) {
          found.push(ok = mark$1);
        }
      }
    }
    if (!ok) {
      throw new SyntaxError("Unknown mark type: '" + marks[i] + "'");
    }
  }
  return found;
};

Object.defineProperties(ContentExpr.prototype, prototypeAccessors);
exports.ContentExpr = ContentExpr;

var ContentElement = function (nodeTypes, attrs, marks, min, max) {
  this.nodeTypes = nodeTypes;
  this.attrs = attrs;
  this.marks = marks;
  this.min = min;
  this.max = max;
};

ContentElement.prototype.matchesType = function (type, attrs, marks, parentAttrs, parentExpr) {
  var this$1 = this;

  if (this.nodeTypes.indexOf(type) == -1) {
    return false;
  }
  if (this.attrs) {
    if (!attrs) {
      return false;
    }
    for (var prop in this$1.attrs) {
      if (attrs[prop] != resolveValue(this$1.attrs[prop], parentAttrs, parentExpr)) {
        return false;
      }
    }
  }
  if (this.marks === true) {
    return true;
  }
  if (this.marks === false) {
    return marks.length == 0;
  }
  for (var i = 0; i < marks.length; i++) {
    if (this$1.marks.indexOf(marks[i].type) == -1) {
      return false;
    }
  }
  return true;
};

ContentElement.prototype.matches = function (node, parentAttrs, parentExpr) {
  return this.matchesType(node.type, node.attrs, node.marks, parentAttrs, parentExpr);
};

ContentElement.prototype.compatible = function (other) {
  var this$1 = this;

  for (var i = 0; i < this.nodeTypes.length; i++) {
    if (other.nodeTypes.indexOf(this$1.nodeTypes[i]) != -1) {
      return true;
    }
  }
  return false;
};

ContentElement.prototype.constrainedAttrs = function (parentAttrs, expr) {
  var this$1 = this;

  if (!this.attrs) {
    return null;
  }
  var attrs = Object.create(null);
  for (var prop in this$1.attrs) {
    attrs[prop] = resolveValue(this$1.attrs[prop], parentAttrs, expr);
  }
  return attrs;
};

ContentElement.prototype.createFiller = function (parentAttrs, expr) {
  var type = this.nodeTypes[0],
      attrs = type.computeAttrs(this.constrainedAttrs(parentAttrs, expr));
  return type.create(attrs, type.contentExpr.generateContent(attrs));
};

ContentElement.prototype.defaultType = function () {
  var first = this.nodeTypes[0];
  if (!(first.hasRequiredAttrs() || first.isText)) {
    return first;
  }
};

ContentElement.prototype.overlaps = function (other) {
  return this.nodeTypes.some(function (t) {
    return other.nodeTypes.indexOf(t) > -1;
  });
};

ContentElement.prototype.allowsMark = function (markType) {
  return this.marks === true || this.marks && this.marks.indexOf(markType) > -1;
};

// ::- Represents a partial match of a node type's [content
// expression](#model.NodeSpec), and can be used to find out whether further
// content matches here, and whether a given position is a valid end
// of the parent node.
var ContentMatch = function (expr, attrs, index, count) {
  this.expr = expr;
  this.attrs = attrs;
  this.index = index;
  this.count = count;
};

var prototypeAccessors$1 = { element: {}, nextElement: {} };

prototypeAccessors$1.element.get = function () {
  return this.expr.elements[this.index];
};

prototypeAccessors$1.nextElement.get = function () {
  var this$1 = this;

  for (var i = this.index, count = this.count; i < this.expr.elements.length; i++) {
    var element = this$1.expr.elements[i];
    if (this$1.resolveValue(element.max) > count) {
      return element;
    }
    count = 0;
  }
};

ContentMatch.prototype.move = function (index, count) {
  return new ContentMatch(this.expr, this.attrs, index, count);
};

ContentMatch.prototype.resolveValue = function (value) {
  return value instanceof AttrValue ? resolveValue(value, this.attrs, this.expr) : value;
};

// :: (Node) → ?ContentMatch
// Match a node, returning a new match after the node if successful.
ContentMatch.prototype.matchNode = function (node) {
  return this.matchType(node.type, node.attrs, node.marks);
};

// :: (NodeType, ?Object, [Mark]) → ?ContentMatch
// Match a node type and marks, returning an match after that node
// if successful.
ContentMatch.prototype.matchType = function (type, attrs, marks) {
  var this$1 = this;
  if (marks === void 0) marks = Mark.none;

  for (var ref = this, index = ref.index, count = ref.count; index < this.expr.elements.length; index++, count = 0) {
    var elt = this$1.expr.elements[index],
        max = this$1.resolveValue(elt.max);
    if (count < max && elt.matchesType(type, attrs, marks, this$1.attrs, this$1.expr)) {
      count++;
      return this$1.move(index, count);
    }
    if (count < this$1.resolveValue(elt.min)) {
      return null;
    }
  }
};

// :: (Fragment, ?number, ?number) → ?union<ContentMatch, bool>
// Try to match a fragment. Returns a new match when successful,
// `null` when it ran into a required element it couldn't fit, and
// `false` if it reached the end of the expression without
// matching all nodes.
ContentMatch.prototype.matchFragment = function (fragment, from, to) {
  var this$1 = this;
  if (from === void 0) from = 0;
  if (to === void 0) to = fragment.childCount;

  if (from == to) {
    return this;
  }
  var fragPos = from,
      end = this.expr.elements.length;
  for (var ref = this, index = ref.index, count = ref.count; index < end; index++, count = 0) {
    var elt = this$1.expr.elements[index],
        max = this$1.resolveValue(elt.max);

    while (count < max && fragPos < to) {
      if (elt.matches(fragment.child(fragPos), this$1.attrs, this$1.expr)) {
        count++;
        if (++fragPos == to) {
          return this$1.move(index, count);
        }
      } else {
        break;
      }
    }
    if (count < this$1.resolveValue(elt.min)) {
      return null;
    }
  }
  return false;
};

// :: (Fragment, ?number, ?number) → bool
// Returns true only if the fragment matches here, and reaches all
// the way to the end of the content expression.
ContentMatch.prototype.matchToEnd = function (fragment, start, end) {
  var matched = this.matchFragment(fragment, start, end);
  return matched && matched.validEnd() || false;
};

// :: () → bool
// Returns true if this position represents a valid end of the
// expression (no required content follows after it).
ContentMatch.prototype.validEnd = function () {
  var this$1 = this;

  for (var i = this.index, count = this.count; i < this.expr.elements.length; i++, count = 0) {
    if (count < this$1.resolveValue(this$1.expr.elements[i].min)) {
      return false;
    }
  }
  return true;
};

// :: (Fragment, bool, ?number) → ?Fragment
// Try to match the given fragment, and if that fails, see if it can
// be made to match by inserting nodes in front of it. When
// successful, return a fragment of inserted nodes (which may be
// empty if nothing had to be inserted). When `toEnd` is true, only
// return a fragment if the resulting match goes to the end of the
// content expression.
ContentMatch.prototype.fillBefore = function (after, toEnd, startIndex) {
  var this$1 = this;

  var added = [],
      match = this,
      index = startIndex || 0,
      end = this.expr.elements.length;
  for (;;) {
    var fits = match.matchFragment(after, index);
    if (fits && (!toEnd || fits.validEnd())) {
      return Fragment.from(added);
    }
    if (fits === false) {
      return null;
    } // Matched to end with content remaining

    var elt = match.element;
    if (match.count < this$1.resolveValue(elt.min)) {
      added.push(elt.createFiller(this$1.attrs, this$1.expr));
      match = match.move(match.index, match.count + 1);
    } else if (match.index < end) {
      match = match.move(match.index + 1, 0);
    } else if (after.childCount > index) {
      return null;
    } else {
      return Fragment.from(added);
    }
  }
};

ContentMatch.prototype.possibleContent = function () {
  var this$1 = this;

  var found = [];
  for (var i = this.index, count = this.count; i < this.expr.elements.length; i++, count = 0) {
    var elt = this$1.expr.elements[i],
        attrs = elt.constrainedAttrs(this$1.attrs, this$1.expr);
    if (count < this$1.resolveValue(elt.max)) {
      for (var j = 0; j < elt.nodeTypes.length; j++) {
        var type = elt.nodeTypes[j];
        if (!type.hasRequiredAttrs(attrs) && !type.isText) {
          found.push({ type: type, attrs: attrs });
        }
      }
    }
    if (this$1.resolveValue(elt.min) > count) {
      break;
    }
  }
  return found;
};

// :: (MarkType) → bool
// Check whether a node with the given mark type is allowed after
// this position.
ContentMatch.prototype.allowsMark = function (markType) {
  return this.element.allowsMark(markType);
};

// :: (NodeType, ?Object, ?[Mark]) → ?[{type: NodeType, attrs: Object}]
// Find a set of wrapping node types that would allow a node of type
// `target` with attributes `targetAttrs` to appear at this
// position. The result may be empty (when it fits directly) and
// will be null when no such wrapping exists.
ContentMatch.prototype.findWrapping = function (target, targetAttrs, targetMarks) {
  var seen = Object.create(null),
      first = { match: this, via: null },
      active = [first];
  while (active.length) {
    var current = active.shift(),
        match = current.match;
    if (match.matchType(target, targetAttrs, targetMarks)) {
      var result = [];
      for (var obj = current; obj != first; obj = obj.via) {
        result.push({ type: obj.match.expr.nodeType, attrs: obj.match.attrs });
      }
      return result.reverse();
    }
    var possible = match.possibleContent();
    for (var i = 0; i < possible.length; i++) {
      var ref = possible[i];
      var type = ref.type;
      var attrs = ref.attrs;
      var fullAttrs = type.computeAttrs(attrs);
      if (!type.isLeaf && !(type.name in seen) && (current == first || match.matchType(type, fullAttrs).validEnd())) {
        active.push({ match: type.contentExpr.start(fullAttrs), via: current });
        seen[type.name] = true;
      }
    }
  }
};

// :: (Node) → ?[{type: NodeType, attrs: Object}]
// Call [`findWrapping`](#model.ContentMatch.findWrapping) with the
// properties of the given node.
ContentMatch.prototype.findWrappingFor = function (node) {
  return this.findWrapping(node.type, node.attrs, node.marks);
};

Object.defineProperties(ContentMatch.prototype, prototypeAccessors$1);
exports.ContentMatch = ContentMatch;

var AttrValue = function (attr) {
  this.attr = attr;
};

function parseValue(nodeType, value) {
  if (value.charAt(0) == ".") {
    var attr = value.slice(1);
    if (!nodeType.attrs[attr]) {
      throw new SyntaxError("Node type " + nodeType.name + " has no attribute " + attr);
    }
    return new AttrValue(attr);
  } else {
    return JSON.parse(value);
  }
}

function resolveValue(value, attrs, expr) {
  if (!(value instanceof AttrValue)) {
    return value;
  }
  var attrVal = attrs && attrs[value.attr];
  return attrVal !== undefined ? attrVal : expr.nodeType.defaultAttrs[value.attr];
}

function checkCount(elt, count, attrs, expr) {
  return count >= resolveValue(elt.min, attrs, expr) && count <= resolveValue(elt.max, attrs, expr);
}

function expandTypes(schema, types) {
  var result = [];
  types.forEach(function (type) {
    var found = schema.nodes[type];
    if (found) {
      if (result.indexOf(found) == -1) {
        result.push(found);
      }
    } else {
      for (var name in schema.nodes) {
        var nodeType = schema.nodes[name];
        if (nodeType.groups.indexOf(type) > -1 && result.indexOf(nodeType) == -1) {
          found = result.push(nodeType);
        }
      }
    }
    if (!found) {
      throw new SyntaxError("Node type or group '" + type + "' does not exist");
    }
  });
  return result;
}

var many = 2e9; // Big number representable as a 32-bit int

function parseRepeat(nodeType, match) {
  var min = 1,
      max = 1;
  if (match) {
    if (match[1] == "+") {
      max = many;
    } else if (match[1] == "*") {
      min = 0;
      max = many;
    } else if (match[1] == "?") {
      min = 0;
    } else if (match[2]) {
      min = parseValue(nodeType, match[2]);
      if (match[3]) {
        max = match[4] ? parseValue(nodeType, match[4]) : many;
      } else {
        max = min;
      }
    }
    if (max == 0 || min > max) {
      throw new SyntaxError("Invalid repeat count in '" + match[0] + "'");
    }
  }
  return { min: min, max: max };
}

function parseAttrs(nodeType, expr) {
  var parts = expr.split(/\s*,\s*/);
  var attrs = Object.create(null);
  for (var i = 0; i < parts.length; i++) {
    var match = /^(\w+)=(\w+|\"(?:\\.|[^\\])*\"|\.\w+)$/.exec(parts[i]);
    if (!match) {
      throw new SyntaxError("Invalid attribute syntax: " + parts[i]);
    }
    attrs[match[1]] = parseValue(nodeType, match[2]);
  }
  return attrs;
}

},{"./fragment":5,"./mark":8}],4:[function(require,module,exports){
function findDiffStart(a, b, pos) {
  for (var i = 0;; i++) {
    if (i == a.childCount || i == b.childCount) {
      return a.childCount == b.childCount ? null : pos;
    }

    var childA = a.child(i),
        childB = b.child(i);
    if (childA == childB) {
      pos += childA.nodeSize;continue;
    }

    if (!childA.sameMarkup(childB)) {
      return pos;
    }

    if (childA.isText && childA.text != childB.text) {
      for (var j = 0; childA.text[j] == childB.text[j]; j++) {
        pos++;
      }
      return pos;
    }
    if (childA.content.size || childB.content.size) {
      var inner = findDiffStart(childA.content, childB.content, pos + 1);
      if (inner != null) {
        return inner;
      }
    }
    pos += childA.nodeSize;
  }
}
exports.findDiffStart = findDiffStart;

function findDiffEnd(a, b, posA, posB) {
  for (var iA = a.childCount, iB = b.childCount;;) {
    if (iA == 0 || iB == 0) {
      return iA == iB ? null : { a: posA, b: posB };
    }

    var childA = a.child(--iA),
        childB = b.child(--iB),
        size = childA.nodeSize;
    if (childA == childB) {
      posA -= size;posB -= size;
      continue;
    }

    if (!childA.sameMarkup(childB)) {
      return { a: posA, b: posB };
    }

    if (childA.isText && childA.text != childB.text) {
      var same = 0,
          minSize = Math.min(childA.text.length, childB.text.length);
      while (same < minSize && childA.text[childA.text.length - same - 1] == childB.text[childB.text.length - same - 1]) {
        same++;posA--;posB--;
      }
      return { a: posA, b: posB };
    }
    if (childA.content.size || childB.content.size) {
      var inner = findDiffEnd(childA.content, childB.content, posA - 1, posB - 1);
      if (inner) {
        return inner;
      }
    }
    posA -= size;posB -= size;
  }
}
exports.findDiffEnd = findDiffEnd;

},{}],5:[function(require,module,exports){
var ref = require("./diff");
var findDiffStart = ref.findDiffStart;
var findDiffEnd = ref.findDiffEnd;

// ::- Fragment is the type used to represent a node's collection of
// child nodes.
//
// Fragments are persistent data structures. That means you should
// _not_ mutate them or their content, but create new instances
// whenever needed. The API tries to make this easy.
var Fragment = function (content, size) {
  var this$1 = this;

  this.content = content;
  this.size = size || 0;
  if (size == null) {
    for (var i = 0; i < content.length; i++) {
      this$1.size += content[i].nodeSize;
    }
  }
};

var prototypeAccessors = { firstChild: {}, lastChild: {}, childCount: {} };

// :: (number, number, (node: Node, start: number, parent: Node, index: number) → ?bool)
// Invoke a callback for all descendant nodes between the given two
// positions (relative to start of this fragment). Doesn't descend
// into a node when the callback returns `false`.
Fragment.prototype.nodesBetween = function (from, to, f, nodeStart, parent) {
  var this$1 = this;
  if (nodeStart === void 0) nodeStart = 0;

  for (var i = 0, pos = 0; pos < to; i++) {
    var child = this$1.content[i],
        end = pos + child.nodeSize;
    if (end > from && f(child, nodeStart + pos, parent, i) !== false && child.content.size) {
      var start = pos + 1;
      child.nodesBetween(Math.max(0, from - start), Math.min(child.content.size, to - start), f, nodeStart + start);
    }
    pos = end;
  }
};

// :: ((node: Node, pos: number, parent: Node) → ?bool)
// Call the given callback for every descendant node. The callback
// may return `false` to prevent traversal of its child nodes.
Fragment.prototype.descendants = function (f) {
  this.nodesBetween(0, this.size, f);
};

// : (number, number, ?string, ?string) → string
Fragment.prototype.textBetween = function (from, to, blockSeparator, leafText) {
  var text = "",
      separated = true;
  this.nodesBetween(from, to, function (node, pos) {
    if (node.isText) {
      text += node.text.slice(Math.max(from, pos) - pos, to - pos);
      separated = !blockSeparator;
    } else if (node.isLeaf && leafText) {
      text += leafText;
      separated = !blockSeparator;
    } else if (!separated && node.isBlock) {
      text += blockSeparator;
      separated = true;
    }
  }, 0);
  return text;
};

// :: (Fragment) → Fragment
// Create a new fragment containing the content of this fragment and
// `other`.
Fragment.prototype.append = function (other) {
  if (!other.size) {
    return this;
  }
  if (!this.size) {
    return other;
  }
  var last = this.lastChild,
      first = other.firstChild,
      content = this.content.slice(),
      i = 0;
  if (last.isText && last.sameMarkup(first)) {
    content[content.length - 1] = last.withText(last.text + first.text);
    i = 1;
  }
  for (; i < other.content.length; i++) {
    content.push(other.content[i]);
  }
  return new Fragment(content, this.size + other.size);
};

// :: (number, ?number) → Fragment
// Cut out the sub-fragment between the two given positions.
Fragment.prototype.cut = function (from, to) {
  var this$1 = this;

  if (to == null) {
    to = this.size;
  }
  if (from == 0 && to == this.size) {
    return this;
  }
  var result = [],
      size = 0;
  if (to > from) {
    for (var i = 0, pos = 0; pos < to; i++) {
      var child = this$1.content[i],
          end = pos + child.nodeSize;
      if (end > from) {
        if (pos < from || end > to) {
          if (child.isText) {
            child = child.cut(Math.max(0, from - pos), Math.min(child.text.length, to - pos));
          } else {
            child = child.cut(Math.max(0, from - pos - 1), Math.min(child.content.size, to - pos - 1));
          }
        }
        result.push(child);
        size += child.nodeSize;
      }
      pos = end;
    }
  }
  return new Fragment(result, size);
};

Fragment.prototype.cutByIndex = function (from, to) {
  if (from == to) {
    return Fragment.empty;
  }
  if (from == 0 && to == this.content.length) {
    return this;
  }
  return new Fragment(this.content.slice(from, to));
};

// :: (number, Node) → Fragment
// Create a new fragment in which the node at the given index is
// replaced by the given node.
Fragment.prototype.replaceChild = function (index, node) {
  var current = this.content[index];
  if (current == node) {
    return this;
  }
  var copy = this.content.slice();
  var size = this.size + node.nodeSize - current.nodeSize;
  copy[index] = node;
  return new Fragment(copy, size);
};

// : (Node) → Fragment
// Create a new fragment by prepending the given node to this
// fragment.
Fragment.prototype.addToStart = function (node) {
  return new Fragment([node].concat(this.content), this.size + node.nodeSize);
};

// : (Node) → Fragment
// Create a new fragment by appending the given node to this
// fragment.
Fragment.prototype.addToEnd = function (node) {
  return new Fragment(this.content.concat(node), this.size + node.nodeSize);
};

// :: (Fragment) → bool
// Compare this fragment to another one.
Fragment.prototype.eq = function (other) {
  var this$1 = this;

  if (this.content.length != other.content.length) {
    return false;
  }
  for (var i = 0; i < this.content.length; i++) {
    if (!this$1.content[i].eq(other.content[i])) {
      return false;
    }
  }
  return true;
};

// :: ?Node
// The first child of the fragment, or `null` if it is empty.
prototypeAccessors.firstChild.get = function () {
  return this.content.length ? this.content[0] : null;
};

// :: ?Node
// The last child of the fragment, or `null` if it is empty.
prototypeAccessors.lastChild.get = function () {
  return this.content.length ? this.content[this.content.length - 1] : null;
};

// :: number
// The number of child nodes in this fragment.
prototypeAccessors.childCount.get = function () {
  return this.content.length;
};

// :: (number) → Node
// Get the child node at the given index. Raise an error when the
// index is out of range.
Fragment.prototype.child = function (index) {
  var found = this.content[index];
  if (!found) {
    throw new RangeError("Index " + index + " out of range for " + this);
  }
  return found;
};

// :: (number) → number
// Get the offset at (size of children before) the given index.
Fragment.prototype.offsetAt = function (index) {
  var this$1 = this;

  var offset = 0;
  for (var i = 0; i < index; i++) {
    offset += this$1.content[i].nodeSize;
  }
  return offset;
};

// :: (number) → ?Node
// Get the child node at the given index, if it exists.
Fragment.prototype.maybeChild = function (index) {
  return this.content[index];
};

// :: ((node: Node, offset: number, index: number))
// Call `f` for every child node, passing the node, its offset
// into this parent node, and its index.
Fragment.prototype.forEach = function (f) {
  var this$1 = this;

  for (var i = 0, p = 0; i < this.content.length; i++) {
    var child = this$1.content[i];
    f(child, p, i);
    p += child.nodeSize;
  }
};

// :: (Fragment) → ?number
// Find the first position at which this fragment and another
// fragment differ, or `null` if they are the same.
Fragment.prototype.findDiffStart = function (other, pos) {
  if (pos === void 0) pos = 0;

  return findDiffStart(this, other, pos);
};

// :: (Node) → ?{a: number, b: number}
// Find the first position, searching from the end, at which this
// fragment and the given fragment differ, or `null` if they are the
// same. Since this position will not be the same in both nodes, an
// object with two separate positions is returned.
Fragment.prototype.findDiffEnd = function (other, pos, otherPos) {
  if (pos === void 0) pos = this.size;
  if (otherPos === void 0) otherPos = other.size;

  return findDiffEnd(this, other, pos, otherPos);
};

// : (number, ?number) → {index: number, offset: number}
// Find the index and inner offset corresponding to a given relative
// position in this fragment. The result object will be reused
// (overwritten) the next time the function is called. (Not public.)
Fragment.prototype.findIndex = function (pos, round) {
  var this$1 = this;
  if (round === void 0) round = -1;

  if (pos == 0) {
    return retIndex(0, pos);
  }
  if (pos == this.size) {
    return retIndex(this.content.length, pos);
  }
  if (pos > this.size || pos < 0) {
    throw new RangeError("Position " + pos + " outside of fragment (" + this + ")");
  }
  for (var i = 0, curPos = 0;; i++) {
    var cur = this$1.child(i),
        end = curPos + cur.nodeSize;
    if (end >= pos) {
      if (end == pos || round > 0) {
        return retIndex(i + 1, end);
      }
      return retIndex(i, curPos);
    }
    curPos = end;
  }
};

// :: () → string
// Return a debugging string that describes this fragment.
Fragment.prototype.toString = function () {
  return "<" + this.toStringInner() + ">";
};

Fragment.prototype.toStringInner = function () {
  return this.content.join(", ");
};

// :: () → ?Object
// Create a JSON-serializeable representation of this fragment.
Fragment.prototype.toJSON = function () {
  return this.content.length ? this.content.map(function (n) {
    return n.toJSON();
  }) : null;
};

// :: (Schema, ?Object) → Fragment
// Deserialize a fragment from its JSON representation.
Fragment.fromJSON = function (schema, value) {
  return value ? new Fragment(value.map(schema.nodeFromJSON)) : Fragment.empty;
};

// :: ([Node]) → Fragment
// Build a fragment from an array of nodes. Ensures that adjacent
// text nodes with the same style are joined together.
Fragment.fromArray = function (array) {
  if (!array.length) {
    return Fragment.empty;
  }
  var joined,
      size = 0;
  for (var i = 0; i < array.length; i++) {
    var node = array[i];
    size += node.nodeSize;
    if (i && node.isText && array[i - 1].sameMarkup(node)) {
      if (!joined) {
        joined = array.slice(0, i);
      }
      joined[joined.length - 1] = node.withText(joined[joined.length - 1].text + node.text);
    } else if (joined) {
      joined.push(node);
    }
  }
  return new Fragment(joined || array, size);
};

// :: (?union<Fragment, Node, [Node]>) → Fragment
// Create a fragment from something that can be interpreted as a set
// of nodes. For `null`, it returns the empty fragment. For a
// fragment, the fragment itself. For a node or array of nodes, a
// fragment containing those nodes.
Fragment.from = function (nodes) {
  if (!nodes) {
    return Fragment.empty;
  }
  if (nodes instanceof Fragment) {
    return nodes;
  }
  if (Array.isArray(nodes)) {
    return this.fromArray(nodes);
  }
  return new Fragment([nodes], nodes.nodeSize);
};

Object.defineProperties(Fragment.prototype, prototypeAccessors);
exports.Fragment = Fragment;

var found = { index: 0, offset: 0 };
function retIndex(index, offset) {
  found.index = index;
  found.offset = offset;
  return found;
}

// :: Fragment
// An empty fragment. Intended to be reused whenever a node doesn't
// contain anything (rather than allocating a new empty fragment for
// each leaf node).
Fragment.empty = new Fragment([], 0);

},{"./diff":4}],6:[function(require,module,exports){
var ref = require("./fragment");
var Fragment = ref.Fragment;
var ref$1 = require("./replace");
var Slice = ref$1.Slice;
var ref$2 = require("./mark");
var Mark = ref$2.Mark;

// ParseOptions:: interface
// Set of options for parsing a DOM node.
//
//   preserveWhitespace:: ?union<bool, "full">
//   By default, whitespace is collapsed as per HTML's rules. Pass
//   `true` to preserve whitespace, but normalize newlines to
//   spaces, and `"full"` to preserve whitespace entirely.
//
//   findPositions:: ?[{node: dom.Node, offset: number}]
//   When given, the parser will, beside parsing the content,
//   record the document positions of the given DOM positions. It
//   will do so by writing to the objects, adding a `pos` property
//   that holds the document position. DOM positions that are not
//   in the parsed content will not be written to.
//
//   from:: ?number
//   The child node index to start parsing from.
//
//   to:: ?number
//   The child node index to stop parsing at.
//
//   topNode:: ?Node
//   By default, the content is parsed into the schema's default
//   [top node type](#model.Schema.topNodeType). You can pass this
//   option to use the type and attributes from a different node
//   as the top container.
//
//   topStart:: ?number
//   Can be used to influence the content match at the start of
//   the topnode. When given, should be a valid index into
//   `topNode`.
//
//   context:: ?ResolvedPos
//   A set of additional node names to count as
//   [context](#model.ParseRule.context) when parsing, above the
//   given [top node](#model.DOMParser.parse^options.topNode).

// ParseRule:: interface
// A value that describes how to parse a given DOM node or inline
// style as a ProseMirror node or mark.
//
//   tag:: ?string
//   A CSS selector describing the kind of DOM elements to match. A
//   single rule should have _either_ a `tag` or a `style` property.
//
//   namespace:: ?string
//   The namespace to match. This should be used with `tag`.
//   Nodes are only matched when the namespace matches or this property
//   is null.
//
//   style:: ?string
//   A CSS property name to match. When given, this rule matches
//   inline styles that list that property.
//
//   context:: ?string
//   When given, restricts this rule to only match when the current
//   context—the parent nodes into which the content is being
//   parsed—matches this expression. Should contain one or more node
//   names or node group names followed by single or double slashes.
//   For example `"paragraph/"` means the rule only matches when the
//   parent node is a paragraph, `"blockquote/paragraph/"` restricts
//   it to be in a paragraph that is inside a blockquote, and
//   `"section//"` matches any position inside a section—a double
//   slash matches any sequence of ancestor nodes.
//
//   node:: ?string
//   The name of the node type to create when this rule matches. Only
//   valid for rules with a `tag` property, not for style rules. Each
//   rule should have one of a `node`, `mark`, or `ignore` property
//   (except when it appears in a [node](#model.NodeSpec.parseDOM) or
//   [mark spec](#model.MarkSpec.parseDOM), in which case the `node`
//   or `mark` property will be derived from its position).
//
//   mark:: ?string
//   The name of the mark type to wrap the matched content in.
//
//   priority:: ?number
//   Can be used to change the order in which the parse rules in a
//   schema are tried. Those with higher priority come first. Rules
//   without a priority are counted as having priority 50. This
//   property is only meaningful in a schema—when directly
//   constructing a parser, the order of the rule array is used.
//
//   ignore:: ?bool
//   When true, ignore content that matches this rule.
//
//   skip:: ?bool
//   When true, ignore the node that matches this rule, but do parse
//   its content.
//
//   attrs:: ?Object
//   Attributes for the node or mark created by this rule. When
//   `getAttrs` is provided, it takes precedence.
//
//   getAttrs:: ?(union<dom.Node, string>) → ?union<bool, Object>
//   A function used to compute the attributes for the node or mark
//   created by this rule. Can also be used to describe further
//   conditions the DOM element or style must match. When it returns
//   `false`, the rule won't match. When it returns null or undefined,
//   that is interpreted as an empty/default set of attributes.
//
//   Called with a DOM Element for `tag` rules, and with a string (the
//   style's value) for `style` rules.
//
//   contentElement:: ?string
//   For `tag` rules that produce non-leaf nodes or marks, by default
//   the content of the DOM element is parsed as content of the mark
//   or node. If the child nodes are in a descendent node, this may be
//   a CSS selector string that the parser must use to find the actual
//   content element.
//
//   getContent:: ?(dom.Node) → Fragment
//   Can be used to override the content of a matched node. Will be
//   called, and its result used, instead of parsing the node's child
//   nodes.
//
//   preserveWhitespace:: ?union<bool, "full">
//   Controls whether whitespace should be preserved when parsing the
//   content inside the matched element. `false` means whitespace may
//   be collapsed, `true` means that whitespace should be preserved
//   but newlines normalized to spaces, and `"full"` means that
//   newlines should also be preserved.

// ::- A DOM parser represents a strategy for parsing DOM content into
// a ProseMirror document conforming to a given schema. Its behavior
// is defined by an array of [rules](#model.ParseRule).
var DOMParser = function (schema, rules) {
  var this$1 = this;

  // :: Schema
  this.schema = schema;
  // :: [ParseRule]
  this.rules = rules;
  this.tags = [];
  this.styles = [];

  rules.forEach(function (rule) {
    if (rule.tag) {
      this$1.tags.push(rule);
    } else if (rule.style) {
      this$1.styles.push(rule);
    }
  });
};

// :: (dom.Node, ?ParseOptions) → Node
// Parse a document from the content of a DOM node.
DOMParser.prototype.parse = function (dom, options) {
  if (options === void 0) options = {};

  var context = new ParseContext(this, options, false);
  context.addAll(dom, null, options.from, options.to);
  return context.finish();
};

// :: (dom.Node, ?ParseOptions) → Slice
// Parses the content of the given DOM node, like
// [`parse`](#model.DOMParser.parse), and takes the same set of
// options. But unlike that method, which produces a whole node,
// this one returns a slice that is open at the sides, meaning that
// the schema constraints aren't applied to the start of nodes to
// the left of the input and the end of nodes at the end.
DOMParser.prototype.parseSlice = function (dom, options) {
  if (options === void 0) options = {};

  var context = new ParseContext(this, options, true);
  context.addAll(dom, null, options.from, options.to);
  return Slice.maxOpen(context.finish());
};

DOMParser.prototype.matchTag = function (dom, context) {
  var this$1 = this;

  for (var i = 0; i < this.tags.length; i++) {
    var rule = this$1.tags[i];
    if (matches(dom, rule.tag) && (!rule.namespace || dom.namespaceURI == rule.namespace) && (!rule.context || context.matchesContext(rule.context))) {
      if (rule.getAttrs) {
        var result = rule.getAttrs(dom);
        if (result === false) {
          continue;
        }
        rule.attrs = result;
      }
      return rule;
    }
  }
};

DOMParser.prototype.matchStyle = function (prop, value, context) {
  var this$1 = this;

  for (var i = 0; i < this.styles.length; i++) {
    var rule = this$1.styles[i];
    if (rule.style == prop && (!rule.context || context.matchesContext(rule.context))) {
      if (rule.getAttrs) {
        var result = rule.getAttrs(value);
        if (result === false) {
          continue;
        }
        rule.attrs = result;
      }
      return rule;
    }
  }
};

// :: (Schema) → [ParseRule]
// Extract the parse rules listed in a schema's [node
// specs](#model.NodeSpec.parseDOM).
DOMParser.schemaRules = function (schema) {
  var result = [];
  function insert(rule) {
    var priority = rule.priority == null ? 50 : rule.priority,
        i = 0;
    for (; i < result.length; i++) {
      var next = result[i],
          nextPriority = next.priority == null ? 50 : next.priority;
      if (nextPriority < priority) {
        break;
      }
    }
    result.splice(i, 0, rule);
  }

  var loop = function (name) {
    var rules = schema.marks[name].spec.parseDOM;
    if (rules) {
      rules.forEach(function (rule) {
        insert(rule = copy(rule));
        rule.mark = name;
      });
    }
  };

  for (var name in schema.marks) loop(name);
  var loop$1 = function (name) {
    var rules$1 = schema.nodes[name$1].spec.parseDOM;
    if (rules$1) {
      rules$1.forEach(function (rule) {
        insert(rule = copy(rule));
        rule.node = name$1;
      });
    }
  };

  for (var name$1 in schema.nodes) loop$1(name);
  return result;
};

// :: (Schema) → DOMParser
// Construct a DOM parser using the parsing rules listed in a
// schema's [node specs](#model.NodeSpec.parseDOM).
DOMParser.fromSchema = function (schema) {
  return schema.cached.domParser || (schema.cached.domParser = new DOMParser(schema, DOMParser.schemaRules(schema)));
};
exports.DOMParser = DOMParser;

// : Object<bool> The block-level tags in HTML5
var blockTags = {
  address: true, article: true, aside: true, blockquote: true, canvas: true,
  dd: true, div: true, dl: true, fieldset: true, figcaption: true, figure: true,
  footer: true, form: true, h1: true, h2: true, h3: true, h4: true, h5: true,
  h6: true, header: true, hgroup: true, hr: true, li: true, noscript: true, ol: true,
  output: true, p: true, pre: true, section: true, table: true, tfoot: true, ul: true

  // : Object<bool> The tags that we normally ignore.
};var ignoreTags = {
  head: true, noscript: true, object: true, script: true, style: true, title: true

  // : Object<bool> List tags.
};var listTags = { ol: true, ul: true

  // Using a bitfield for node context options
};var OPT_PRESERVE_WS = 1,
    OPT_PRESERVE_WS_FULL = 2,
    OPT_OPEN_LEFT = 4;

function wsOptionsFor(preserveWhitespace) {
  return (preserveWhitespace ? OPT_PRESERVE_WS : 0) | (preserveWhitespace === "full" ? OPT_PRESERVE_WS_FULL : 0);
}

var NodeContext = function (type, attrs, solid, match, options) {
  this.type = type;
  this.attrs = attrs;
  this.solid = solid;
  this.match = match || (options & OPT_OPEN_LEFT ? null : type.contentExpr.start(attrs));
  this.options = options;
  this.content = [];
};

NodeContext.prototype.findWrapping = function (type, attrs) {
  if (!this.match) {
    if (!this.type) {
      return [];
    }
    var found = this.type.contentExpr.atType(this.attrs, type, attrs);
    if (!found) {
      var start = this.type.contentExpr.start(this.attrs),
          wrap;
      if (wrap = start.findWrapping(type, attrs)) {
        this.match = start;
        return wrap;
      }
    }
    if (found) {
      this.match = found;
    } else {
      return null;
    }
  }
  return this.match.findWrapping(type, attrs);
};

NodeContext.prototype.finish = function (openEnd) {
  if (!(this.options & OPT_PRESERVE_WS)) {
    // Strip trailing whitespace
    var last = this.content[this.content.length - 1],
        m;
    if (last && last.isText && (m = /\s+$/.exec(last.text))) {
      if (last.text.length == m[0].length) {
        this.content.pop();
      } else {
        this.content[this.content.length - 1] = last.withText(last.text.slice(0, last.text.length - m[0].length));
      }
    }
  }
  var content = Fragment.from(this.content);
  if (!openEnd && this.match) {
    content = content.append(this.match.fillBefore(Fragment.empty, true));
  }
  return this.type ? this.type.create(this.attrs, content) : content;
};

var ParseContext = function (parser, options, open) {
  // : DOMParser The parser we are using.
  this.parser = parser;
  // : Object The options passed to this parse.
  this.options = options;
  this.isOpen = open;
  var topNode = options.topNode,
      topContext;
  var topOptions = wsOptionsFor(options.preserveWhitespace) | (open ? OPT_OPEN_LEFT : 0);
  if (topNode) {
    topContext = new NodeContext(topNode.type, topNode.attrs, true, topNode.contentMatchAt(options.topStart || 0), topOptions);
  } else if (open) {
    topContext = new NodeContext(null, null, true, null, topOptions);
  } else {
    topContext = new NodeContext(parser.schema.topNodeType, null, true, null, topOptions);
  }
  this.nodes = [topContext];
  // : [Mark] The current set of marks
  this.marks = Mark.none;
  this.open = 0;
  this.find = options.findPositions;
  this.needsBlock = false;
};

var prototypeAccessors = { top: {}, currentPos: {} };

prototypeAccessors.top.get = function () {
  return this.nodes[this.open];
};

// : (Mark) → [Mark]
// Add a mark to the current set of marks, return the old set.
ParseContext.prototype.addMark = function (mark) {
  var old = this.marks;
  this.marks = mark.addToSet(this.marks);
  return old;
};

// : (dom.Node)
// Add a DOM node to the content. Text is inserted as text node,
// otherwise, the node is passed to `addElement` or, if it has a
// `style` attribute, `addElementWithStyles`.
ParseContext.prototype.addDOM = function (dom) {
  if (dom.nodeType == 3) {
    this.addTextNode(dom);
  } else if (dom.nodeType == 1) {
    var style = dom.getAttribute("style");
    if (style) {
      this.addElementWithStyles(parseStyles(style), dom);
    } else {
      this.addElement(dom);
    }
  }
};

ParseContext.prototype.addTextNode = function (dom) {
  var value = dom.nodeValue;
  var top = this.top;
  if (top.type && top.type.inlineContent || /\S/.test(value)) {
    if (!(top.options & OPT_PRESERVE_WS)) {
      value = value.replace(/\s+/g, " ");
      // If this starts with whitespace, and there is either no node
      // before it or a node that ends with whitespace, strip the
      // leading space.
      if (/^\s/.test(value) && this.open == this.nodes.length - 1) {
        var nodeBefore = top.content[top.content.length - 1];
        if (!nodeBefore || nodeBefore.isText && /\s$/.test(nodeBefore.text)) {
          value = value.slice(1);
        }
      }
    } else if (!(top.options & OPT_PRESERVE_WS_FULL)) {
      value = value.replace(/\r?\n|\r/g, " ");
    }
    if (value) {
      this.insertNode(this.parser.schema.text(value, this.marks));
    }
    this.findInText(dom);
  } else {
    this.findInside(dom);
  }
};

// : (dom.Element)
// Try to find a handler for the given tag and use that to parse. If
// none is found, the element's content nodes are added directly.
ParseContext.prototype.addElement = function (dom) {
  var name = dom.nodeName.toLowerCase();
  if (listTags.hasOwnProperty(name)) {
    normalizeList(dom);
  }
  var rule = this.options.ruleFromNode && this.options.ruleFromNode(dom) || this.parser.matchTag(dom, this);
  if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
    this.findInside(dom);
  } else if (!rule || rule.skip) {
    if (rule && rule.skip.nodeType) {
      dom = rule.skip;
    }
    var sync,
        oldNeedsBlock = this.needsBlock;
    if (blockTags.hasOwnProperty(name)) {
      sync = this.top;
      if (!sync.type) {
        this.needsBlock = true;
      }
    }
    this.addAll(dom);
    if (sync) {
      this.sync(sync);
    }
    this.needsBlock = oldNeedsBlock;
  } else {
    this.addElementByRule(dom, rule);
  }
};

// Run any style parser associated with the node's styles. After
// that, if no style parser suppressed the node's content, pass it
// through to `addElement`.
ParseContext.prototype.addElementWithStyles = function (styles, dom) {
  var this$1 = this;

  var oldMarks = this.marks,
      ignore = false;
  for (var i = 0; i < styles.length; i += 2) {
    var rule = this$1.parser.matchStyle(styles[i], styles[i + 1], this$1);
    if (!rule) {
      continue;
    }
    if (rule.ignore) {
      ignore = true;break;
    }
    this$1.addMark(this$1.parser.schema.marks[rule.mark].create(rule.attrs));
  }
  if (!ignore) {
    this.addElement(dom);
  }
  this.marks = oldMarks;
};

// : (dom.Element, ParseRule) → bool
// Look up a handler for the given node. If none are found, return
// false. Otherwise, apply it, use its return value to drive the way
// the node's content is wrapped, and return true.
ParseContext.prototype.addElementByRule = function (dom, rule) {
  var this$1 = this;

  var sync, before, nodeType, markType, mark;
  if (rule.node) {
    nodeType = this.parser.schema.nodes[rule.node];
    if (nodeType.isLeaf) {
      this.insertNode(nodeType.create(rule.attrs, null, this.marks));
    } else {
      sync = this.enter(nodeType, rule.attrs, rule.preserveWhitespace) && this.top;
    }
  } else {
    markType = this.parser.schema.marks[rule.mark];
    before = this.addMark(mark = markType.create(rule.attrs));
  }

  if (nodeType && nodeType.isLeaf) {
    this.findInside(dom);
  } else if (rule.getContent) {
    this.findInside(dom);
    rule.getContent(dom).forEach(function (node) {
      return this$1.insertNode(mark ? node.mark(mark.addToSet(node.marks)) : node);
    });
  } else {
    var contentDOM = rule.contentElement;
    if (typeof contentDOM == "string") {
      contentDOM = dom.querySelector(contentDOM);
    }
    if (!contentDOM) {
      contentDOM = dom;
    }
    this.findAround(dom, contentDOM, true);
    this.addAll(contentDOM, sync);
  }
  if (sync) {
    this.sync(sync);this.open--;
  } else if (before) {
    this.marks = before;
  }
  return true;
};

// : (dom.Node, ?NodeBuilder, ?number, ?number)
// Add all child nodes between `startIndex` and `endIndex` (or the
// whole node, if not given). If `sync` is passed, use it to
// synchronize after every block element.
ParseContext.prototype.addAll = function (parent, sync, startIndex, endIndex) {
  var this$1 = this;

  var index = startIndex || 0;
  for (var dom = startIndex ? parent.childNodes[startIndex] : parent.firstChild, end = endIndex == null ? null : parent.childNodes[endIndex]; dom != end; dom = dom.nextSibling, ++index) {
    this$1.findAtPoint(parent, index);
    this$1.addDOM(dom);
    if (sync && blockTags.hasOwnProperty(dom.nodeName.toLowerCase())) {
      this$1.sync(sync);
    }
  }
  this.findAtPoint(parent, index);
};

// Try to find a way to fit the given node type into the current
// context. May add intermediate wrappers and/or leave non-solid
// nodes that we're in.
ParseContext.prototype.findPlace = function (type, attrs) {
  var this$1 = this;

  var route, sync;
  for (var depth = this.open; depth >= 0; depth--) {
    var node = this$1.nodes[depth];
    var found = node.findWrapping(type, attrs);
    if (found && (!route || route.length > found.length)) {
      route = found;
      sync = node;
      if (!found.length) {
        break;
      }
    }
    if (node.solid) {
      break;
    }
  }
  if (!route) {
    return false;
  }
  this.sync(sync);
  for (var i = 0; i < route.length; i++) {
    this$1.enterInner(route[i].type, route[i].attrs, false);
  }
  return true;
};

// : (Node) → ?Node
// Try to insert the given node, adjusting the context when needed.
ParseContext.prototype.insertNode = function (node) {
  if (node.isInline && this.needsBlock && !this.top.type) {
    var block = this.textblockFromContext();
    if (block) {
      this.enter(block);
    }
  }
  if (this.findPlace(node.type, node.attrs)) {
    this.closeExtra();
    var top = this.top;
    if (top.match) {
      var match = top.match.matchNode(node);
      if (!match) {
        node = node.mark(node.marks.filter(function (mark) {
          return top.match.allowsMark(mark.type);
        }));
        match = top.match.matchNode(node);
      }
      top.match = match;
    }
    top.content.push(node);
  }
};

// : (NodeType, ?Object) → bool
// Try to start a node of the given type, adjusting the context when
// necessary.
ParseContext.prototype.enter = function (type, attrs, preserveWS) {
  var ok = this.findPlace(type, attrs);
  if (ok) {
    this.enterInner(type, attrs, true, preserveWS);
  }
  return ok;
};

// Open a node of the given type
ParseContext.prototype.enterInner = function (type, attrs, solid, preserveWS) {
  this.closeExtra();
  var top = this.top;
  top.match = top.match && top.match.matchType(type, attrs);
  var options = preserveWS == null ? top.options & ~OPT_OPEN_LEFT : wsOptionsFor(preserveWS);
  if (top.options & OPT_OPEN_LEFT && top.content.length == 0) {
    options |= OPT_OPEN_LEFT;
  }
  this.nodes.push(new NodeContext(type, attrs, solid, null, options));
  this.open++;
};

// Make sure all nodes above this.open are finished and added to
// their parents
ParseContext.prototype.closeExtra = function (openEnd) {
  var this$1 = this;

  var i = this.nodes.length - 1;
  if (i > this.open) {
    this.marks = Mark.none;
    for (; i > this.open; i--) {
      this$1.nodes[i - 1].content.push(this$1.nodes[i].finish(openEnd));
    }
    this.nodes.length = this.open + 1;
  }
};

ParseContext.prototype.finish = function () {
  this.open = 0;
  this.closeExtra(this.isOpen);
  return this.nodes[0].finish(this.isOpen || this.options.topOpen);
};

ParseContext.prototype.sync = function (to) {
  var this$1 = this;

  for (var i = this.open; i >= 0; i--) {
    if (this$1.nodes[i] == to) {
      this$1.open = i;
      return;
    }
  }
};

prototypeAccessors.currentPos.get = function () {
  var this$1 = this;

  this.closeExtra();
  var pos = 0;
  for (var i = this.open; i >= 0; i--) {
    var content = this$1.nodes[i].content;
    for (var j = content.length - 1; j >= 0; j--) {
      pos += content[j].nodeSize;
    }
    if (i) {
      pos++;
    }
  }
  return pos;
};

ParseContext.prototype.findAtPoint = function (parent, offset) {
  var this$1 = this;

  if (this.find) {
    for (var i = 0; i < this.find.length; i++) {
      if (this$1.find[i].node == parent && this$1.find[i].offset == offset) {
        this$1.find[i].pos = this$1.currentPos;
      }
    }
  }
};

ParseContext.prototype.findInside = function (parent) {
  var this$1 = this;

  if (this.find) {
    for (var i = 0; i < this.find.length; i++) {
      if (this$1.find[i].pos == null && parent.nodeType == 1 && parent.contains(this$1.find[i].node)) {
        this$1.find[i].pos = this$1.currentPos;
      }
    }
  }
};

ParseContext.prototype.findAround = function (parent, content, before) {
  var this$1 = this;

  if (parent != content && this.find) {
    for (var i = 0; i < this.find.length; i++) {
      if (this$1.find[i].pos == null && parent.nodeType == 1 && parent.contains(this$1.find[i].node)) {
        var pos = content.compareDocumentPosition(this$1.find[i].node);
        if (pos & (before ? 2 : 4)) {
          this$1.find[i].pos = this$1.currentPos;
        }
      }
    }
  }
};

ParseContext.prototype.findInText = function (textNode) {
  var this$1 = this;

  if (this.find) {
    for (var i = 0; i < this.find.length; i++) {
      if (this$1.find[i].node == textNode) {
        this$1.find[i].pos = this$1.currentPos - (textNode.nodeValue.length - this$1.find[i].offset);
      }
    }
  }
};

// : (string) → bool
// Determines whether the given [context
// string](#ParseRule.context) matches this context.
ParseContext.prototype.matchesContext = function (context) {
  var this$1 = this;

  var parts = context.split("/");
  var option = this.options.context;
  var useRoot = !this.isOpen && (!option || option.parent.type == this.nodes[0].type);
  var minDepth = -(option ? option.depth + 1 : 0) + (useRoot ? 0 : 1);
  var match = function (i, depth) {
    for (; i >= 0; i--) {
      var part = parts[i];
      if (part == "") {
        if (i == parts.length - 1 || i == 0) {
          continue;
        }
        for (; depth >= minDepth; depth--) {
          if (match(i - 1, depth)) {
            return true;
          }
        }
        return false;
      } else {
        var next = depth > 0 || depth == 0 && useRoot ? this$1.nodes[depth].type : option && depth >= minDepth ? option.node(depth - minDepth).type : null;
        if (!next || next.name != part && next.groups.indexOf(part) == -1) {
          return false;
        }
        depth--;
      }
    }
    return true;
  };
  return match(parts.length - 1, this.open);
};

ParseContext.prototype.textblockFromContext = function () {
  var this$1 = this;

  var $context = this.options.context;
  if ($context) {
    for (var d = $context.depth; d >= 0; d--) {
      var deflt = $context.node(d).defaultContentType($context.indexAfter(d));
      if (deflt && deflt.isTextblock && deflt.defaultAttrs) {
        return deflt;
      }
    }
  }
  for (var name in this$1.parser.schema.nodes) {
    var type = this$1.parser.schema.nodes[name];
    if (type.isTextblock && type.defaultAttrs) {
      return type;
    }
  }
};

Object.defineProperties(ParseContext.prototype, prototypeAccessors);

// Kludge to work around directly nested list nodes produced by some
// tools and allowed by browsers to mean that the nested list is
// actually part of the list item above it.
function normalizeList(dom) {
  for (var child = dom.firstChild, prevItem = null; child; child = child.nextSibling) {
    var name = child.nodeType == 1 ? child.nodeName.toLowerCase() : null;
    if (name && listTags.hasOwnProperty(name) && prevItem) {
      prevItem.appendChild(child);
      child = prevItem;
    } else if (name == "li") {
      prevItem = child;
    } else if (name) {
      prevItem = null;
    }
  }
}

// Apply a CSS selector.
function matches(dom, selector) {
  return (dom.matches || dom.msMatchesSelector || dom.webkitMatchesSelector || dom.mozMatchesSelector).call(dom, selector);
}

// : (string) → [string]
// Tokenize a style attribute into property/value pairs.
function parseStyles(style) {
  var re = /\s*([\w-]+)\s*:\s*([^;]+)/g,
      m,
      result = [];
  while (m = re.exec(style)) {
    result.push(m[1], m[2].trim());
  }
  return result;
}

function copy(obj) {
  var copy = {};
  for (var prop in obj) {
    copy[prop] = obj[prop];
  }
  return copy;
}

},{"./fragment":5,"./mark":8,"./replace":10}],7:[function(require,module,exports){
exports.Node = require("./node").Node;var assign;
assign = require("./resolvedpos"), exports.ResolvedPos = assign.ResolvedPos, exports.NodeRange = assign.NodeRange;
exports.Fragment = require("./fragment").Fragment;var assign$1;
assign$1 = require("./replace"), exports.Slice = assign$1.Slice, exports.ReplaceError = assign$1.ReplaceError;
exports.Mark = require("./mark").Mark;var assign$2;
assign$2 = require("./schema"), exports.Schema = assign$2.Schema, exports.NodeType = assign$2.NodeType, exports.MarkType = assign$2.MarkType;var assign$3;
assign$3 = require("./content"), exports.ContentMatch = assign$3.ContentMatch;

exports.DOMParser = require("./from_dom").DOMParser;
exports.DOMSerializer = require("./to_dom").DOMSerializer;

},{"./content":3,"./fragment":5,"./from_dom":6,"./mark":8,"./node":9,"./replace":10,"./resolvedpos":11,"./schema":12,"./to_dom":13}],8:[function(require,module,exports){
var ref = require("./comparedeep");
var compareDeep = ref.compareDeep;

// ::- A mark is a piece of information that can be attached to a node,
// such as it being emphasized, in code font, or a link. It has a type
// and optionally a set of attributes that provide further information
// (such as the target of the link). Marks are created through a
// `Schema`, which controls which types exist and which
// attributes they have.
var Mark = function (type, attrs) {
  // :: MarkType
  // The type of this mark.
  this.type = type;
  // :: Object
  // The attributes associated with this mark.
  this.attrs = attrs;
};

// :: ([Mark]) → [Mark]
// Given a set of marks, create a new set which contains this one as
// well, in the right position. If this mark is already in the set,
// the set itself is returned. If a mark of this type with different
// attributes is already in the set, a set in which it is replaced
// by this one is returned.
Mark.prototype.addToSet = function (set) {
  var this$1 = this;

  var copy,
      placed = false;
  for (var i = 0; i < set.length; i++) {
    var other = set[i];
    if (this$1.eq(other)) {
      return set;
    }
    if (this$1.type.excludes(other.type)) {
      if (!copy) {
        copy = set.slice(0, i);
      }
    } else if (other.type.excludes(this$1.type)) {
      return set;
    } else {
      if (!placed && other.type.rank > this$1.type.rank) {
        if (!copy) {
          copy = set.slice(0, i);
        }
        copy.push(this$1);
        placed = true;
      }
      if (copy) {
        copy.push(other);
      }
    }
  }
  if (!copy) {
    copy = set.slice();
  }
  if (!placed) {
    copy.push(this);
  }
  return copy;
};

// :: ([Mark]) → [Mark]
// Remove this mark from the given set, returning a new set. If this
// mark is not in the set, the set itself is returned.
Mark.prototype.removeFromSet = function (set) {
  var this$1 = this;

  for (var i = 0; i < set.length; i++) {
    if (this$1.eq(set[i])) {
      return set.slice(0, i).concat(set.slice(i + 1));
    }
  }
  return set;
};

// :: ([Mark]) → bool
// Test whether this mark is in the given set of marks.
Mark.prototype.isInSet = function (set) {
  var this$1 = this;

  for (var i = 0; i < set.length; i++) {
    if (this$1.eq(set[i])) {
      return true;
    }
  }
  return false;
};

// :: (Mark) → bool
// Test whether this mark has the same type and attributes as
// another mark.
Mark.prototype.eq = function (other) {
  return this == other || this.type == other.type && compareDeep(this.attrs, other.attrs);
};

// :: () → Object
// Convert this mark to a JSON-serializeable representation.
Mark.prototype.toJSON = function () {
  var this$1 = this;

  var obj = { type: this.type.name };
  for (var _ in this$1.attrs) {
    obj.attrs = this$1.attrs;
    break;
  }
  return obj;
};

// :: (Schema, Object) → Mark
Mark.fromJSON = function (schema, json) {
  var type = schema.marks[json.type];
  if (!type) {
    throw new RangeError("There is no mark type " + json.type + " in this schema");
  }
  return type.create(json.attrs);
};

// :: ([Mark], [Mark]) → bool
// Test whether two sets of marks are identical.
Mark.sameSet = function (a, b) {
  if (a == b) {
    return true;
  }
  if (a.length != b.length) {
    return false;
  }
  for (var i = 0; i < a.length; i++) {
    if (!a[i].eq(b[i])) {
      return false;
    }
  }
  return true;
};

// :: (?union<Mark, [Mark]>) → [Mark]
// Create a properly sorted mark set from null, a single mark, or an
// unsorted array of marks.
Mark.setFrom = function (marks) {
  if (!marks || marks.length == 0) {
    return Mark.none;
  }
  if (marks instanceof Mark) {
    return [marks];
  }
  var copy = marks.slice();
  copy.sort(function (a, b) {
    return a.type.rank - b.type.rank;
  });
  return copy;
};
exports.Mark = Mark;

// :: [Mark] The empty set of marks.
Mark.none = [];

},{"./comparedeep":2}],9:[function(require,module,exports){
var ref = require("./fragment");
var Fragment = ref.Fragment;
var ref$1 = require("./mark");
var Mark = ref$1.Mark;
var ref$2 = require("./replace");
var Slice = ref$2.Slice;
var replace = ref$2.replace;
var ref$3 = require("./resolvedpos");
var ResolvedPos = ref$3.ResolvedPos;
var ref$4 = require("./comparedeep");
var compareDeep = ref$4.compareDeep;

var emptyAttrs = Object.create(null);

// ::- This class represents a node in the tree that makes up a
// ProseMirror document. So a document is an instance of `Node`, with
// children that are also instances of `Node`.
//
// Nodes are persistent data structures. Instead of changing them, you
// create new ones with the content you want. Old ones keep pointing
// at the old document shape. This is made cheaper by sharing
// structure between the old and new data as much as possible, which a
// tree shape like this (without back pointers) makes easy.
//
// **Never** directly mutate the properties of a `Node` object. See
// [this guide](/docs/guides/doc/) for more information.
var Node = function (type, attrs, content, marks) {
  // :: NodeType
  // The type of node that this is.
  this.type = type;

  // :: Object
  // An object mapping attribute names to values. The kind of
  // attributes allowed and required are determined by the node
  // type.
  this.attrs = attrs;

  // :: Fragment
  // A container holding the node's children.
  this.content = content || Fragment.empty;

  // :: [Mark]
  // The marks (things like whether it is emphasized or part of a
  // link) associated with this node.
  this.marks = marks || Mark.none;
};

var prototypeAccessors = { nodeSize: {}, childCount: {}, textContent: {}, firstChild: {}, lastChild: {}, isBlock: {}, isTextblock: {}, inlineContent: {}, isInline: {}, isText: {}, isLeaf: {}, isAtom: {} };

// text:: ?string
// For text nodes, this contains the node's text content.

// :: number
// The size of this node, as defined by the integer-based [indexing
// scheme](/docs/guides/doc/#indexing). For text nodes, this is the
// amount of characters. For other leaf nodes, it is one. And for
// non-leaf nodes, it is the size of the content plus two (the start
// and end token).
prototypeAccessors.nodeSize.get = function () {
  return this.isLeaf ? 1 : 2 + this.content.size;
};

// :: number
// The number of children that the node has.
prototypeAccessors.childCount.get = function () {
  return this.content.childCount;
};

// :: (number) → Node
// Get the child node at the given index. Raises an error when the
// index is out of range.
Node.prototype.child = function (index) {
  return this.content.child(index);
};

// :: (number) → ?Node
// Get the child node at the given index, if it exists.
Node.prototype.maybeChild = function (index) {
  return this.content.maybeChild(index);
};

// :: ((node: Node, offset: number, index: number))
// Call `f` for every child node, passing the node, its offset
// into this parent node, and its index.
Node.prototype.forEach = function (f) {
  this.content.forEach(f);
};

// :: (number, number, (node: Node, pos: number, parent: Node, index: number) → ?bool)
// Invoke a callback for all descendant nodes recursively between
// the given two positions that are relative to start of this node's content.
// The callback is invoked with the node, its parent-relative position,
// its parent node, and its child index. If the callback returns false,
// the current node's children will not be recursed over.
Node.prototype.nodesBetween = function (from, to, f, pos) {
  if (pos === void 0) pos = 0;

  this.content.nodesBetween(from, to, f, pos, this);
};

// :: ((node: Node, pos: number, parent: Node) → ?bool)
// Call the given callback for every descendant node. If doesn't
// descend into a child node when the callback returns `false`.
Node.prototype.descendants = function (f) {
  this.nodesBetween(0, this.content.size, f);
};

// :: string
// Concatenates all the text nodes found in this fragment and its
// children.
prototypeAccessors.textContent.get = function () {
  return this.textBetween(0, this.content.size, "");
};

// :: (number, number, ?string, ?string) → string
// Get all text between positions `from` and `to`. When
// `blockSeparator` is given, it will be inserted whenever a new
// block node is started. When `leafText` is given, it'll be
// inserted for every non-text leaf node encountered.
Node.prototype.textBetween = function (from, to, blockSeparator, leafText) {
  return this.content.textBetween(from, to, blockSeparator, leafText);
};

// :: ?Node
// Returns this node's first child, or `null` if there are no
// children.
prototypeAccessors.firstChild.get = function () {
  return this.content.firstChild;
};

// :: ?Node
// Returns this node's last child, or `null` if there are no
// children.
prototypeAccessors.lastChild.get = function () {
  return this.content.lastChild;
};

// :: (Node) → bool
// Test whether two nodes represent the same content.
Node.prototype.eq = function (other) {
  return this == other || this.sameMarkup(other) && this.content.eq(other.content);
};

// :: (Node) → bool
// Compare the markup (type, attributes, and marks) of this node to
// those of another. Returns `true` if both have the same markup.
Node.prototype.sameMarkup = function (other) {
  return this.hasMarkup(other.type, other.attrs, other.marks);
};

// :: (NodeType, ?Object, ?[Mark]) → bool
// Check whether this node's markup correspond to the given type,
// attributes, and marks.
Node.prototype.hasMarkup = function (type, attrs, marks) {
  return this.type == type && compareDeep(this.attrs, attrs || type.defaultAttrs || emptyAttrs) && Mark.sameSet(this.marks, marks || Mark.none);
};

// :: (?Fragment) → Node
// Create a new node with the same markup as this node, containing
// the given content (or empty, if no content is given).
Node.prototype.copy = function (content) {
  if (content === void 0) content = null;

  if (content == this.content) {
    return this;
  }
  return new this.constructor(this.type, this.attrs, content, this.marks);
};

// :: ([Mark]) → Node
// Create a copy of this node, with the given set of marks instead
// of the node's own marks.
Node.prototype.mark = function (marks) {
  return marks == this.marks ? this : new this.constructor(this.type, this.attrs, this.content, marks);
};

// :: (number, ?number) → Node
// Create a copy of this node with only the content between the
// given offsets. If `to` is not given, it defaults to the end of
// the node.
Node.prototype.cut = function (from, to) {
  if (from == 0 && to == this.content.size) {
    return this;
  }
  return this.copy(this.content.cut(from, to));
};

// :: (number, ?number) → Slice
// Cut out the part of the document between the given positions, and
// return it as a `Slice` object.
Node.prototype.slice = function (from, to, includeParents) {
  if (to === void 0) to = this.content.size;
  if (includeParents === void 0) includeParents = false;

  if (from == to) {
    return Slice.empty;
  }

  var $from = this.resolve(from),
      $to = this.resolve(to);
  var depth = includeParents ? 0 : $from.sharedDepth(to);
  var start = $from.start(depth),
      node = $from.node(depth);
  var content = node.content.cut($from.pos - start, $to.pos - start);
  return new Slice(content, $from.depth - depth, $to.depth - depth);
};

// :: (number, number, Slice) → Node
// Replace the part of the document between the given positions with
// the given slice. The slice must 'fit', meaning its open sides
// must be able to connect to the surrounding content, and its
// content nodes must be valid children for the node they are placed
// into. If any of this is violated, an error of type
// [`ReplaceError`](#model.ReplaceError) is thrown.
Node.prototype.replace = function (from, to, slice) {
  return replace(this.resolve(from), this.resolve(to), slice);
};

// :: (number) → ?Node
// Find the node after the given position.
Node.prototype.nodeAt = function (pos) {
  for (var node = this;;) {
    var ref = node.content.findIndex(pos);
    var index = ref.index;
    var offset = ref.offset;
    node = node.maybeChild(index);
    if (!node) {
      return null;
    }
    if (offset == pos || node.isText) {
      return node;
    }
    pos -= offset + 1;
  }
};

// :: (number) → {node: ?Node, index: number, offset: number}
// Find the (direct) child node after the given offset, if any,
// and return it along with its index and offset relative to this
// node.
Node.prototype.childAfter = function (pos) {
  var ref = this.content.findIndex(pos);
  var index = ref.index;
  var offset = ref.offset;
  return { node: this.content.maybeChild(index), index: index, offset: offset };
};

// :: (number) → {node: ?Node, index: number, offset: number}
// Find the (direct) child node before the given offset, if any,
// and return it along with its index and offset relative to this
// node.
Node.prototype.childBefore = function (pos) {
  if (pos == 0) {
    return { node: null, index: 0, offset: 0 };
  }
  var ref = this.content.findIndex(pos);
  var index = ref.index;
  var offset = ref.offset;
  if (offset < pos) {
    return { node: this.content.child(index), index: index, offset: offset };
  }
  var node = this.content.child(index - 1);
  return { node: node, index: index - 1, offset: offset - node.nodeSize };
};

// :: (number) → ResolvedPos
// Resolve the given position in the document, returning an object
// describing its path through the document.
Node.prototype.resolve = function (pos) {
  return ResolvedPos.resolveCached(this, pos);
};

Node.prototype.resolveNoCache = function (pos) {
  return ResolvedPos.resolve(this, pos);
};

// :: (number, number, MarkType) → bool
// Test whether a mark of the given type occurs in this document
// between the two given positions.
Node.prototype.rangeHasMark = function (from, to, type) {
  var found = false;
  this.nodesBetween(from, to, function (node) {
    if (type.isInSet(node.marks)) {
      found = true;
    }
    return !found;
  });
  return found;
};

// :: bool
// True when this is a block (non-inline node)
prototypeAccessors.isBlock.get = function () {
  return this.type.isBlock;
};

// :: bool
// True when this is a textblock node, a block node with inline
// content.
prototypeAccessors.isTextblock.get = function () {
  return this.type.isTextblock;
};

// :: bool
// True when this node has inline content.
prototypeAccessors.inlineContent.get = function () {
  return this.type.inlineContent;
};

// :: bool
// True when this is an inline node (a text node or a node that can
// appear among text).
prototypeAccessors.isInline.get = function () {
  return this.type.isInline;
};

// :: bool
// True when this is a text node.
prototypeAccessors.isText.get = function () {
  return this.type.isText;
};

// :: bool
// True when this is a leaf node.
prototypeAccessors.isLeaf.get = function () {
  return this.type.isLeaf;
};

// :: bool
// True when this is an atom, i.e. when it does not have directly
// editable content. This is usually the same as `isLeaf`, but can
// be configured with the [`leaf` property](#model.NodeSpec.leaf) on
// a node's spec (typically when the node is displayed as an
// uneditable [node view](#view.NodeView)).
prototypeAccessors.isAtom.get = function () {
  return this.type.isAtom;
};

// :: () → string
// Return a string representation of this node for debugging
// purposes.
Node.prototype.toString = function () {
  var name = this.type.name;
  if (this.content.size) {
    name += "(" + this.content.toStringInner() + ")";
  }
  return wrapMarks(this.marks, name);
};

// :: (number) → ContentMatch
// Get the content match in this node at the given index.
Node.prototype.contentMatchAt = function (index) {
  return this.type.contentExpr.getMatchAt(this.attrs, this.content, index);
};

// :: (number, number, ?Fragment, ?number, ?number) → bool
// Test whether replacing the range `from` to `to` (by index) with
// the given replacement fragment (which defaults to the empty
// fragment) would leave the node's content valid. You can
// optionally pass `start` and `end` indices into the replacement
// fragment.
Node.prototype.canReplace = function (from, to, replacement, start, end) {
  return this.type.contentExpr.checkReplace(this.attrs, this.content, from, to, replacement, start, end);
};

// :: (number, number, NodeType, ?[Mark]) → bool
// Test whether replacing the range `from` to `to` (by index) with a
// node of the given type with the given attributes and marks would
// be valid.
Node.prototype.canReplaceWith = function (from, to, type, attrs, marks) {
  return this.type.contentExpr.checkReplaceWith(this.attrs, this.content, from, to, type, attrs, marks || Mark.none);
};

// :: (Node) → bool
// Test whether the given node's content could be appended to this
// node. If that node is empty, this will only return true if there
// is at least one node type that can appear in both nodes (to avoid
// merging completely incompatible nodes).
Node.prototype.canAppend = function (other) {
  if (other.content.size) {
    return this.canReplace(this.childCount, this.childCount, other.content);
  } else {
    return this.type.compatibleContent(other.type);
  }
};

Node.prototype.defaultContentType = function (at) {
  var elt = this.contentMatchAt(at).nextElement;
  return elt && elt.defaultType();
};

// :: ()
// Check whether this node and its descendants conform to the
// schema, and raise error when they do not.
Node.prototype.check = function () {
  if (!this.type.validContent(this.content, this.attrs)) {
    throw new RangeError("Invalid content for node " + this.type.name + ": " + this.content.toString().slice(0, 50));
  }
  this.content.forEach(function (node) {
    return node.check();
  });
};

// :: () → Object
// Return a JSON-serializeable representation of this node.
Node.prototype.toJSON = function () {
  var this$1 = this;

  var obj = { type: this.type.name };
  for (var _ in this$1.attrs) {
    obj.attrs = this$1.attrs;
    break;
  }
  if (this.content.size) {
    obj.content = this.content.toJSON();
  }
  if (this.marks.length) {
    obj.marks = this.marks.map(function (n) {
      return n.toJSON();
    });
  }
  return obj;
};

// :: (Schema, Object) → Node
// Deserialize a node from its JSON representation.
Node.fromJSON = function (schema, json) {
  var marks = json.marks && json.marks.map(schema.markFromJSON);
  if (json.type == "text") {
    return schema.text(json.text, marks);
  }
  var type = schema.nodeType(json.type);
  if (!type) {
    throw new RangeError("There is no node type " + json.type + " in this schema");
  }
  return type.create(json.attrs, Fragment.fromJSON(schema, json.content), marks);
};

Object.defineProperties(Node.prototype, prototypeAccessors);
exports.Node = Node;

var TextNode = function (Node) {
  function TextNode(type, attrs, content, marks) {
    Node.call(this, type, attrs, null, marks);

    if (!content) {
      throw new RangeError("Empty text nodes are not allowed");
    }

    this.text = content;
  }

  if (Node) TextNode.__proto__ = Node;
  TextNode.prototype = Object.create(Node && Node.prototype);
  TextNode.prototype.constructor = TextNode;

  var prototypeAccessors$1 = { textContent: {}, nodeSize: {} };

  TextNode.prototype.toString = function () {
    return wrapMarks(this.marks, JSON.stringify(this.text));
  };

  prototypeAccessors$1.textContent.get = function () {
    return this.text;
  };

  TextNode.prototype.textBetween = function (from, to) {
    return this.text.slice(from, to);
  };

  prototypeAccessors$1.nodeSize.get = function () {
    return this.text.length;
  };

  TextNode.prototype.mark = function (marks) {
    return new TextNode(this.type, this.attrs, this.text, marks);
  };

  TextNode.prototype.withText = function (text) {
    if (text == this.text) {
      return this;
    }
    return new TextNode(this.type, this.attrs, text, this.marks);
  };

  TextNode.prototype.cut = function (from, to) {
    if (from === void 0) from = 0;
    if (to === void 0) to = this.text.length;

    if (from == 0 && to == this.text.length) {
      return this;
    }
    return this.withText(this.text.slice(from, to));
  };

  TextNode.prototype.eq = function (other) {
    return this.sameMarkup(other) && this.text == other.text;
  };

  TextNode.prototype.toJSON = function () {
    var base = Node.prototype.toJSON.call(this);
    base.text = this.text;
    return base;
  };

  Object.defineProperties(TextNode.prototype, prototypeAccessors$1);

  return TextNode;
}(Node);
exports.TextNode = TextNode;

function wrapMarks(marks, str) {
  for (var i = marks.length - 1; i >= 0; i--) {
    str = marks[i].type.name + "(" + str + ")";
  }
  return str;
}

},{"./comparedeep":2,"./fragment":5,"./mark":8,"./replace":10,"./resolvedpos":11}],10:[function(require,module,exports){
var ref = require("./fragment");
var Fragment = ref.Fragment;

// ::- Error type raised by [`Node.replace`](#model.Node.replace) when
// given an invalid replacement.
var ReplaceError = function (Error) {
  function ReplaceError(message) {
    Error.call(this, message);
    this.message = message;
  }

  if (Error) ReplaceError.__proto__ = Error;
  ReplaceError.prototype = Object.create(Error && Error.prototype);
  ReplaceError.prototype.constructor = ReplaceError;

  var prototypeAccessors = { name: {} };
  prototypeAccessors.name.get = function () {
    return "ReplaceError";
  };

  Object.defineProperties(ReplaceError.prototype, prototypeAccessors);

  return ReplaceError;
}(Error);
exports.ReplaceError = ReplaceError;

// ::- A slice represents a piece cut out of a larger document. It
// stores not only a fragment, but also the depth up to which nodes on
// both side are 'open' / cut through.
var Slice = function (content, openStart, openEnd) {
  // :: Fragment The slice's content nodes.
  this.content = content;
  // :: number The open depth at the start.
  this.openStart = openStart;
  // :: number The open depth at the end.
  this.openEnd = openEnd;
};

var prototypeAccessors$1 = { size: {} };

// :: number
// The size this slice would add when inserted into a document.
prototypeAccessors$1.size.get = function () {
  return this.content.size - this.openStart - this.openEnd;
};

Slice.prototype.insertAt = function (pos, fragment) {
  var content = insertInto(this.content, pos + this.openStart, fragment, null);
  return content && new Slice(content, this.openStart, this.openEnd);
};

Slice.prototype.removeBetween = function (from, to) {
  return new Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
};

// :: (Slice) → bool
// Tests whether this slice is equal to another slice.
Slice.prototype.eq = function (other) {
  return this.content.eq(other.content) && this.openStart == other.openStart && this.openEnd == other.openEnd;
};

Slice.prototype.toString = function () {
  return this.content + "(" + this.openStart + "," + this.openEnd + ")";
};

// :: () → ?Object
// Convert a slice to a JSON-serializable representation.
Slice.prototype.toJSON = function () {
  if (!this.content.size) {
    return null;
  }
  var json = { content: this.content.toJSON() };
  if (this.openStart > 0) {
    json.openStart = this.openStart;
  }
  if (this.openEnd > 0) {
    json.openEnd = this.openEnd;
  }
  return json;
};

// :: (Schema, ?Object) → Slice
// Deserialize a slice from its JSON representation.
Slice.fromJSON = function (schema, json) {
  if (!json) {
    return Slice.empty;
  }
  return new Slice(Fragment.fromJSON(schema, json.content), json.openStart || 0, json.openEnd || 0);
};

// :: (Fragment) → Slice
// Create a slice from a fragment by taking the maximum possible
// open value on both side of the fragment.
Slice.maxOpen = function (fragment) {
  var openStart = 0,
      openEnd = 0;
  for (var n = fragment.firstChild; n && !n.isLeaf; n = n.firstChild) {
    openStart++;
  }
  for (var n$1 = fragment.lastChild; n$1 && !n$1.isLeaf; n$1 = n$1.lastChild) {
    openEnd++;
  }
  return new Slice(fragment, openStart, openEnd);
};

Object.defineProperties(Slice.prototype, prototypeAccessors$1);
exports.Slice = Slice;

function removeRange(content, from, to) {
  var ref = content.findIndex(from);
  var index = ref.index;
  var offset = ref.offset;
  var child = content.maybeChild(index);
  var ref$1 = content.findIndex(to);
  var indexTo = ref$1.index;
  var offsetTo = ref$1.offset;
  if (offset == from || child.isText) {
    if (offsetTo != to && !content.child(indexTo).isText) {
      throw new RangeError("Removing non-flat range");
    }
    return content.cut(0, from).append(content.cut(to));
  }
  if (index != indexTo) {
    throw new RangeError("Removing non-flat range");
  }
  return content.replaceChild(index, child.copy(removeRange(child.content, from - offset - 1, to - offset - 1)));
}

function insertInto(content, dist, insert, parent) {
  var ref = content.findIndex(dist);
  var index = ref.index;
  var offset = ref.offset;
  var child = content.maybeChild(index);
  if (offset == dist || child.isText) {
    if (parent && !parent.canReplace(index, index, insert)) {
      return null;
    }
    return content.cut(0, dist).append(insert).append(content.cut(dist));
  }
  var inner = insertInto(child.content, dist - offset - 1, insert);
  return inner && content.replaceChild(index, child.copy(inner));
}

// :: Slice
// The empty slice.
Slice.empty = new Slice(Fragment.empty, 0, 0);

function replace($from, $to, slice) {
  if (slice.openStart > $from.depth) {
    throw new ReplaceError("Inserted content deeper than insertion position");
  }
  if ($from.depth - slice.openStart != $to.depth - slice.openEnd) {
    throw new ReplaceError("Inconsistent open depths");
  }
  return replaceOuter($from, $to, slice, 0);
}
exports.replace = replace;

function replaceOuter($from, $to, slice, depth) {
  var index = $from.index(depth),
      node = $from.node(depth);
  if (index == $to.index(depth) && depth < $from.depth - slice.openStart) {
    var inner = replaceOuter($from, $to, slice, depth + 1);
    return node.copy(node.content.replaceChild(index, inner));
  } else if (!slice.content.size) {
    return close(node, replaceTwoWay($from, $to, depth));
  } else if (!slice.openStart && !slice.openEnd && $from.depth == depth && $to.depth == depth) {
    // Simple, flat case
    var parent = $from.parent,
        content = parent.content;
    return close(parent, content.cut(0, $from.parentOffset).append(slice.content).append(content.cut($to.parentOffset)));
  } else {
    var ref = prepareSliceForReplace(slice, $from);
    var start = ref.start;
    var end = ref.end;
    return close(node, replaceThreeWay($from, start, end, $to, depth));
  }
}

function checkJoin(main, sub) {
  if (!sub.type.compatibleContent(main.type)) {
    throw new ReplaceError("Cannot join " + sub.type.name + " onto " + main.type.name);
  }
}

function joinable($before, $after, depth) {
  var node = $before.node(depth);
  checkJoin(node, $after.node(depth));
  return node;
}

function addNode(child, target) {
  var last = target.length - 1;
  if (last >= 0 && child.isText && child.sameMarkup(target[last])) {
    target[last] = child.withText(target[last].text + child.text);
  } else {
    target.push(child);
  }
}

function addRange($start, $end, depth, target) {
  var node = ($end || $start).node(depth);
  var startIndex = 0,
      endIndex = $end ? $end.index(depth) : node.childCount;
  if ($start) {
    startIndex = $start.index(depth);
    if ($start.depth > depth) {
      startIndex++;
    } else if ($start.textOffset) {
      addNode($start.nodeAfter, target);
      startIndex++;
    }
  }
  for (var i = startIndex; i < endIndex; i++) {
    addNode(node.child(i), target);
  }
  if ($end && $end.depth == depth && $end.textOffset) {
    addNode($end.nodeBefore, target);
  }
}

function close(node, content) {
  if (!node.type.validContent(content, node.attrs)) {
    throw new ReplaceError("Invalid content for node " + node.type.name);
  }
  return node.copy(content);
}

function replaceThreeWay($from, $start, $end, $to, depth) {
  var openStart = $from.depth > depth && joinable($from, $start, depth + 1);
  var openEnd = $to.depth > depth && joinable($end, $to, depth + 1);

  var content = [];
  addRange(null, $from, depth, content);
  if (openStart && openEnd && $start.index(depth) == $end.index(depth)) {
    checkJoin(openStart, openEnd);
    addNode(close(openStart, replaceThreeWay($from, $start, $end, $to, depth + 1)), content);
  } else {
    if (openStart) {
      addNode(close(openStart, replaceTwoWay($from, $start, depth + 1)), content);
    }
    addRange($start, $end, depth, content);
    if (openEnd) {
      addNode(close(openEnd, replaceTwoWay($end, $to, depth + 1)), content);
    }
  }
  addRange($to, null, depth, content);
  return new Fragment(content);
}

function replaceTwoWay($from, $to, depth) {
  var content = [];
  addRange(null, $from, depth, content);
  if ($from.depth > depth) {
    var type = joinable($from, $to, depth + 1);
    addNode(close(type, replaceTwoWay($from, $to, depth + 1)), content);
  }
  addRange($to, null, depth, content);
  return new Fragment(content);
}

function prepareSliceForReplace(slice, $along) {
  var extra = $along.depth - slice.openStart,
      parent = $along.node(extra);
  var node = parent.copy(slice.content);
  for (var i = extra - 1; i >= 0; i--) {
    node = $along.node(i).copy(Fragment.from(node));
  }
  return { start: node.resolveNoCache(slice.openStart + extra),
    end: node.resolveNoCache(node.content.size - slice.openEnd - extra) };
}

},{"./fragment":5}],11:[function(require,module,exports){
var ref = require("./mark");
var Mark = ref.Mark;

// ::- You'll often have to '[resolve](#model.Node.resolve)' a
// position to get the context you need. Objects of this class
// represent such a resolved position, providing various pieces of
// context information and helper methods.
//
// Throughout this interface, methods that take an optional `depth`
// parameter will interpret undefined as `this.depth` and negative
// numbers as `this.depth + value`.
var ResolvedPos = function (pos, path, parentOffset) {
  // :: number The position that was resolved.
  this.pos = pos;
  this.path = path;
  // :: number
  // The number of levels the parent node is from the root. If this
  // position points directly into the root, it is 0. If it points
  // into a top-level paragraph, 1, and so on.
  this.depth = path.length / 3 - 1;
  // :: number The offset this position has into its parent node.
  this.parentOffset = parentOffset;
};

var prototypeAccessors = { parent: {}, doc: {}, textOffset: {}, nodeAfter: {}, nodeBefore: {} };

ResolvedPos.prototype.resolveDepth = function (val) {
  if (val == null) {
    return this.depth;
  }
  if (val < 0) {
    return this.depth + val;
  }
  return val;
};

// :: Node
// The parent node that the position points into. Note that even if
// a position points into a text node, that node is not considered
// the parent—text nodes are 'flat' in this model.
prototypeAccessors.parent.get = function () {
  return this.node(this.depth);
};

// :: Node
// The root node in which the position was resolved.
prototypeAccessors.doc.get = function () {
  return this.node(0);
};

// :: (?number) → Node
// The ancestor node at the given level. `p.node(p.depth)` is the
// same as `p.parent`.
ResolvedPos.prototype.node = function (depth) {
  return this.path[this.resolveDepth(depth) * 3];
};

// :: (?number) → number
// The index into the ancestor at the given level. If this points at
// the 3rd node in the 2nd paragraph on the top level, for example,
// `p.index(0)` is 2 and `p.index(1)` is 3.
ResolvedPos.prototype.index = function (depth) {
  return this.path[this.resolveDepth(depth) * 3 + 1];
};

// :: (?number) → number
// The index pointing after this position into the ancestor at the
// given level.
ResolvedPos.prototype.indexAfter = function (depth) {
  depth = this.resolveDepth(depth);
  return this.index(depth) + (depth == this.depth && !this.textOffset ? 0 : 1);
};

// :: (?number) → number
// The (absolute) position at the start of the node at the given
// level.
ResolvedPos.prototype.start = function (depth) {
  depth = this.resolveDepth(depth);
  return depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
};

// :: (?number) → number
// The (absolute) position at the end of the node at the given
// level.
ResolvedPos.prototype.end = function (depth) {
  depth = this.resolveDepth(depth);
  return this.start(depth) + this.node(depth).content.size;
};

// :: (?number) → number
// The (absolute) position directly before the node at the given
// level, or, when `level` is `this.depth + 1`, the original
// position.
ResolvedPos.prototype.before = function (depth) {
  depth = this.resolveDepth(depth);
  if (!depth) {
    throw new RangeError("There is no position before the top-level node");
  }
  return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1];
};

// :: (?number) → number
// The (absolute) position directly after the node at the given
// level, or, when `level` is `this.depth + 1`, the original
// position.
ResolvedPos.prototype.after = function (depth) {
  depth = this.resolveDepth(depth);
  if (!depth) {
    throw new RangeError("There is no position after the top-level node");
  }
  return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1] + this.path[depth * 3].nodeSize;
};

// :: number
// When this position points into a text node, this returns the
// distance between the position and the start of the text node.
// Will be zero for positions that point between nodes.
prototypeAccessors.textOffset.get = function () {
  return this.pos - this.path[this.path.length - 1];
};

// :: ?Node
// Get the node directly after the position, if any. If the position
// points into a text node, only the part of that node after the
// position is returned.
prototypeAccessors.nodeAfter.get = function () {
  var parent = this.parent,
      index = this.index(this.depth);
  if (index == parent.childCount) {
    return null;
  }
  var dOff = this.pos - this.path[this.path.length - 1],
      child = parent.child(index);
  return dOff ? parent.child(index).cut(dOff) : child;
};

// :: ?Node
// Get the node directly before the position, if any. If the
// position points into a text node, only the part of that node
// before the position is returned.
prototypeAccessors.nodeBefore.get = function () {
  var index = this.index(this.depth);
  var dOff = this.pos - this.path[this.path.length - 1];
  if (dOff) {
    return this.parent.child(index).cut(0, dOff);
  }
  return index == 0 ? null : this.parent.child(index - 1);
};

// :: (?bool) → [Mark]
// Get the marks at this position, factoring in the surrounding
// marks' [`inclusive`](#model.MarkSpec.inclusive) property. If the
// position is at the start of a non-empty node, or `after` is true,
// the marks of the node after it (if any) are returned.
ResolvedPos.prototype.marks = function (after) {
  var parent = this.parent,
      index = this.index();

  // In an empty parent, return the empty array
  if (parent.content.size == 0) {
    return Mark.none;
  }

  // When inside a text node, just return the text node's marks
  if (this.textOffset) {
    return parent.child(index).marks;
  }

  var main = parent.maybeChild(index - 1),
      other = parent.maybeChild(index);
  // If the `after` flag is true of there is no node before, make
  // the node after this position the main reference.
  if (after && other || !main) {
    var tmp = main;main = other;other = tmp;
  }

  // Use all marks in the main node, except those that have
  // `inclusive` set to false and are not present in the other node.
  var marks = main.marks;
  for (var i = 0; i < marks.length; i++) {
    if (marks[i].type.spec.inclusive === false && (!other || !marks[i].isInSet(other.marks))) {
      marks = marks[i--].removeFromSet(marks);
    }
  }

  return marks;
};

// :: (number) → number
// The depth up to which this position and the given (non-resolved)
// position share the same parent nodes.
ResolvedPos.prototype.sharedDepth = function (pos) {
  var this$1 = this;

  for (var depth = this.depth; depth > 0; depth--) {
    if (this$1.start(depth) <= pos && this$1.end(depth) >= pos) {
      return depth;
    }
  }
  return 0;
};

// :: (?ResolvedPos, ?(Node) → bool) → ?NodeRange
// Returns a range based on the place where this position and the
// given position diverge around block content. If both point into
// the same textblock, for example, a range around that textblock
// will be returned. If they point into different blocks, the range
// around those blocks or their ancestors in their common ancestor
// is returned. You can pass in an optional predicate that will be
// called with a parent node to see if a range into that parent is
// acceptable.
ResolvedPos.prototype.blockRange = function (other, pred) {
  var this$1 = this;
  if (other === void 0) other = this;

  if (other.pos < this.pos) {
    return other.blockRange(this);
  }
  for (var d = this.depth - (this.parent.inlineContent || this.pos == other.pos ? 1 : 0); d >= 0; d--) {
    if (other.pos <= this$1.end(d) && (!pred || pred(this$1.node(d)))) {
      return new NodeRange(this$1, other, d);
    }
  }
};

// :: (ResolvedPos) → bool
// Query whether the given position shares the same parent node.
ResolvedPos.prototype.sameParent = function (other) {
  return this.pos - this.parentOffset == other.pos - other.parentOffset;
};

// :: (ResolvedPos) → ResolvedPos
// Return the greater of this and the given position.
ResolvedPos.prototype.max = function (other) {
  return other.pos > this.pos ? other : this;
};

// :: (ResolvedPos) → ResolvedPos
// Return the smaller of this and the given position.
ResolvedPos.prototype.min = function (other) {
  return other.pos < this.pos ? other : this;
};

ResolvedPos.prototype.toString = function () {
  var this$1 = this;

  var str = "";
  for (var i = 1; i <= this.depth; i++) {
    str += (str ? "/" : "") + this$1.node(i).type.name + "_" + this$1.index(i - 1);
  }
  return str + ":" + this.parentOffset;
};

ResolvedPos.resolve = function (doc, pos) {
  if (!(pos >= 0 && pos <= doc.content.size)) {
    throw new RangeError("Position " + pos + " out of range");
  }
  var path = [];
  var start = 0,
      parentOffset = pos;
  for (var node = doc;;) {
    var ref = node.content.findIndex(parentOffset);
    var index = ref.index;
    var offset = ref.offset;
    var rem = parentOffset - offset;
    path.push(node, index, start + offset);
    if (!rem) {
      break;
    }
    node = node.child(index);
    if (node.isText) {
      break;
    }
    parentOffset = rem - 1;
    start += offset + 1;
  }
  return new ResolvedPos(pos, path, parentOffset);
};

ResolvedPos.resolveCached = function (doc, pos) {
  for (var i = 0; i < resolveCache.length; i++) {
    var cached = resolveCache[i];
    if (cached.pos == pos && cached.node(0) == doc) {
      return cached;
    }
  }
  var result = resolveCache[resolveCachePos] = ResolvedPos.resolve(doc, pos);
  resolveCachePos = (resolveCachePos + 1) % resolveCacheSize;
  return result;
};

Object.defineProperties(ResolvedPos.prototype, prototypeAccessors);
exports.ResolvedPos = ResolvedPos;

var resolveCache = [],
    resolveCachePos = 0,
    resolveCacheSize = 6;

// ::- Represents a flat range of content.
var NodeRange = function ($from, $to, depth) {
  // :: ResolvedPos A resolved position along the start of the
  // content. May have a `depth` greater than this object's `depth`
  // property, since these are the positions that were used to
  // compute the range, not re-resolved positions directly at its
  // boundaries.
  this.$from = $from;
  // :: ResolvedPos A position along the end of the content. See
  // caveat for [`$from`](#model.NodeRange.$from).
  this.$to = $to;
  // :: number The depth of the node that this range points into.
  this.depth = depth;
};

var prototypeAccessors$1 = { start: {}, end: {}, parent: {}, startIndex: {}, endIndex: {} };

// :: number The position at the start of the range.
prototypeAccessors$1.start.get = function () {
  return this.$from.before(this.depth + 1);
};
// :: number The position at the end of the range.
prototypeAccessors$1.end.get = function () {
  return this.$to.after(this.depth + 1);
};

// :: Node The parent node that the range points into.
prototypeAccessors$1.parent.get = function () {
  return this.$from.node(this.depth);
};
// :: number The start index of the range in the parent node.
prototypeAccessors$1.startIndex.get = function () {
  return this.$from.index(this.depth);
};
// :: number The end index of the range in the parent node.
prototypeAccessors$1.endIndex.get = function () {
  return this.$to.indexAfter(this.depth);
};

Object.defineProperties(NodeRange.prototype, prototypeAccessors$1);
exports.NodeRange = NodeRange;

},{"./mark":8}],12:[function(require,module,exports){
var OrderedMap = require("orderedmap");

var ref = require("./node");
var Node = ref.Node;
var TextNode = ref.TextNode;
var ref$1 = require("./fragment");
var Fragment = ref$1.Fragment;
var ref$2 = require("./mark");
var Mark = ref$2.Mark;
var ref$3 = require("./content");
var ContentExpr = ref$3.ContentExpr;

// For node types where all attrs have a default value (or which don't
// have any attributes), build up a single reusable default attribute
// object, and use it for all nodes that don't specify specific
// attributes.
function defaultAttrs(attrs) {
  var defaults = Object.create(null);
  for (var attrName in attrs) {
    var attr = attrs[attrName];
    if (attr.default === undefined) {
      return null;
    }
    defaults[attrName] = attr.default;
  }
  return defaults;
}

function computeAttrs(attrs, value) {
  var built = Object.create(null);
  for (var name in attrs) {
    var given = value && value[name];
    if (given == null) {
      var attr = attrs[name];
      if (attr.default !== undefined) {
        given = attr.default;
      } else if (attr.compute) {
        given = attr.compute();
      } else {
        throw new RangeError("No value supplied for attribute " + name);
      }
    }
    built[name] = given;
  }
  return built;
}

function initAttrs(attrs) {
  var result = Object.create(null);
  if (attrs) {
    for (var name in attrs) {
      result[name] = new Attribute(attrs[name]);
    }
  }
  return result;
}

// ::- Node types are objects allocated once per `Schema` and used to
// tag `Node` instances with a type. They contain information about
// the node type, such as its name and what kind of node it
// represents.
var NodeType = function (name, schema, spec) {
  // :: string
  // The name the node type has in this schema.
  this.name = name;

  // :: Schema
  // A link back to the `Schema` the node type belongs to.
  this.schema = schema;

  // :: NodeSpec
  // The spec that this type is based on
  this.spec = spec;

  this.groups = spec.group ? spec.group.split(" ") : [];
  this.attrs = initAttrs(spec.attrs);

  this.defaultAttrs = defaultAttrs(this.attrs);
  this.contentExpr = null;

  // :: bool
  // True if this is a block type
  this.isBlock = !(spec.inline || name == "text");

  // :: bool
  // True if this is the text node type.
  this.isText = name == "text";
};

var prototypeAccessors = { isInline: {}, isTextblock: {}, inlineContent: {}, isLeaf: {}, isAtom: {} };

// :: bool
// True if this is an inline type.
prototypeAccessors.isInline.get = function () {
  return !this.isBlock;
};

// :: bool
// True if this is a textblock type, a block that contains inline
// content.
prototypeAccessors.isTextblock.get = function () {
  return this.isBlock && this.contentExpr.inlineContent;
};

// :: bool
// True if this node type has inline content.
prototypeAccessors.inlineContent.get = function () {
  return this.contentExpr.inlineContent;
};

// :: bool
// True for node types that allow no content.
prototypeAccessors.isLeaf.get = function () {
  return this.contentExpr.isLeaf;
};

// :: bool
// True when this node is an atom, i.e. when it does not have
// directly editable content.
prototypeAccessors.isAtom.get = function () {
  return this.isLeaf || this.spec.atom;
};

NodeType.prototype.hasRequiredAttrs = function (ignore) {
  var this$1 = this;

  for (var n in this$1.attrs) {
    if (this$1.attrs[n].isRequired && (!ignore || !(n in ignore))) {
      return true;
    }
  }
  return false;
};

NodeType.prototype.compatibleContent = function (other) {
  return this == other || this.contentExpr.compatible(other.contentExpr);
};

NodeType.prototype.computeAttrs = function (attrs) {
  if (!attrs && this.defaultAttrs) {
    return this.defaultAttrs;
  } else {
    return computeAttrs(this.attrs, attrs);
  }
};

// :: (?Object, ?union<Fragment, Node, [Node]>, ?[Mark]) → Node
// Create a `Node` of this type. The given attributes are
// checked and defaulted (you can pass `null` to use the type's
// defaults entirely, if no required attributes exist). `content`
// may be a `Fragment`, a node, an array of nodes, or
// `null`. Similarly `marks` may be `null` to default to the empty
// set of marks.
NodeType.prototype.create = function (attrs, content, marks) {
  if (typeof content == "string") {
    throw new Error("Calling create with string");
  }
  if (this.isText) {
    throw new Error("NodeType.create can't construct text nodes");
  }
  return new Node(this, this.computeAttrs(attrs), Fragment.from(content), Mark.setFrom(marks));
};

// :: (?Object, ?union<Fragment, Node, [Node]>, ?[Mark]) → Node
// Like [`create`](#model.NodeType.create), but check the given content
// against the node type's content restrictions, and throw an error
// if it doesn't match.
NodeType.prototype.createChecked = function (attrs, content, marks) {
  attrs = this.computeAttrs(attrs);
  content = Fragment.from(content);
  if (!this.validContent(content, attrs)) {
    throw new RangeError("Invalid content for node " + this.name);
  }
  return new Node(this, attrs, content, Mark.setFrom(marks));
};

// :: (?Object, ?union<Fragment, Node, [Node]>, ?[Mark]) → ?Node
// Like [`create`](#model.NodeType.create), but see if it is necessary to
// add nodes to the start or end of the given fragment to make it
// fit the node. If no fitting wrapping can be found, return null.
// Note that, due to the fact that required nodes can always be
// created, this will always succeed if you pass null or
// `Fragment.empty` as content.
NodeType.prototype.createAndFill = function (attrs, content, marks) {
  attrs = this.computeAttrs(attrs);
  content = Fragment.from(content);
  if (content.size) {
    var before = this.contentExpr.start(attrs).fillBefore(content);
    if (!before) {
      return null;
    }
    content = before.append(content);
  }
  var after = this.contentExpr.getMatchAt(attrs, content).fillBefore(Fragment.empty, true);
  if (!after) {
    return null;
  }
  return new Node(this, attrs, content.append(after), Mark.setFrom(marks));
};

// :: (Fragment, ?Object) → bool
// Returns true if the given fragment is valid content for this node
// type with the given attributes.
NodeType.prototype.validContent = function (content, attrs) {
  return this.contentExpr.matches(attrs, content);
};

NodeType.compile = function (nodes, schema) {
  var result = Object.create(null);
  nodes.forEach(function (name, spec) {
    return result[name] = new NodeType(name, schema, spec);
  });

  var topType = schema.spec.topNode || "doc";
  if (!result[topType]) {
    throw new RangeError("Schema is missing its top node type ('" + topType + "')");
  }
  if (!result.text) {
    throw new RangeError("Every schema needs a 'text' type");
  }
  for (var _ in result.text.attrs) {
    throw new RangeError("The text node type should not have attributes");
  }

  return result;
};

Object.defineProperties(NodeType.prototype, prototypeAccessors);
exports.NodeType = NodeType;

// Attribute descriptors

var Attribute = function (options) {
  this.default = options.default;
  this.compute = options.compute;
};

var prototypeAccessors$1 = { isRequired: {} };

prototypeAccessors$1.isRequired.get = function () {
  return this.default === undefined && !this.compute;
};

Object.defineProperties(Attribute.prototype, prototypeAccessors$1);

// Marks

// ::- Like nodes, marks (which are associated with nodes to signify
// things like emphasis or being part of a link) are tagged with type
// objects, which are instantiated once per `Schema`.
var MarkType = function (name, rank, schema, spec) {
  // :: string
  // The name of the mark type.
  this.name = name;

  // :: Schema
  // The schema that this mark type instance is part of.
  this.schema = schema;

  // :: MarkSpec
  // The spec on which the type is based.
  this.spec = spec;

  this.attrs = initAttrs(spec.attrs);

  this.rank = rank;
  this.excluded = null;
  var defaults = defaultAttrs(this.attrs);
  this.instance = defaults && new Mark(this, defaults);
};

// :: (?Object) → Mark
// Create a mark of this type. `attrs` may be `null` or an object
// containing only some of the mark's attributes. The others, if
// they have defaults, will be added.
MarkType.prototype.create = function (attrs) {
  if (!attrs && this.instance) {
    return this.instance;
  }
  return new Mark(this, computeAttrs(this.attrs, attrs));
};

MarkType.compile = function (marks, schema) {
  var result = Object.create(null),
      rank = 0;
  marks.forEach(function (name, spec) {
    return result[name] = new MarkType(name, rank++, schema, spec);
  });
  return result;
};

// :: ([Mark]) → [Mark]
// When there is a mark of this type in the given set, a new set
// without it is returned. Otherwise, the input set is returned.
MarkType.prototype.removeFromSet = function (set) {
  var this$1 = this;

  for (var i = 0; i < set.length; i++) {
    if (set[i].type == this$1) {
      return set.slice(0, i).concat(set.slice(i + 1));
    }
  }
  return set;
};

// :: ([Mark]) → ?Mark
// Tests whether there is a mark of this type in the given set.
MarkType.prototype.isInSet = function (set) {
  var this$1 = this;

  for (var i = 0; i < set.length; i++) {
    if (set[i].type == this$1) {
      return set[i];
    }
  }
};

// :: (MarkType) → bool
// Queries whether a given mark type is
// [excluded](#model.MarkSpec.excludes) by this one.
MarkType.prototype.excludes = function (other) {
  return this.excluded.indexOf(other) > -1;
};
exports.MarkType = MarkType;

// SchemaSpec:: interface
// An object describing a schema, as passed to the `Schema`
// constructor.
//
//   nodes:: union<Object<NodeSpec>, OrderedMap<NodeSpec>>
//   The node types in this schema. Maps names to `NodeSpec` objects
//   describing the node to be associated with that name. Their order
//   is significant
//
//   marks:: ?union<Object<MarkSpec>, OrderedMap<MarkSpec>>
//   The mark types that exist in this schema.
//
//   topNode:: ?string
//   The name of the default top-level node for the schema. Defaults
//   to `"doc"`.

// NodeSpec:: interface
//
//   content:: ?string
//   The content expression for this node, as described in the [schema
//   guide](/docs/guides/schema/). When not given, the node does not allow
//   any content.
//
//   group:: ?string
//   The group or space-separated groups to which this node belongs, as
//   referred to in the content expressions for the schema.
//
//   inline:: ?bool
//   Should be set to a truthy value for inline nodes. (Implied for
//   text nodes.)
//
//   atom:: ?bool
//   Can be set to true to indicate that, though this isn't a [leaf
//   node](#model.NodeType.isLeaf), it doesn't have directly editable
//   content and should be treated as a single unit in the view.
//
//   attrs:: ?Object<AttributeSpec>
//   The attributes that nodes of this type get.
//
//   selectable:: ?bool
//   Controls whether nodes of this type can be selected (as a [node
//   selection](#state.NodeSelection)). Defaults to true for non-text
//   nodes.
//
//   draggable:: ?bool
//   Determines whether nodes of this type can be dragged without
//   being selected. Defaults to false.
//
//   code:: ?bool
//   Can be used to indicate that this node contains code, which
//   causes some commands to behave differently.
//
//   defining:: ?bool
//   Determines whether this node is considered an important parent
//   node during replace operations (such as paste). Non-defining (the
//   default) nodes get dropped when their entire content is replaced,
//   whereas defining nodes persist and wrap the inserted content.
//   Likewise, the the _inserted_ content, when not inserting into a
//   textblock, the defining parents of the content are preserved.
//   Typically, non-default-paragraph textblock types, and possible
//   list items, are marked as defining.
//
//   isolating:: ?bool
//   When enabled (default is false), the sides of nodes of this type
//   count as boundaries that regular editing operations, like
//   backspacing or lifting, won't cross. An example of a node that
//   should probably have this set is a table cell.
//
//   toDOM:: ?(node: Node) → DOMOutputSpec
//   Defines the default way a node of this type should be serialized
//   to DOM/HTML (as used by
//   [`DOMSerializer.fromSchema`](#model.DOMSerializer^fromSchema)).
//   Should return an [array structure](#model.DOMOutputSpec) that
//   describes the resulting DOM structure, with an optional number
//   zero (“hole”) in it to indicate where the node's content should
//   be inserted.
//
//   For text nodes, the default is to create a text DOM node. Though
//   it is possible to create a serializer where text is rendered
//   differently, this is not supported inside the editor, so you
//   shouldn't override that in your text node spec.
//
//   parseDOM:: ?[ParseRule]
//   Associates DOM parser information with this node, which can be
//   used by [`DOMParser.fromSchema`](#model.DOMParser^fromSchema) to
//   automatically derive a parser. The `node` field in the rules is
//   implied (the name of this node will be filled in automatically).
//   If you supply your own parser, you do not need to also specify
//   parsing rules in your schema.

// MarkSpec:: interface
//
//   attrs:: ?Object<AttributeSpec>
//   The attributes that marks of this type get.
//
//   inclusive:: ?bool
//   Whether this mark should be active when the cursor is positioned
//   at the start or end boundary of the mark. Defaults to true.
//
//   excludes:: ?string
//   Determines which other marks this mark can coexist with. Should
//   be a space-separated strings naming other marks or groups of marks.
//   When a mark is [added](#model.mark.addToSet) to a set, all marks
//   that it excludes are removed in the process. If the set contains
//   any mark that excludes the new mark but is not, itself, excluded
//   by the new mark, the mark can not be added an the set. You can
//   use the value `"_"` to indicate that the mark excludes all
//   marks in the schema.
//
//   Defaults to only being exclusive with marks of the same type. You
//   can set it to an empty string (or any string not containing the
//   mark's own name) to allow multiple marks of a given type to
//   coexist (as long as they have different attributes).
//
//   group:: ?string
//   The group or space-separated groups to which this node belongs.
//
//   toDOM:: ?(mark: Mark, inline: bool) → DOMOutputSpec
//   Defines the default way marks of this type should be serialized
//   to DOM/HTML.
//
//   parseDOM:: ?[ParseRule]
//   Associates DOM parser information with this mark (see the
//   corresponding [node spec field](#model.NodeSpec.parseDOM)). The
//   `mark` field in the rules is implied.

// AttributeSpec:: interface
//
// Used to define attributes. Attributes that have no default or
// compute property must be provided whenever a node or mark of a type
// that has them is created.
//
// The following fields are supported:
//
//   default:: ?any
//   The default value for this attribute, to choose when no
//   explicit value is provided.
//
//   compute:: ?() → any
//   A function that computes a default value for the attribute.

// ::- A document schema.
var Schema = function (spec) {
  var this$1 = this;

  // :: SchemaSpec
  // The [spec](#model.SchemaSpec) on which the schema is based,
  // with the added guarantee that its `nodes` and `marks`
  // properties are
  // [`OrderedMap`](https://github.com/marijnh/orderedmap) instances
  // (not raw objects or null).
  this.spec = {};
  for (var prop in spec) {
    this$1.spec[prop] = spec[prop];
  }
  this.spec.nodes = OrderedMap.from(spec.nodes);
  this.spec.marks = OrderedMap.from(spec.marks);

  // :: Object<NodeType>
  // An object mapping the schema's node names to node type objects.
  this.nodes = NodeType.compile(this.spec.nodes, this);

  // :: Object<MarkType>
  // A map from mark names to mark type objects.
  this.marks = MarkType.compile(this.spec.marks, this);

  for (var prop$1 in this$1.nodes) {
    if (prop$1 in this$1.marks) {
      throw new RangeError(prop$1 + " can not be both a node and a mark");
    }
    var type = this$1.nodes[prop$1];
    type.contentExpr = ContentExpr.parse(type, this$1.spec.nodes.get(prop$1).content || "");
  }
  for (var prop$2 in this$1.marks) {
    var type$1 = this$1.marks[prop$2],
        excl = type$1.spec.excludes;
    type$1.excluded = excl == null ? [type$1] : excl == "" ? [] : ContentExpr.gatherMarks(this$1, excl.split(" "));
  }

  // :: Object
  // An object for storing whatever values modules may want to
  // compute and cache per schema. (If you want to store something
  // in it, try to use property names unlikely to clash.)
  this.cached = Object.create(null);
  this.cached.wrappings = Object.create(null);

  this.nodeFromJSON = this.nodeFromJSON.bind(this);
  this.markFromJSON = this.markFromJSON.bind(this);

  // :: NodeType
  // The type of the [default top node](#model.SchemaSpec.topNode)
  // for this schema.
  this.topNodeType = this.nodes[this.spec.topNode || "doc"];
};

// :: (union<string, NodeType>, ?Object, ?union<Fragment, Node, [Node]>, ?[Mark]) → Node
// Create a node in this schema. The `type` may be a string or a
// `NodeType` instance. Attributes will be extended
// with defaults, `content` may be a `Fragment`,
// `null`, a `Node`, or an array of nodes.
Schema.prototype.node = function (type, attrs, content, marks) {
  if (typeof type == "string") {
    type = this.nodeType(type);
  } else if (!(type instanceof NodeType)) {
    throw new RangeError("Invalid node type: " + type);
  } else if (type.schema != this) {
    throw new RangeError("Node type from different schema used (" + type.name + ")");
  }

  return type.createChecked(attrs, content, marks);
};

// :: (string, ?[Mark]) → Node
// Create a text node in the schema. Empty text nodes are not
// allowed.
Schema.prototype.text = function (text$1, marks) {
  var type = this.nodes.text;
  return new TextNode(type, type.defaultAttrs, text$1, Mark.setFrom(marks));
};

// :: (union<string, MarkType>, ?Object) → Mark
// Create a mark with the given type and attributes.
Schema.prototype.mark = function (type, attrs) {
  if (typeof type == "string") {
    type = this.marks[type];
  }
  return type.create(attrs);
};

// :: (Object) → Node
// Deserialize a node from its JSON representation. This method is
// bound.
Schema.prototype.nodeFromJSON = function (json) {
  return Node.fromJSON(this, json);
};

// :: (Object) → Mark
// Deserialize a mark from its JSON representation. This method is
// bound.
Schema.prototype.markFromJSON = function (json) {
  return Mark.fromJSON(this, json);
};

Schema.prototype.nodeType = function (name) {
  var found = this.nodes[name];
  if (!found) {
    throw new RangeError("Unknown node type: " + name);
  }
  return found;
};
exports.Schema = Schema;

},{"./content":3,"./fragment":5,"./mark":8,"./node":9,"orderedmap":1}],13:[function(require,module,exports){
// DOMOutputSpec:: interface
// A description of a DOM structure. Can be either a string, which is
// interpreted as a text node, a DOM node, which is interpreted as
// itself, or an array.
//
// An array describes a DOM element. The first element in the array
// should be a string, and is the name of the DOM element. If the
// second element is a non-Array, non-DOM node object, it is
// interpreted as an object providing the DOM element's attributes.
// Any elements after that (including the 2nd if it's not an attribute
// object) are interpreted as children of the DOM elements, and must
// either be valid `DOMOutputSpec` values, or the number zero.
//
// The number zero (pronounced “hole”) is used to indicate the place
// where a ProseMirror node's content should be inserted.

// ::- A DOM serializer knows how to convert ProseMirror nodes and
// marks of various types to DOM nodes.
var DOMSerializer = function (nodes, marks) {
  // :: Object<(node: Node) → DOMOutputSpec>
  this.nodes = nodes || {};
  // :: Object<(mark: Mark) → DOMOutputSpec>
  this.marks = marks || {};
};

// :: (Fragment, ?Object) → dom.DocumentFragment
// Serialize the content of this fragment to a DOM fragment. When
// not in the browser, the `document` option, containing a DOM
// document, should be passed so that the serializer can create
// nodes.
DOMSerializer.prototype.serializeFragment = function (fragment, options, target) {
  var this$1 = this;
  if (options === void 0) options = {};

  if (!target) {
    target = doc(options).createDocumentFragment();
  }

  var top = target,
      active = null;
  fragment.forEach(function (node) {
    if (active || node.marks.length) {
      if (!active) {
        active = [];
      }
      var keep = 0;
      for (; keep < Math.min(active.length, node.marks.length); ++keep) {
        if (!node.marks[keep].eq(active[keep])) {
          break;
        }
      }
      while (keep < active.length) {
        var removed = active.pop();
        if (this$1.marks[removed.type.name]) {
          top = top.parentNode;
        }
      }
      while (active.length < node.marks.length) {
        var add = node.marks[active.length];
        active.push(add);
        var markDOM = this$1.serializeMark(add, node.isInline, options);
        if (markDOM) {
          top = top.appendChild(markDOM);
        }
      }
    }
    top.appendChild(this$1.serializeNode(node, options));
  });

  return target;
};

// :: (Node, ?Object) → dom.Node
// Serialize this node to a DOM node. This can be useful when you
// need to serialize a part of a document, as opposed to the whole
// document. To serialize a whole document, use
// [`serializeFragment`](#model.DOMSerializer.serializeFragment) on
// its [`content`](#model.Node.content).
DOMSerializer.prototype.serializeNode = function (node, options) {
  if (options === void 0) options = {};

  return this.renderStructure(this.nodes[node.type.name](node), node, options);
};

DOMSerializer.prototype.serializeNodeAndMarks = function (node, options) {
  var this$1 = this;
  if (options === void 0) options = {};

  var dom = this.serializeNode(node, options);
  for (var i = node.marks.length - 1; i >= 0; i--) {
    var wrap = this$1.serializeMark(node.marks[i], node.isInline, options);
    if (wrap) {
      wrap.appendChild(dom);
      dom = wrap;
    }
  }
  return dom;
};

DOMSerializer.prototype.serializeMark = function (mark, inline, options) {
  if (options === void 0) options = {};

  var toDOM = this.marks[mark.type.name];
  return toDOM && this.renderStructure(toDOM(mark, inline), null, options);
};

// :: (dom.Document, DOMOutputSpec) → {dom: dom.Node, contentDOM: ?dom.Node}
// Render an [output spec](#model.DOMOutputSpec).
DOMSerializer.renderSpec = function (doc, structure) {
  if (typeof structure == "string") {
    return { dom: doc.createTextNode(structure) };
  }
  if (structure.nodeType != null) {
    return { dom: structure };
  }
  var dom = doc.createElement(structure[0]),
      contentDOM = null;
  var attrs = structure[1],
      start = 1;
  if (attrs && typeof attrs == "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
    start = 2;
    for (var name in attrs) {
      if (name == "style") {
        dom.style.cssText = attrs[name];
      } else if (attrs[name] != null) {
        dom.setAttribute(name, attrs[name]);
      }
    }
  }
  for (var i = start; i < structure.length; i++) {
    var child = structure[i];
    if (child === 0) {
      if (i < structure.length - 1 || i > start) {
        throw new RangeError("Content hole must be the only child of its parent node");
      }
      return { dom: dom, contentDOM: dom };
    } else {
      var ref = DOMSerializer.renderSpec(doc, child);
      var inner = ref.dom;
      var innerContent = ref.contentDOM;
      dom.appendChild(inner);
      if (innerContent) {
        if (contentDOM) {
          throw new RangeError("Multiple content holes");
        }
        contentDOM = innerContent;
      }
    }
  }
  return { dom: dom, contentDOM: contentDOM };
};

DOMSerializer.prototype.renderStructure = function (structure, node, options) {
  var ref = DOMSerializer.renderSpec(doc(options), structure);
  var dom = ref.dom;
  var contentDOM = ref.contentDOM;
  if (contentDOM) {
    if (!node || node.isLeaf) {
      throw new RangeError("Content hole not allowed in a mark or leaf node spec");
    }
    if (options.onContent) {
      options.onContent(node, contentDOM, options);
    } else {
      this.serializeFragment(node.content, options, contentDOM);
    }
  }
  return dom;
};

// :: (Schema) → DOMSerializer
// Build a serializer using the [`toDOM`](#model.NodeSpec.toDOM)
// properties in a schema's node and mark specs.
DOMSerializer.fromSchema = function (schema) {
  return schema.cached.domSerializer || (schema.cached.domSerializer = new DOMSerializer(this.nodesFromSchema(schema), this.marksFromSchema(schema)));
};

// :: (Schema) → Object<(node: Node) → DOMOutputSpec>
// Gather the serializers in a schema's node specs into an object.
// This can be useful as a base to build a custom serializer from.
DOMSerializer.nodesFromSchema = function (schema) {
  var result = gatherToDOM(schema.nodes);
  if (!result.text) {
    result.text = function (node) {
      return node.text;
    };
  }
  return result;
};

// :: (Schema) → Object<(mark: Mark) → DOMOutputSpec>
// Gather the serializers in a schema's mark specs into an object.
DOMSerializer.marksFromSchema = function (schema) {
  return gatherToDOM(schema.marks);
};
exports.DOMSerializer = DOMSerializer;

function gatherToDOM(obj) {
  var result = {};
  for (var name in obj) {
    var toDOM = obj[name].spec.toDOM;
    if (toDOM) {
      result[name] = toDOM;
    }
  }
  return result;
}

function doc(options) {
  // declare global: window
  return options.document || window.document;
}

},{}],14:[function(require,module,exports){
;var assign;
assign = require("./selection"), exports.Selection = assign.Selection, exports.SelectionRange = assign.SelectionRange, exports.TextSelection = assign.TextSelection, exports.NodeSelection = assign.NodeSelection, exports.AllSelection = assign.AllSelection;

exports.Transaction = require("./transaction").Transaction;

exports.EditorState = require("./state").EditorState;var assign$1;
assign$1 = require("./plugin"), exports.Plugin = assign$1.Plugin, exports.PluginKey = assign$1.PluginKey;

},{"./plugin":15,"./selection":16,"./state":17,"./transaction":18}],15:[function(require,module,exports){
// PluginSpec:: interface
//
// A plugin spec provides a definition for a plugin.
//
//   props:: ?EditorProps
//   The [view props](#view.EditorProps) added by this plugin. Props
//   that are functions will be bound to have the plugin instance as
//   their `this` binding.
//
//   state:: ?StateField<any>
//   A [state field](#state.StateField) defined by this plugin.
//
//   key:: ?PluginKey
//   Can optionally be used to make this a keyed plugin. You can
//   have only one plugin with a given key in a given state, but
//   it is possible to access the plugin's configuration and state
//   through the key, without having access to the plugin instance
//   itself.
//
//   view:: ?(EditorView) → Object
//   When the plugin needs to interact with the editor view, or
//   set something up in the DOM, use this field. The function
//   will be called when the plugin's state is associated with an
//   editor view.
//
//     return::-
//     Should return an object with the following optional
//     properties:
//
//       update:: ?(view: EditorView, prevState: EditorState)
//       Called whenever the view's state is updated.
//
//       destroy:: ?()
//       Called when the view is destroyed or receives a state
//       with different plugins.
//
//   filterTransaction:: ?(Transaction, EditorState) → bool
//   When present, this will be called before a transaction is
//   applied by the state, allowing the plugin to cancel it (by
//   returning false).
//
//   appendTransaction:: ?(transactions: [Transaction], oldState: EditorState, newState: EditorState) → ?Transaction
//   Allows the plugin to append another transaction to be applied
//   after the given array of transactions. When another plugin
//   appends a transaction after this was called, it is called
//   again with the new state and extended array of transactions.

function bindProps(obj, self, target) {
  for (var prop in obj) {
    var val = obj[prop];
    if (val instanceof Function) {
      val = val.bind(self);
    } else if (prop == "handleDOMEvents") {
      val = bindProps(val, self, {});
    }
    target[prop] = val;
  }
  return target;
}

// ::- Plugins wrap extra functionality that can be added to an
// editor. They can define new [state fields](#state.StateField), and
// add [view props](#view.EditorProps).
var Plugin = function Plugin(spec) {
  // :: EditorProps
  // The props exported by this plugin.
  this.props = {};
  if (spec.props) {
    bindProps(spec.props, this, this.props);
  }
  // :: Object
  // The plugin's configuration object.
  this.spec = spec;
  this.key = spec.key ? spec.key.key : createKey("plugin");
};

// :: (EditorState) → any
// Get the state field for this plugin.
Plugin.prototype.getState = function getState(state) {
  return state[this.key];
};
exports.Plugin = Plugin;

// StateField:: interface<T>
// A plugin may provide a state field (under its `state` property) of
// this type, which describes the state it wants to keep. Functions
// provided here are always called with the plugin instance as their
// `this` binding.
//
//   init:: (config: Object, instance: EditorState) → T
//   Initialize the value of this field. `config` will be the object
//   passed to [`EditorState.create`](#state.EditorState^create). Note
//   that `instance` is a half-initialized state instance, and will
//   not have values for any fields initialized after this one.
//
//   apply:: (tr: Transaction, value: T, oldState: EditorState, newState: EditorState) → T
//   Apply the given transaction to this state field, producing a new
//   field value. Note that the `newState` argument is a partially
//   constructed state does not yet contain the state from plugins
//   coming after this plugin.
//
//   toJSON:: ?(value: T) → *
//   Convert this field to JSON. Optional, can be left off to disable
//   JSON serialization for the field.
//
//   fromJSON:: ?(config: Object, value: *, state: EditorState) → T
//   Deserialize the JSON representation of this field. Note that the
//   `state` argument is again a half-initialized state.

var keys = Object.create(null);

function createKey(name) {
  if (name in keys) {
    return name + "$" + ++keys[name];
  }
  keys[name] = 0;
  return name + "$";
}

// ::- A key is used to [tag](#state.PluginSpec.key)
// plugins in a way that makes it possible to find them, given an
// editor state. Assigning a key does mean only one plugin of that
// type can be active in a state.
var PluginKey = function PluginKey(name) {
  if (name === void 0) name = "key";
  this.key = createKey(name);
};

// :: (EditorState) → ?Plugin
// Get the active plugin with this key, if any, from an editor
// state.
PluginKey.prototype.get = function get(state) {
  return state.config.pluginsByKey[this.key];
};

// :: (EditorState) → ?any
// Get the plugin's state from an editor state.
PluginKey.prototype.getState = function getState(state) {
  return state[this.key];
};
exports.PluginKey = PluginKey;

},{}],16:[function(require,module,exports){
var ref = require("prosemirror-model");
var Slice = ref.Slice;
var Fragment = ref.Fragment;

var classesById = Object.create(null);

// ::- Superclass for editor selections. Should not be instantiated
// directly, only extended.
var Selection = function Selection($anchor, $head, ranges) {
  // :: [SelectionRange]
  // The ranges covered by the selection.
  this.ranges = ranges || [new SelectionRange($anchor.min($head), $anchor.max($head))];
  // :: ResolvedPos
  // The resolved anchor of the selection (the side that stays in
  // place when the selection is modified).
  this.$anchor = $anchor;
  // :: ResolvedPos
  // The resolved head of the selection (the side that moves when
  // the selection is modified).
  this.$head = $head;
};

var prototypeAccessors = { anchor: {}, head: {}, from: {}, to: {}, $from: {}, $to: {}, empty: {} };

// :: number
// The selection's immobile side (does not move when
// shift-selecting).
prototypeAccessors.anchor.get = function () {
  return this.$anchor.pos;
};

// :: number
// The selection's mobile side (the side that moves when
// shift-selecting).
prototypeAccessors.head.get = function () {
  return this.$head.pos;
};

// :: number
// The lower bound of the selection's first range.
prototypeAccessors.from.get = function () {
  return this.$from.pos;
};

// :: number
// The upper bound of the selection's first range.
prototypeAccessors.to.get = function () {
  return this.$to.pos;
};

// :: ResolvedPos
// The resolved lowerbound of the selection's main range.
prototypeAccessors.$from.get = function () {
  return this.ranges[0].$from;
};

// :: ResolvedPos
// The resolved upper bound of the selection's main range.
prototypeAccessors.$to.get = function () {
  return this.ranges[0].$to;
};

// :: bool
// Indicates whether the selection contains any content.
prototypeAccessors.empty.get = function () {
  var ranges = this.ranges;
  for (var i = 0; i < ranges.length; i++) {
    if (ranges[i].$from.pos != ranges[i].$to.pos) {
      return false;
    }
  }
  return true;
};

// eq:: (Selection) → bool
// Test whether the selection is the same as another selection.

// map:: (doc: Node, mapping: Mappable) → Selection
// Map this selection through a [mappable](#transform.Mappable) thing. `doc`
// should be the new document, to which we are mapping.

// :: Slice
// Get the content of this selection as a slice.
Selection.prototype.content = function content() {
  return this.$from.node(0).slice(this.from, this.to, true);
};

// :: (Transaction, ?Slice)
// Replace the selection with a slice or, if no slice is given,
// delete the selection. Will append to the given transaction.
Selection.prototype.replace = function replace(tr, content) {
  if (content === void 0) content = Slice.empty;

  // Put the new selection at the position after the inserted
  // content. When that ended in an inline node, search backwards,
  // to get the position after that node. If not, search forward.
  var lastNode = content.content.lastChild,
      lastParent = null;
  for (var i = 0; i < content.openEnd; i++) {
    lastParent = lastNode;
    lastNode = lastNode.lastChild;
  }

  var mapFrom = tr.steps.length,
      ranges = this.ranges;
  for (var i$1 = 0; i$1 < ranges.length; i$1++) {
    var ref = ranges[i$1];
    var $from = ref.$from;
    var $to = ref.$to;
    var mapping = tr.mapping.slice(mapFrom);
    tr.replaceRange(mapping.map($from.pos), mapping.map($to.pos), i$1 ? Slice.empty : content);
    if (i$1 == 0) {
      selectionToInsertionEnd(tr, mapFrom, (lastNode ? lastNode.isInline : lastParent && lastParent.isTextblock) ? -1 : 1);
    }
  }
};

// :: (Transaction, Node)
// Replace the selection with the given node, appending the changes
// to the given transaction.
Selection.prototype.replaceWith = function replaceWith(tr, node) {
  var mapFrom = tr.steps.length,
      ranges = this.ranges;
  for (var i = 0; i < ranges.length; i++) {
    var ref = ranges[i];
    var $from = ref.$from;
    var $to = ref.$to;
    var mapping = tr.mapping.slice(mapFrom);
    var from = mapping.map($from.pos),
        to = mapping.map($to.pos);
    if (i) {
      tr.deleteRange(from, to);
    } else {
      tr.replaceRangeWith(from, to, node);
      selectionToInsertionEnd(tr, mapFrom, node.isInline ? -1 : 1);
    }
  }
};

// toJSON:: () → Object
// Convert the selection to a JSON representation. When implementing
// this for a custom selection class, make sure to give the object a
// `type` property whose value matches the ID under which you
// [registered](#state.Selection^jsonID) your class. The default
// implementation adds `type`, `head`, and `anchor` properties.

// :: (ResolvedPos, number, ?bool) → ?Selection
// Find a valid cursor or leaf node selection starting at the given
// position and searching back if `dir` is negative, and forward if
// negative. When `textOnly` is true, only consider cursor
// selections.
Selection.findFrom = function findFrom($pos, dir, textOnly) {
  var inner = $pos.parent.inlineContent ? new TextSelection($pos) : findSelectionIn($pos.node(0), $pos.parent, $pos.pos, $pos.index(), dir, textOnly);
  if (inner) {
    return inner;
  }

  for (var depth = $pos.depth - 1; depth >= 0; depth--) {
    var found = dir < 0 ? findSelectionIn($pos.node(0), $pos.node(depth), $pos.before(depth + 1), $pos.index(depth), dir, textOnly) : findSelectionIn($pos.node(0), $pos.node(depth), $pos.after(depth + 1), $pos.index(depth) + 1, dir, textOnly);
    if (found) {
      return found;
    }
  }
};

// :: (ResolvedPos, ?number) → Selection
// Find a valid cursor or leaf node selection near the given
// position. Searches forward first by default, but if `bias` is
// negative, it will search backwards first.
Selection.near = function near($pos, bias) {
  if (bias === void 0) bias = 1;

  return this.findFrom($pos, bias) || this.findFrom($pos, -bias) || new AllSelection($pos.node(0));
};

// :: (Node) → Selection
// Find the cursor or leaf node selection closest to the start of
// the given document. Will return an `AllSelection` if no valid
// position exists.
Selection.atStart = function atStart(doc) {
  return findSelectionIn(doc, doc, 0, 0, 1) || new AllSelection(doc);
};

// :: (Node) → Selection
// Find the cursor or leaf node selection closest to the end of the
// given document. Will return an `AllSelection` if no valid
// position exists.
Selection.atEnd = function atEnd(doc) {
  return findSelectionIn(doc, doc, doc.content.size, doc.childCount, -1) || new AllSelection(doc);
};

// :: (Node, Object) → Selection
// Deserialize a JSON representation of a selection. Must be
// implemented for custom classes (as a static class method).
Selection.fromJSON = function fromJSON(doc, json) {
  var cls = classesById[json.type];
  if (!cls) {
    return this.backwardsCompatFromJSON(doc, json);
  }
  return cls.fromJSON(doc, json);
};

Selection.backwardsCompatFromJSON = function backwardsCompatFromJSON(doc, json) {
  if (json.anchor != null) {
    return TextSelection.fromJSON(doc, json);
  }
  if (json.node != null) {
    return NodeSelection.fromJSON(doc, { anchor: json.node, head: json.after });
  }
  throw new RangeError("Unrecognized JSON data " + JSON.stringify(json));
};

// :: (string, constructor<Selection>)
// To be able to deserialize selections from JSON, custom selection
// classes must register themselves with an ID string, so that they
// can be disambiguated. Try to pick something that's unlikely to
// clash with classes from other modules.
Selection.jsonID = function jsonID(id, selectionClass) {
  if (id in classesById) {
    throw new RangeError("Duplicate use of selection JSON ID " + id);
  }
  classesById[id] = selectionClass;
  selectionClass.prototype.jsonID = id;
  return selectionClass;
};

// :: () → SelectionBookmark
// Get a [bookmark](#state.SelectionBookmark) for this selection,
// which is a value that can be mapped without having access to a
// current document, and later resolved to a real selection for a
// given document again. (This is used mostly by the history to
// track and restore old selections.) The default implementation of
// this method just converts the selection to a text selection and
// returns the bookmark for that.
Selection.prototype.getBookmark = function getBookmark() {
  return TextSelection.between(this.anchor, this.head).getBookmark();
};

Object.defineProperties(Selection.prototype, prototypeAccessors);
exports.Selection = Selection;

// :: bool
// Controls whether, when a selection of this type is active in the
// browser, the selected range should be visible to the user. Defaults
// to `true`.
Selection.prototype.visible = true;

// SelectionBookmark:: interface
// A lightweight, document-independent representation of a selection.
// You can define a custom bookmark type for a custom selection class
// to make the history handle it well.
//
//   map:: (mapping: Mapping) → SelectionBookmark
//   Map the bookmark through a set of changes.
//
//   resolve:: (doc: Node) → Selection
//   Resolve the bookmark to a real selection again. This may need to
//   do some error checking and may fall back to a default (usually
//   [`TextSelection.between`](#state.TextSelection.between) if
//   mapping made the bookmark invalid.

// ::- Represents a selected range in a document.
var SelectionRange = function SelectionRange($from, $to) {
  // :: ResolvedPos
  // The lower bound of the range.
  this.$from = $from;
  // :: ResolvedPos
  // The upper bound of the range.
  this.$to = $to;
};
exports.SelectionRange = SelectionRange;

// ::- A text selection represents a classical editor selection, with
// a head (the moving side) and anchor (immobile side), both of which
// point into textblock nodes. It can be empty (a regular cursor
// position).
var TextSelection = function (Selection) {
  function TextSelection($anchor, $head) {
    if ($head === void 0) $head = $anchor;

    Selection.call(this, $anchor, $head);
  }

  if (Selection) TextSelection.__proto__ = Selection;
  TextSelection.prototype = Object.create(Selection && Selection.prototype);
  TextSelection.prototype.constructor = TextSelection;

  var prototypeAccessors$1 = { $cursor: {} };

  // :: ?ResolvedPos
  // Returns a resolved position if this is a cursor selection (an
  // empty text selection), and null otherwise.
  prototypeAccessors$1.$cursor.get = function () {
    return this.$anchor.pos == this.$head.pos ? this.$head : null;
  };

  TextSelection.prototype.map = function map(doc, mapping) {
    var $head = doc.resolve(mapping.map(this.head));
    if (!$head.parent.inlineContent) {
      return Selection.near($head);
    }
    var $anchor = doc.resolve(mapping.map(this.anchor));
    return new TextSelection($anchor.parent.inlineContent ? $anchor : $head, $head);
  };

  TextSelection.prototype.replace = function replace(tr, content) {
    if (content === void 0) content = Slice.empty;

    Selection.prototype.replace.call(this, tr, content);
    if (content == Slice.empty) {
      if (this.$from.parentOffset < this.$from.parent.content.size) {
        tr.ensureMarks(this.$from.marks(true));
      }
    }
  };

  TextSelection.prototype.eq = function eq(other) {
    return other instanceof TextSelection && other.anchor == this.anchor && other.head == this.head;
  };

  TextSelection.prototype.getBookmark = function getBookmark() {
    return new TextBookmark(this.anchor, this.head);
  };

  TextSelection.prototype.toJSON = function toJSON() {
    return { type: "text", anchor: this.anchor, head: this.head };
  };

  TextSelection.fromJSON = function fromJSON(doc, json) {
    return new TextSelection(doc.resolve(json.anchor), doc.resolve(json.head));
  };

  // :: (Node, number, ?number) → TextSelection
  // Create a text selection from non-resolved positions.
  TextSelection.create = function create(doc, anchor, head) {
    if (head === void 0) head = anchor;

    var $anchor = doc.resolve(anchor);
    return new this($anchor, head == anchor ? $anchor : doc.resolve(head));
  };

  // :: (ResolvedPos, ResolvedPos, ?number) → Selection
  // Return a text selection that spans the given positions or, if
  // they aren't text positions, find a text selection near them.
  // `bias` determines whether the method searches forward (default)
  // or backwards (negative number) first. Will fall back to calling
  // [`Selection.near`](#state.Selection^near) when the document
  // doesn't contain a valid text position.
  TextSelection.between = function between($anchor, $head, bias) {
    var dPos = $anchor.pos - $head.pos;
    if (!bias || dPos) {
      bias = dPos >= 0 ? 1 : -1;
    }
    if (!$head.parent.inlineContent) {
      var found = Selection.findFrom($head, bias, true) || Selection.findFrom($head, -bias, true);
      if (found) {
        $head = found.$head;
      } else {
        return Selection.near($head, bias);
      }
    }
    if (!$anchor.parent.inlineContent) {
      if (dPos == 0) {
        $anchor = $head;
      } else {
        $anchor = (Selection.findFrom($anchor, -bias, true) || Selection.findFrom($anchor, bias, true)).$anchor;
        if ($anchor.pos < $head.pos != dPos < 0) {
          $anchor = $head;
        }
      }
    }
    return new TextSelection($anchor, $head);
  };

  Object.defineProperties(TextSelection.prototype, prototypeAccessors$1);

  return TextSelection;
}(Selection);
exports.TextSelection = TextSelection;

Selection.jsonID("text", TextSelection);

var TextBookmark = function TextBookmark(anchor, head) {
  this.anchor = anchor;
  this.head = head;
};
TextBookmark.prototype.map = function map(mapping) {
  return new TextBookmark(mapping.map(this.anchor), mapping.map(this.head));
};
TextBookmark.prototype.resolve = function resolve(doc) {
  return TextSelection.between(doc.resolve(this.anchor), doc.resolve(this.head));
};

// ::- A node selection is a selection that points at a
// single node. All nodes marked [selectable](#model.NodeSpec.selectable)
// can be the target of a node selection. In such an object, `from`
// and `to` point directly before and after the selected node.
var NodeSelection = function (Selection) {
  function NodeSelection($pos) {
    var node = $pos.nodeAfter;
    var $end = $pos.node(0).resolve($pos.pos + node.nodeSize);
    Selection.call(this, $pos, $end);
    // :: Node The selected node.
    this.node = node;
  }

  if (Selection) NodeSelection.__proto__ = Selection;
  NodeSelection.prototype = Object.create(Selection && Selection.prototype);
  NodeSelection.prototype.constructor = NodeSelection;

  NodeSelection.prototype.map = function map(doc, mapping) {
    var ref = mapping.mapResult(this.anchor);
    var deleted = ref.deleted;
    var pos = ref.pos;
    var $pos = doc.resolve(pos);
    if (deleted) {
      return Selection.near($pos);
    }
    return new NodeSelection($pos);
  };

  NodeSelection.prototype.content = function content() {
    return new Slice(Fragment.from(this.node), 0, 0);
  };

  NodeSelection.prototype.eq = function eq(other) {
    return other instanceof NodeSelection && other.anchor == this.anchor;
  };

  NodeSelection.prototype.toJSON = function toJSON() {
    return { type: "node", anchor: this.anchor };
  };

  NodeSelection.prototype.getBookmark = function getBookmark() {
    return new NodeBookmark(this.anchor);
  };

  NodeSelection.fromJSON = function fromJSON(doc, json) {
    return new NodeSelection(doc.resolve(json.anchor));
  };

  // :: (Node, number, ?number) → NodeSelection
  // Create a node selection from non-resolved positions.
  NodeSelection.create = function create(doc, from) {
    return new this(doc.resolve(from));
  };

  // :: (Node) → bool
  // Determines whether the given node may be selected as a node
  // selection.
  NodeSelection.isSelectable = function isSelectable(node) {
    return !node.isText && node.type.spec.selectable !== false;
  };

  return NodeSelection;
}(Selection);
exports.NodeSelection = NodeSelection;

NodeSelection.prototype.visible = false;

Selection.jsonID("node", NodeSelection);

var NodeBookmark = function NodeBookmark(anchor) {
  this.anchor = anchor;
};
NodeBookmark.prototype.map = function map(mapping) {
  var ref = mapping.mapResult(this.anchor);
  var deleted = ref.deleted;
  var pos = ref.pos;
  return deleted ? new TextBookmark(pos, pos) : new NodeBookmark(pos);
};
NodeBookmark.prototype.resolve = function resolve(doc) {
  var $pos = doc.resolve(this.anchor),
      node = $pos.nodeAfter;
  if (node && NodeSelection.isSelectable(node)) {
    return new NodeSelection($pos);
  }
  return Selection.near($pos);
};

// ::- A selection type that represents selecting the whole document
// (which can not necessarily be expressed with a text selection, when
// there are for example leaf block nodes at the start or end of the
// document).
var AllSelection = function (Selection) {
  function AllSelection(doc) {
    Selection.call(this, doc.resolve(0), doc.resolve(doc.content.size));
  }

  if (Selection) AllSelection.__proto__ = Selection;
  AllSelection.prototype = Object.create(Selection && Selection.prototype);
  AllSelection.prototype.constructor = AllSelection;

  AllSelection.prototype.toJSON = function toJSON() {
    return { type: "all" };
  };

  AllSelection.fromJSON = function fromJSON(doc) {
    return new AllSelection(doc);
  };

  AllSelection.prototype.map = function map(doc) {
    return new AllSelection(doc);
  };

  AllSelection.prototype.eq = function eq(other) {
    return other instanceof AllSelection;
  };

  AllSelection.prototype.getBookmark = function getBookmark() {
    return AllBookmark;
  };

  return AllSelection;
}(Selection);
exports.AllSelection = AllSelection;

Selection.jsonID("all", AllSelection);

var AllBookmark = {
  map: function map() {
    return this;
  },
  resolve: function resolve(doc) {
    return new AllSelection(doc);
  }

  // FIXME we'll need some awareness of text direction when scanning for selections

  // Try to find a selection inside the given node. `pos` points at the
  // position where the search starts. When `text` is true, only return
  // text selections.
};function findSelectionIn(doc, node, pos, index, dir, text) {
  if (node.inlineContent) {
    return TextSelection.create(doc, pos);
  }
  for (var i = index - (dir > 0 ? 0 : 1); dir > 0 ? i < node.childCount : i >= 0; i += dir) {
    var child = node.child(i);
    if (!child.isAtom) {
      var inner = findSelectionIn(doc, child, pos + dir, dir < 0 ? child.childCount : 0, dir, text);
      if (inner) {
        return inner;
      }
    } else if (!text && NodeSelection.isSelectable(child)) {
      return NodeSelection.create(doc, pos - (dir < 0 ? child.nodeSize : 0));
    }
    pos += child.nodeSize * dir;
  }
}

function selectionToInsertionEnd(tr, startLen, bias) {
  if (tr.steps.length == startLen) {
    return;
  }
  var map = tr.mapping.maps[tr.mapping.maps.length - 1],
      end;
  map.forEach(function (_from, _to, _newFrom, newTo) {
    return end = newTo;
  });
  if (end != null) {
    tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
  }
}

},{"prosemirror-model":7}],17:[function(require,module,exports){
var ref = require("prosemirror-model");
var Node = ref.Node;

var ref$1 = require("./selection");
var Selection = ref$1.Selection;
var ref$2 = require("./transaction");
var Transaction = ref$2.Transaction;

function bind(f, self) {
  return !self || !f ? f : f.bind(self);
}

var FieldDesc = function FieldDesc(name, desc, self) {
  this.name = name;
  this.init = bind(desc.init, self);
  this.apply = bind(desc.apply, self);
};

var baseFields = [new FieldDesc("doc", {
  init: function init(config) {
    return config.doc || config.schema.topNodeType.createAndFill();
  },
  apply: function apply(tr) {
    return tr.doc;
  }
}), new FieldDesc("selection", {
  init: function init(config, instance) {
    return config.selection || Selection.atStart(instance.doc);
  },
  apply: function apply(tr) {
    return tr.selection;
  }
}), new FieldDesc("storedMarks", {
  init: function init() {
    return null;
  },
  apply: function apply(tr, _marks, _old, state) {
    return state.selection.$cursor ? tr.storedMarks : null;
  }
}), new FieldDesc("scrollToSelection", {
  init: function init() {
    return 0;
  },
  apply: function apply(tr, prev) {
    return tr.scrolledIntoView ? prev + 1 : prev;
  }
})];

// Object wrapping the part of a state object that stays the same
// across transactions. Stored in the state's `config` property.
var Configuration = function Configuration(schema, plugins) {
  var this$1 = this;

  this.schema = schema;
  this.fields = baseFields.concat();
  this.plugins = [];
  this.pluginsByKey = Object.create(null);
  if (plugins) {
    plugins.forEach(function (plugin) {
      if (this$1.pluginsByKey[plugin.key]) {
        throw new RangeError("Adding different instances of a keyed plugin (" + plugin.key + ")");
      }
      this$1.plugins.push(plugin);
      this$1.pluginsByKey[plugin.key] = plugin;
      if (plugin.spec.state) {
        this$1.fields.push(new FieldDesc(plugin.key, plugin.spec.state, plugin));
      }
    });
  }
};

// ::- The state of a ProseMirror editor is represented by an object
// of this type. This is a persistent data structure—it isn't updated,
// but rather a new state value is computed from an old one with the
// [`apply`](#state.EditorState.apply) method.
//
// In addition to the built-in state fields, plugins can define
// additional pieces of state.
var EditorState = function EditorState(config) {
  this.config = config;
};

var prototypeAccessors = { schema: {}, plugins: {}, tr: {} };

// doc:: Node
// The current document.

// selection:: Selection
// The selection.

// storedMarks:: ?[Mark]
// A set of marks to apply to the next character that's typed. Will
// be null whenever no explicit marks have been set.

// :: Schema
// The schema of the state's document.
prototypeAccessors.schema.get = function () {
  return this.config.schema;
};

// :: [Plugin]
// The plugins that are active in this state.
prototypeAccessors.plugins.get = function () {
  return this.config.plugins;
};

// :: (Transaction) → EditorState
// Apply the given transaction to produce a new state.
EditorState.prototype.apply = function apply(tr) {
  return this.applyTransaction(tr).state;
};

// : (Transaction) → ?Transaction
EditorState.prototype.filterTransaction = function filterTransaction(tr, ignore) {
  var this$1 = this;
  if (ignore === void 0) ignore = -1;

  for (var i = 0; i < this.config.plugins.length; i++) {
    if (i != ignore) {
      var plugin = this$1.config.plugins[i];
      if (plugin.spec.filterTransaction && !plugin.spec.filterTransaction.call(plugin, tr, this$1)) {
        return false;
      }
    }
  }
  return true;
};

// :: (Transaction) → {state: EditorState, transactions: [Transaction]}
// Verbose variant of [`apply`](#state.EditorState.apply) that
// returns the precise transactions that were applied (which might
// be influenced by the [transaction
// hooks](#state.PluginSpec.filterTransaction) of
// plugins) along with the new state.
EditorState.prototype.applyTransaction = function applyTransaction(tr) {
  var this$1 = this;

  if (!this.filterTransaction(tr)) {
    return { state: this, transactions: [] };
  }

  var trs = [tr],
      newState = this.applyInner(tr),
      seen = null;
  // This loop repeatedly gives plugins a chance to respond to
  // transactions as new transactions are added, making sure to only
  // pass the transactions the plugin did not see before.
  outer: for (;;) {
    var haveNew = false;
    for (var i = 0; i < this.config.plugins.length; i++) {
      var plugin = this$1.config.plugins[i];
      if (plugin.spec.appendTransaction) {
        var n = seen ? seen[i].n : 0,
            oldState = seen ? seen[i].state : this$1;
        var tr$1 = n < trs.length && plugin.spec.appendTransaction.call(plugin, n ? trs.slice(n) : trs, oldState, newState);
        if (tr$1 && newState.filterTransaction(tr$1, i)) {
          tr$1.setMeta("appendedTransaction", tr$1);
          if (!seen) {
            seen = [];
            for (var j = 0; j < this.config.plugins.length; j++) {
              seen.push(j < i ? { state: newState, n: trs.length } : { state: this$1, n: 0 });
            }
          }
          trs.push(tr$1);
          newState = newState.applyInner(tr$1);
          haveNew = true;
        }
        if (seen) {
          seen[i] = { state: newState, n: trs.length };
        }
      }
    }
    if (!haveNew) {
      return { state: newState, transactions: trs };
    }
  }
};

// : (Transaction) → EditorState
EditorState.prototype.applyInner = function applyInner(tr) {
  var this$1 = this;

  if (!tr.before.eq(this.doc)) {
    throw new RangeError("Applying a mismatched transaction");
  }
  var newInstance = new EditorState(this.config),
      fields = this.config.fields;
  for (var i = 0; i < fields.length; i++) {
    var field = fields[i];
    newInstance[field.name] = field.apply(tr, this$1[field.name], this$1, newInstance);
  }
  for (var i$1 = 0; i$1 < applyListeners.length; i$1++) {
    applyListeners[i$1](this$1, tr, newInstance);
  }
  return newInstance;
};

// :: Transaction
// Start a [transaction](#state.Transaction) from this state.
prototypeAccessors.tr.get = function () {
  return new Transaction(this);
};

// :: (Object) → EditorState
// Create a state.
//
// config::- Configuration options. Must contain `schema` or `doc` (or both).
//
//    schema:: ?Schema
//    The schema to use.
//
//    doc:: ?Node
//    The starting document.
//
//    selection:: ?Selection
//    A valid selection in the document.
//
//    plugins:: ?[Plugin]
//    The plugins that should be active in this state.
EditorState.create = function create(config) {
  var $config = new Configuration(config.schema || config.doc.type.schema, config.plugins);
  var instance = new EditorState($config);
  for (var i = 0; i < $config.fields.length; i++) {
    instance[$config.fields[i].name] = $config.fields[i].init(config, instance);
  }
  return instance;
};

// :: (Object) → EditorState
// Create a new state based on this one, but with an adjusted set of
// active plugins. State fields that exist in both sets of plugins
// are kept unchanged. Those that no longer exist are dropped, and
// those that are new are initialized using their
// [`init`](#state.StateField.init) method, passing in the new
// configuration object..
//
// config::- configuration options
//
//   schema:: ?Schema
//   New schema to use.
//
//   plugins:: ?[Plugin]
//   New set of active plugins.
EditorState.prototype.reconfigure = function reconfigure(config) {
  var this$1 = this;

  var $config = new Configuration(config.schema || this.schema, config.plugins);
  var fields = $config.fields,
      instance = new EditorState($config);
  for (var i = 0; i < fields.length; i++) {
    var name = fields[i].name;
    instance[name] = this$1.hasOwnProperty(name) ? this$1[name] : fields[i].init(config, instance);
  }
  return instance;
};

// :: (?Object<Plugin>) → Object
// Serialize this state to JSON. If you want to serialize the state
// of plugins, pass an object mapping property names to use in the
// resulting JSON object to plugin objects.
EditorState.prototype.toJSON = function toJSON(pluginFields) {
  var this$1 = this;

  var result = { doc: this.doc.toJSON(), selection: this.selection.toJSON() };
  if (pluginFields) {
    for (var prop in pluginFields) {
      if (prop == "doc" || prop == "selection") {
        throw new RangeError("The JSON fields `doc` and `selection` are reserved");
      }
      var plugin = pluginFields[prop],
          state = plugin.spec.state;
      if (state && state.toJSON) {
        result[prop] = state.toJSON.call(plugin, this$1[plugin.key]);
      }
    }
  }
  return result;
};

// :: (Object, Object, ?Object<Plugin>) → EditorState
// Deserialize a JSON representation of a state. `config` should
// have at least a `schema` field, and should contain array of
// plugins to initialize the state with. `pluginFields` can be used
// to deserialize the state of plugins, by associating plugin
// instances with the property names they use in the JSON object.
//
// config::- configuration options
//
//   schema:: Schema
//   The schema to use.
//
//   plugins:: ?[Plugin]
//   The set of active plugins.
EditorState.fromJSON = function fromJSON(config, json, pluginFields) {
  if (!config.schema) {
    throw new RangeError("Required config field 'schema' missing");
  }
  var $config = new Configuration(config.schema, config.plugins);
  var instance = new EditorState($config);
  $config.fields.forEach(function (field) {
    if (field.name == "doc") {
      instance.doc = Node.fromJSON(config.schema, json.doc);
    } else if (field.name == "selection") {
      instance.selection = Selection.fromJSON(instance.doc, json.selection);
    } else {
      if (pluginFields) {
        for (var prop in pluginFields) {
          var plugin = pluginFields[prop],
              state = plugin.spec.state;
          if (plugin.key == field.name && state && state.fromJSON && Object.prototype.hasOwnProperty.call(json, prop)) {
            // This field belongs to a plugin mapped to a JSON field, read it from there.
            instance[field.name] = state.fromJSON.call(plugin, config, json[prop], instance);
            return;
          }
        }
      }
      instance[field.name] = field.init(config, instance);
    }
  });
  return instance;
};

// Kludge to allow the view to track mappings between different
// instances of a state.
EditorState.addApplyListener = function addApplyListener(f) {
  applyListeners.push(f);
};
EditorState.removeApplyListener = function removeApplyListener(f) {
  var found = applyListeners.indexOf(f);
  if (found > -1) {
    applyListeners.splice(found, 1);
  }
};

Object.defineProperties(EditorState.prototype, prototypeAccessors);
exports.EditorState = EditorState;

var applyListeners = [];

},{"./selection":16,"./transaction":18,"prosemirror-model":7}],18:[function(require,module,exports){
var ref = require("prosemirror-transform");
var Transform = ref.Transform;
var ref$1 = require("prosemirror-model");
var Mark = ref$1.Mark;

var UPDATED_SEL = 1,
    UPDATED_MARKS = 2,
    UPDATED_SCROLL = 4;

// ::- An editor state transaction, which can be applied to a state to
// create an updated state. Use
// [`EditorState.tr`](#state.EditorState.tr) to create an instance.
//
// Transactions track changes to the document (they are a subclass of
// [`Transform`](#transform.Transform)), but also other state changes,
// like selection updates and adjustments of the set of [stored
// marks](#state.EditorState.storedMarks). In addition, you can store
// metadata properties in a transaction, which are extra pieces of
// information that client code or plugins can use to describe what a
// transacion represents, so that they can update their [own
// state](#state.StateField) accordingly.
//
// The [editor view](#view.EditorView) uses a single metadata
// property: it will attach a property `"pointer"` with the value
// `true` to selection transactions directly caused by mouse or touch
// input.
var Transaction = function (Transform) {
  function Transaction(state) {
    Transform.call(this, state.doc);
    // :: number
    // The timestamp associated with this transaction.
    this.time = Date.now();
    this.curSelection = state.selection;
    // The step count for which the current selection is valid.
    this.curSelectionFor = 0;
    // :: ?[Mark]
    // The stored marks in this transaction.
    this.storedMarks = state.storedMarks;
    // Bitfield to track which aspects of the state were updated by
    // this transaction.
    this.updated = 0;
    // Object used to store metadata properties for the transaction.
    this.meta = Object.create(null);
  }

  if (Transform) Transaction.__proto__ = Transform;
  Transaction.prototype = Object.create(Transform && Transform.prototype);
  Transaction.prototype.constructor = Transaction;

  var prototypeAccessors = { selection: {}, selectionSet: {}, storedMarksSet: {}, isGeneric: {}, scrolledIntoView: {} };

  // :: Selection
  // The transform's current selection. This defaults to the
  // editor selection [mapped](#state.Selection.map) through the steps in
  // this transform, but can be overwritten with
  // [`setSelection`](#state.Transaction.setSelection).
  prototypeAccessors.selection.get = function () {
    if (this.curSelectionFor < this.steps.length) {
      this.curSelection = this.curSelection.map(this.doc, this.mapping.slice(this.curSelectionFor));
      this.curSelectionFor = this.steps.length;
    }
    return this.curSelection;
  };

  // :: (Selection) → Transaction
  // Update the transaction's current selection. This will determine
  // the selection that the editor gets when the transaction is
  // applied.
  Transaction.prototype.setSelection = function setSelection(selection) {
    this.curSelection = selection;
    this.curSelectionFor = this.steps.length;
    this.updated = (this.updated | UPDATED_SEL) & ~UPDATED_MARKS;
    this.storedMarks = null;
    return this;
  };

  // :: bool
  // Whether the selection was explicitly updated by this transaction.
  prototypeAccessors.selectionSet.get = function () {
    return (this.updated & UPDATED_SEL) > 0;
  };

  // :: (?[Mark]) → Transaction
  // Set the current stored marks.
  Transaction.prototype.setStoredMarks = function setStoredMarks(marks) {
    this.storedMarks = marks;
    this.updated |= UPDATED_MARKS;
    return this;
  };

  // :: ([Mark]) → Transaction
  // Make sure the current stored marks or, if that is null, the marks
  // at the selection, match the given set of marks. Does nothing if
  // this is already the case.
  Transaction.prototype.ensureMarks = function ensureMarks(marks) {
    if (!Mark.sameSet(this.storedMarks || this.selection.$from.marks(), marks)) {
      this.setStoredMarks(marks);
    }
    return this;
  };

  // :: bool
  // Whether the stored marks were explicitly set for this transaction.
  prototypeAccessors.storedMarksSet.get = function () {
    return (this.updated & UPDATED_MARKS) > 0;
  };

  Transaction.prototype.addStep = function addStep(step, doc) {
    Transform.prototype.addStep.call(this, step, doc);
    this.updated = this.updated & ~UPDATED_MARKS;
    this.storedMarks = null;
  };

  // :: (number) → Transaction
  // Update the timestamp for the transaction.
  Transaction.prototype.setTime = function setTime(time) {
    this.time = time;
    return this;
  };

  // :: (Slice) → Transaction
  Transaction.prototype.replaceSelection = function replaceSelection(slice) {
    this.selection.replace(this, slice);
    return this;
  };

  // :: (Node, ?bool) → Transaction
  // Replace the selection with the given node or slice, or delete it
  // if `content` is null. When `inheritMarks` is true and the content
  // is inline, it inherits the marks from the place where it is
  // inserted.
  Transaction.prototype.replaceSelectionWith = function replaceSelectionWith(node, inheritMarks) {
    var selection = this.selection;
    if (inheritMarks !== false) {
      node = node.mark(this.storedMarks || selection.$from.marks(selection.to > selection.from));
    }
    selection.replaceWith(this, node);
    return this;
  };

  // :: () → Transaction
  // Delete the selection.
  Transaction.prototype.deleteSelection = function deleteSelection() {
    this.selection.replace(this);
    return this;
  };

  // :: (string, from: ?number, to: ?number) → Transaction
  // Replace the given range, or the selection if no range is given,
  // with a text node containing the given string.
  Transaction.prototype.insertText = function insertText(text, from, to) {
    if (to === void 0) to = from;

    var schema = this.doc.type.schema;
    if (from == null) {
      if (!text) {
        return this.deleteSelection();
      }
      return this.replaceSelectionWith(schema.text(text), true);
    } else {
      if (!text) {
        return this.deleteRange(from, to);
      }
      var node = schema.text(text, this.storedMarks || this.doc.resolve(from).marks(to > from));
      return this.replaceRangeWith(from, to, node);
    }
  };

  // :: (union<string, Plugin, PluginKey>, any) → Transaction
  // Store a metadata property in this transaction, keyed either by
  // name or by plugin.
  Transaction.prototype.setMeta = function setMeta(key, value) {
    this.meta[typeof key == "string" ? key : key.key] = value;
    return this;
  };

  // :: (union<string, Plugin, PluginKey>) → any
  // Retrieve a metadata property for a given name or plugin.
  Transaction.prototype.getMeta = function getMeta(key) {
    return this.meta[typeof key == "string" ? key : key.key];
  };

  // :: bool
  // Returns true if this transaction doesn't contain any metadata,
  // and can thus be safely extended.
  prototypeAccessors.isGeneric.get = function () {
    var this$1 = this;

    for (var _ in this$1.meta) {
      return false;
    }
    return true;
  };

  // :: () → Transaction
  // Indicate that the editor should scroll the selection into view
  // when updated to the state produced by this transaction.
  Transaction.prototype.scrollIntoView = function scrollIntoView() {
    this.updated |= UPDATED_SCROLL;
    return this;
  };

  prototypeAccessors.scrolledIntoView.get = function () {
    return (this.updated & UPDATED_SCROLL) > 0;
  };

  // :: (Mark) → Transaction
  // Add a mark to the set of stored marks.
  Transaction.prototype.addStoredMark = function addStoredMark(mark) {
    return this.ensureMarks(mark.addToSet(this.storedMarks || this.selection.$head.marks()));
  };

  // :: (union<Mark, MarkType>) → Transaction
  // Remove a mark or mark type from the set of stored marks.
  Transaction.prototype.removeStoredMark = function removeStoredMark(mark) {
    return this.ensureMarks(mark.removeFromSet(this.storedMarks || this.selection.$head.marks()));
  };

  Object.defineProperties(Transaction.prototype, prototypeAccessors);

  return Transaction;
}(Transform);
exports.Transaction = Transaction;

},{"prosemirror-model":7,"prosemirror-transform":19}],19:[function(require,module,exports){
;var assign;
assign = require("./transform"), exports.Transform = assign.Transform, exports.TransformError = assign.TransformError;var assign$1;
assign$1 = require("./step"), exports.Step = assign$1.Step, exports.StepResult = assign$1.StepResult;var assign$2;
assign$2 = require("./structure"), exports.joinPoint = assign$2.joinPoint, exports.canJoin = assign$2.canJoin, exports.canSplit = assign$2.canSplit, exports.insertPoint = assign$2.insertPoint, exports.liftTarget = assign$2.liftTarget, exports.findWrapping = assign$2.findWrapping;var assign$3;
assign$3 = require("./map"), exports.StepMap = assign$3.StepMap, exports.MapResult = assign$3.MapResult, exports.Mapping = assign$3.Mapping;var assign$4;
assign$4 = require("./mark_step"), exports.AddMarkStep = assign$4.AddMarkStep, exports.RemoveMarkStep = assign$4.RemoveMarkStep;var assign$5;
assign$5 = require("./replace_step"), exports.ReplaceStep = assign$5.ReplaceStep, exports.ReplaceAroundStep = assign$5.ReplaceAroundStep;
require("./mark");var assign$6;
assign$6 = require("./replace"), exports.replaceStep = assign$6.replaceStep;

},{"./map":20,"./mark":21,"./mark_step":22,"./replace":23,"./replace_step":24,"./step":25,"./structure":26,"./transform":27}],20:[function(require,module,exports){
// Mappable:: interface
// There are several things that positions can be mapped through.
// We'll denote those as 'mappable'.
//
//   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,
//   and when to consider the position to be deleted.
//
//   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.

// 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 marked ranges. 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;
};
exports.MapResult = MapResult;

// ::- 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. This class implements [`Mappable`](#transform.Mappable).
var StepMap = function StepMap(ranges, inverted) {
  if (inverted === void 0) inverted = false;

  this.ranges = ranges;
  this.inverted = inverted;
};

StepMap.prototype.recover = function recover(value) {
  var this$1 = this;

  var diff = 0,
      index = recoverIndex(value);
  if (!this.inverted) {
    for (var i = 0; i < index; i++) {
      diff += this$1.ranges[i * 3 + 2] - this$1.ranges[i * 3 + 1];
    }
  }
  return this.ranges[index * 3] + diff + recoverOffset(value);
};

// :: (number, ?number) → MapResult
// Map the given position through this map. The `assoc` parameter can
// be used to control what happens when the transform inserted
// content at (or around) this position—if `assoc` is negative, the a
// position before the inserted content will be returned, if it is
// positive, a position after the insertion is returned.
StepMap.prototype.mapResult = function mapResult(pos, assoc) {
  return this._map(pos, assoc, false);
};

// :: (number, ?number) → number
// Map the given position through this map, returning only the
// mapped position.
StepMap.prototype.map = function map(pos, assoc) {
  return this._map(pos, assoc, true);
};

StepMap.prototype._map = function _map(pos, assoc, simple) {
  var this$1 = this;

  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$1.ranges[i] - (this$1.inverted ? diff : 0);
    if (start > pos) {
      break;
    }
    var oldSize = this$1.ranges[i + oldIndex],
        newSize = this$1.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 = 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 this$1 = this;

  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$1.ranges[i] - (this$1.inverted ? diff : 0);
    if (start > pos) {
      break;
    }
    var oldSize = this$1.ranges[i + oldIndex],
        end = start + oldSize;
    if (pos <= end && i == index * 3) {
      return true;
    }
    diff += this$1.ranges[i + newIndex] - oldSize;
  }
  return false;
};

// :: ((oldStart: number, oldEnd: number, newStart: number, newEnd: number))
// Calls the given function on each of the changed ranges denoted by
// this map.
StepMap.prototype.forEach = function forEach(f) {
  var this$1 = this;

  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$1.ranges[i],
        oldStart = start - (this$1.inverted ? diff : 0),
        newStart = start + (this$1.inverted ? 0 : diff);
    var oldSize = this$1.ranges[i + oldIndex],
        newSize = this$1.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);
};
exports.StepMap = StepMap;

StepMap.empty = new StepMap([]);

// ::- 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’ steps for collaboration or history management.) This
// class implements [`Mappable`](#transform.Mappable).
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 positions 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);
};

Mapping.prototype.getMirror = function getMirror(n) {
  var this$1 = this;

  if (this.mirror) {
    for (var i = 0; i < this.mirror.length; i++) {
      if (this$1.mirror[i] == n) {
        return this$1.mirror[i + (i % 2 ? -1 : 1)];
      }
    }
  }
};

Mapping.prototype.setMirror = function setMirror(n, m) {
  if (!this.mirror) {
    this.mirror = [];
  }
  this.mirror.push(n, m);
};

// :: (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) {
  var this$1 = this;

  for (var i = 0, startSize = this.maps.length; i < mapping.maps.length; i++) {
    var mirr = mapping.getMirror(i);
    this$1.appendMap(mapping.maps[i], mirr != null && mirr < i ? startSize + mirr : null);
  }
};

// :: (Mapping)
// Append the inverse of the given mapping to this one.
Mapping.prototype.appendMappingInverted = function appendMappingInverted(mapping) {
  var this$1 = this;

  for (var i = mapping.maps.length - 1, totalSize = this.maps.length + mapping.maps.length; i >= 0; i--) {
    var mirr = mapping.getMirror(i);
    this$1.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) {
  var this$1 = this;

  if (this.mirror) {
    return this._map(pos, assoc, true);
  }
  for (var i = this.from; i < this.to; i++) {
    pos = this$1.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) {
  return this._map(pos, assoc, false);
};

Mapping.prototype._map = function _map(pos, assoc, simple) {
  var this$1 = this;

  var deleted = false,
      recoverables = null;

  for (var i = this.from; i < this.to; i++) {
    var map = this$1.maps[i],
        rec = recoverables && recoverables[i];
    if (rec != null && map.touches(pos, rec)) {
      pos = map.recover(rec);
      continue;
    }

    var result = map.mapResult(pos, assoc);
    if (result.recover != null) {
      var corr = this$1.getMirror(i);
      if (corr != null && corr > i && corr < this$1.to) {
        if (result.deleted) {
          i = corr;
          pos = this$1.maps[corr].recover(result.recover);
          continue;
        } else {
          ;(recoverables || (recoverables = Object.create(null)))[corr] = result.recover;
        }
      }
    }

    if (result.deleted) {
      deleted = true;
    }
    pos = result.pos;
  }

  return simple ? pos : new MapResult(pos, deleted);
};
exports.Mapping = Mapping;

},{}],21:[function(require,module,exports){
var ref = require("prosemirror-model");
var MarkType = ref.MarkType;
var Slice = ref.Slice;
var Fragment = ref.Fragment;

var ref$1 = require("./transform");
var Transform = ref$1.Transform;
var ref$2 = require("./mark_step");
var AddMarkStep = ref$2.AddMarkStep;
var RemoveMarkStep = ref$2.RemoveMarkStep;
var ref$3 = require("./replace_step");
var ReplaceStep = ref$3.ReplaceStep;

// :: (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 = this;

  var removed = [],
      added = [],
      removing = null,
      adding = null;
  this.doc.nodesBetween(from, to, function (node, pos, parent, index) {
    if (!node.isInline) {
      return;
    }
    var marks = node.marks;
    if (!mark.isInSet(marks) && parent.contentMatchAt(index).allowsMark(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.step(s);
  });
  added.forEach(function (s) {
    return this$1.step(s);
  });
  return this;
};

// :: (number, number, ?union<Mark, MarkType>) → this
// Remove the given mark, or all marks of the given type, from inline
// nodes between `from` and `to`.
Transform.prototype.removeMark = function (from, to, mark) {
  var this$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 found = mark.isInSet(node.marks);
      if (found) {
        toRemove = [found];
      }
    } 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.step(new RemoveMarkStep(m.from, m.to, m.style));
  });
  return this;
};

// :: (number, number) → this
// Remove all marks and non-text inline nodes from the given range.
Transform.prototype.clearMarkup = function (from, to) {
  var this$1 = this;

  var delSteps = []; // Must be accumulated and applied in inverse order
  this.doc.nodesBetween(from, to, function (node, pos) {
    if (!node.isInline) {
      return;
    }
    if (!node.type.isText) {
      delSteps.push(new ReplaceStep(pos, pos + node.nodeSize, Slice.empty));
      return;
    }
    for (var i = 0; i < node.marks.length; i++) {
      this$1.step(new RemoveMarkStep(Math.max(pos, from), Math.min(pos + node.nodeSize, to), node.marks[i]));
    }
  });
  for (var i = delSteps.length - 1; i >= 0; i--) {
    this$1.step(delSteps[i]);
  }
  return this;
};

Transform.prototype.clearNonMatching = function (pos, match) {
  var this$1 = this;

  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 (!match.allowsMark(child.marks[j])) {
          this$1.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$1.step(delSteps[i$1]);
  }
  return this;
};

},{"./mark_step":22,"./replace_step":24,"./transform":27,"prosemirror-model":7}],22:[function(require,module,exports){
var ref = require("prosemirror-model");
var Fragment = ref.Fragment;
var Slice = ref.Slice;
var ref$1 = require("./step");
var Step = ref$1.Step;
var StepResult = ref$1.StepResult;

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 = function (Step) {
  function AddMarkStep(from, to, mark) {
    Step.call(this);
    this.from = from;
    this.to = to;
    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 = 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, index) {
      if (!parent.contentMatchAt(index).allowsMark(this$1.mark.type)) {
        return node;
      }
      return node.mark(this$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.offset = function offset(n) {
    return new AddMarkStep(this.from + n, this.to + n, this.mark);
  };

  AddMarkStep.fromJSON = function fromJSON(schema, json) {
    return new AddMarkStep(json.from, json.to, schema.markFromJSON(json.mark));
  };

  return AddMarkStep;
}(Step);
exports.AddMarkStep = AddMarkStep;

Step.jsonID("addMark", AddMarkStep);

// ::- Remove a mark from all inline content between two positions.
var RemoveMarkStep = function (Step) {
  function RemoveMarkStep(from, to, mark) {
    Step.call(this);
    this.from = from;
    this.to = to;
    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 = this;

    var oldSlice = doc.slice(this.from, this.to);
    var slice = new Slice(mapFragment(oldSlice.content, function (node) {
      return node.mark(this$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.offset = function offset(n) {
    return new RemoveMarkStep(this.from + n, this.to + n, this.mark);
  };

  RemoveMarkStep.fromJSON = function fromJSON(schema, json) {
    return new RemoveMarkStep(json.from, json.to, schema.markFromJSON(json.mark));
  };

  return RemoveMarkStep;
}(Step);
exports.RemoveMarkStep = RemoveMarkStep;

Step.jsonID("removeMark", RemoveMarkStep);

},{"./step":25,"prosemirror-model":7}],23:[function(require,module,exports){
var ref = require("prosemirror-model");
var Fragment = ref.Fragment;
var Slice = ref.Slice;

var ref$1 = require("./replace_step");
var ReplaceStep = ref$1.ReplaceStep;
var ReplaceAroundStep = ref$1.ReplaceAroundStep;
var ref$2 = require("./transform");
var Transform = ref$2.Transform;
var ref$3 = require("./structure");
var insertPoint = ref$3.insertPoint;

// :: (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](#model.NodeSpec.defining), or
// including an open parent node from the slice that _is_ marked as
// [defining](#model.NodeSpec.defining).
//
// 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) {
  var this$1 = this;

  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 canExpand = coveredDepths($from, this.doc.resolve(to)),
      preferredExpand = 0;
  if (canExpand[canExpand.length - 1] == 0) {
    canExpand.pop();
  }
  canExpand.unshift($from.depth + 1);
  for (var d = $from.depth; d > 0; d--) {
    if ($from.node(d).type.spec.defining) {
      break;
    }
    var found = canExpand.indexOf(d, 1);
    if (found > -1) {
      preferredExpand = found;
    }
  }

  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 if the node directly above openStart, or the node above
  // that separated only by a non-defining textblock node, is defining.
  if (preferredDepth > 0 && leftNodes[preferredDepth - 1].type.spec.defining) {
    preferredDepth -= 1;
  } else if (preferredDepth >= 2 && leftNodes[preferredDepth - 1].isTextblock && leftNodes[preferredDepth - 2].type.spec.defining) {
    preferredDepth -= 2;
  }

  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 < canExpand.length; i$1++) {
      // Loop over possible expansion levels, starting with the
      // preferred one
      var expandDepth = canExpand[(i$1 + preferredExpand) % canExpand.length];
      var parent = $from.node(expandDepth - 1),
          index = $from.index(expandDepth - 1);
      if (parent.canReplaceWith(index, index, insert.type, insert.attrs, insert.marks)) {
        return this$1.replace($from.before(expandDepth), expandDepth > $from.depth ? to : $to.after(expandDepth), new Slice(closeFragment(slice.content, 0, slice.openStart, openDepth), openDepth, slice.openEnd));
      }
    }
  }

  return this.replace(from, to, slice);
};

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) {
    fragment = parent.contentMatchAt(0).fillBefore(fragment).append(fragment);
  }
  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, node.attrs);
    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).contentMatchAt(0).validEnd()) {
      from = $from.start(depth);
      to = $to.end(depth);
      break;
    }
    if (depth > 0 && (last || $from.node(depth - 1).canReplace($from.index(depth - 1), $to.indexAfter(depth - 1)))) {
      from = $from.before(depth);
      to = $to.after(depth);
      break;
    }
  }
  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)) {
      result.push(d);
    }
  }
  return result;
}

// :: (number, number) → this
// Delete the content between the given positions.
Transform.prototype.delete = function (from, to) {
  return this.replace(from, to, Slice.empty);
};

// :: (Node, number, ?number, ?Slice) → ?Step
// "Fit" a slice into a given position in the document, producing a
// [step](#transform.Step) that inserts it.
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);
  }
  var placed = placeSlice($from, slice);

  var fittedLeft = fitLeft($from, placed);
  var fitted = fitRight($from, $to, fittedLeft);
  if (!fitted) {
    return null;
  }
  if (fittedLeft.size != fitted.size && canMoveText($from, $to, fittedLeft)) {
    var d = $to.depth,
        after = $to.after(d);
    while (d > 1 && after == $to.end(--d)) {
      ++after;
    }
    var fittedAfter = fitRight($from, doc.resolve(after), fittedLeft);
    if (fittedAfter) {
      return new ReplaceAroundStep(from, after, to, $to.end(), fittedAfter, fittedLeft.size);
    }
  }
  return new ReplaceStep(from, to, fitted);
}
exports.replaceStep = replaceStep;

// :: (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, 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 fitLeftInner($from, depth, placed, placedBelow) {
  var content = Fragment.empty,
      openEnd = 0,
      placedHere = placed[depth];
  if ($from.depth > depth) {
    var inner = fitLeftInner($from, depth + 1, placed, placedBelow || placedHere);
    openEnd = inner.openEnd + 1;
    content = Fragment.from($from.node(depth + 1).copy(inner.content));
  }

  if (placedHere) {
    content = content.append(placedHere.content);
    openEnd = placedHere.openEnd;
  }
  if (placedBelow) {
    content = content.append($from.node(depth).contentMatchAt($from.indexAfter(depth)).fillBefore(Fragment.empty, true));
    openEnd = 0;
  }

  return { content: content, openEnd: openEnd };
}

function fitLeft($from, placed) {
  var ref = fitLeftInner($from, 0, placed, false);
  var content = ref.content;
  var openEnd = ref.openEnd;
  return new Slice(content, $from.depth, openEnd || 0);
}

function fitRightJoin(content, parent, $from, $to, depth, openStart, openEnd) {
  var match,
      count = content.childCount,
      matchCount = count - (openEnd > 0 ? 1 : 0);
  if (openStart < 0) {
    match = parent.contentMatchAt(matchCount);
  } else if (count == 1 && openEnd > 0) {
    match = $from.node(depth).contentMatchAt(openStart ? $from.index(depth) : $from.indexAfter(depth));
  } else {
    match = $from.node(depth).contentMatchAt($from.indexAfter(depth)).matchFragment(content, count > 0 && openStart ? 1 : 0, matchCount);
  }

  var toNode = $to.node(depth);
  if (openEnd > 0 && depth < $to.depth) {
    var after = toNode.content.cutByIndex($to.indexAfter(depth)).addToStart(content.lastChild);
    var joinable$1 = match.fillBefore(after, true);
    // Can't insert content if there's a single node stretched across this gap
    if (joinable$1 && joinable$1.size && openStart > 0 && count == 1) {
      joinable$1 = null;
    }

    if (joinable$1) {
      var inner = fitRightJoin(content.lastChild.content, content.lastChild, $from, $to, depth + 1, count == 1 ? openStart - 1 : -1, openEnd - 1);
      if (inner) {
        var last = content.lastChild.copy(inner);
        if (joinable$1.size) {
          return content.cutByIndex(0, count - 1).append(joinable$1).addToEnd(last);
        } else {
          return content.replaceChild(count - 1, last);
        }
      }
    }
  }
  if (openEnd > 0) {
    match = match.matchNode(count == 1 && openStart > 0 ? $from.node(depth + 1) : content.lastChild);
  }

  // If we're here, the next level can't be joined, so we see what
  // happens if we leave it open.
  var toIndex = $to.index(depth);
  if (toIndex == toNode.childCount && !toNode.type.compatibleContent(parent.type)) {
    return null;
  }
  var joinable = match.fillBefore(toNode.content, true, toIndex);
  if (!joinable) {
    return null;
  }

  if (openEnd > 0) {
    var closed = fitRightClosed(content.lastChild, openEnd - 1, $from, depth + 1, count == 1 ? openStart - 1 : -1);
    content = content.replaceChild(count - 1, closed);
  }
  content = content.append(joinable);
  if ($to.depth > depth) {
    content = content.addToEnd(fitRightSeparate($to, depth + 1));
  }
  return content;
}

function fitRightClosed(node, openEnd, $from, depth, openStart) {
  var match,
      content = node.content,
      count = content.childCount;
  if (openStart >= 0) {
    match = $from.node(depth).contentMatchAt($from.indexAfter(depth)).matchFragment(content, openStart > 0 ? 1 : 0, count);
  } else {
    match = node.contentMatchAt(count);
  }

  if (openEnd > 0) {
    var closed = fitRightClosed(content.lastChild, openEnd - 1, $from, depth + 1, count == 1 ? openStart - 1 : -1);
    content = content.replaceChild(count - 1, closed);
  }

  return node.copy(content.append(match.fillBefore(Fragment.empty, true)));
}

function fitRightSeparate($to, depth) {
  var node = $to.node(depth);
  var fill = node.contentMatchAt(0).fillBefore(node.content, true, $to.index(depth));
  if ($to.depth > depth) {
    fill = fill.addToEnd(fitRightSeparate($to, depth + 1));
  }
  return node.copy(fill);
}

function normalizeSlice(content, openStart, openEnd) {
  while (openStart > 0 && openEnd > 0 && content.childCount == 1) {
    content = content.firstChild.content;
    openStart--;
    openEnd--;
  }
  return new Slice(content, openStart, openEnd);
}

// : (ResolvedPos, ResolvedPos, number, Slice) → Slice
function fitRight($from, $to, slice) {
  var fitted = fitRightJoin(slice.content, $from.node(0), $from, $to, 0, slice.openStart, slice.openEnd);
  if (!fitted) {
    return null;
  }
  return normalizeSlice(fitted, slice.openStart, $to.depth);
}

function fitsTrivially($from, $to, slice) {
  return !slice.openStart && !slice.openEnd && $from.start() == $to.start() && $from.parent.canReplace($from.index(), $to.index(), slice.content);
}

function canMoveText($from, $to, slice) {
  if (!$to.parent.isTextblock) {
    return false;
  }

  var match;
  if (!slice.openEnd) {
    var parent = $from.node($from.depth - (slice.openStart - slice.openEnd));
    if (!parent.isTextblock) {
      return false;
    }
    match = parent.contentMatchAt(parent.childCount);
    if (slice.size) {
      match = match.matchFragment(slice.content, slice.openStart ? 1 : 0);
    }
  } else {
    var parent$1 = nodeRight(slice.content, slice.openEnd);
    if (!parent$1.isTextblock) {
      return false;
    }
    match = parent$1.contentMatchAt(parent$1.childCount);
  }
  match = match.matchFragment($to.parent.content, $to.index());
  return match && match.validEnd();
}

// 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").
//
// So placeSlice splits up a slice into a number of sub-slices,
// along with information on where they can be placed on the given
// left-side edge. It works by walking the open side of the slice,
// from the inside out, and trying to find a landing spot for each
// element, by simultaneously scanning over the gap side. When no
// place is found for an open node's content, it is left in that node.
//
// If the outer content can't be placed, a set of wrapper nodes is
// made up for it (by rooting it in the document node type using
// findWrapping), and the algorithm continues to iterate over those.
// This is guaranteed to find a fit, since both stacks now start with
// the same node type (doc).

function nodeLeft(content, depth) {
  for (var i = 1; i < depth; i++) {
    content = content.firstChild.content;
  }
  return content.firstChild;
}

function nodeRight(content, depth) {
  for (var i = 1; i < depth; i++) {
    content = content.lastChild.content;
  }
  return content.lastChild;
}

// : (ResolvedPos, Slice) → [{content: Fragment, openEnd: number, depth: number}]
function placeSlice($from, slice) {
  var dFrom = $from.depth,
      unplaced = null;
  var placed = [],
      parents = null;

  // Loop over the open side of the slice, trying to find a place for
  // each open fragment.
  for (var dSlice = slice.openStart;; --dSlice) {
    // Get the components of the node at this level
    var curType = void 0,
        curAttrs = void 0,
        curFragment = void 0;
    if (dSlice >= 0) {
      if (dSlice > 0) {
        // Inside slice
        ;var assign;
        assign = nodeLeft(slice.content, dSlice), curType = assign.type, curAttrs = assign.attrs, curFragment = assign.content;
      } else if (dSlice == 0) {
        // Top of slice
        curFragment = slice.content;
      }
      if (dSlice < slice.openStart) {
        curFragment = curFragment.cut(curFragment.firstChild.nodeSize);
      }
    } else {
      // Outside slice, in generated wrappers (see below)
      curFragment = Fragment.empty;
      var parent = parents[parents.length + dSlice - 1];
      curType = parent.type;
      curAttrs = parent.attrs;
    }
    // If the last iteration left unplaced content, include it in the fragment
    if (unplaced) {
      curFragment = curFragment.addToStart(unplaced);
    }

    // If there's nothing left to place, we're done
    if (curFragment.size == 0 && dSlice <= 0) {
      break;
    }

    // This will go through the positions in $from, down from dFrom,
    // to find a fit
    var found = findPlacement(curFragment, $from, dFrom, placed);
    if (found && unneccesaryFallthrough($from, dFrom, found.depth, slice, dSlice)) {
      found = null;
    }

    if (found) {
      // If there was a fit, store it, and consider this content placed
      if (found.fragment.size > 0) {
        placed[found.depth] = {
          content: found.fragment,
          openEnd: endOfContent(slice, dSlice) ? slice.openEnd - dSlice : 0,
          depth: found.depth
        };
      }
      // If that was the last of the content, we're done
      if (dSlice <= 0) {
        break;
      }
      unplaced = null;
      dFrom = found.depth - (curType == $from.node(found.depth).type ? 1 : 0);
    } else {
      if (dSlice == 0) {
        // This is the top of the slice, and we haven't found a place to insert it.
        var top = $from.node(0);
        // Try to find a wrapping that makes its first child fit in the top node.
        var wrap = top.contentMatchAt($from.index(0)).findWrappingFor(curFragment.firstChild);
        // If no such thing exists, give up.
        if (!wrap || wrap.length == 0) {
          break;
        }
        var last = wrap[wrap.length - 1];
        // Check that the fragment actually fits in the wrapping.
        if (!last.type.contentExpr.matches(last.attrs, curFragment)) {
          break;
        }
        // Store the result for subsequent iterations.
        parents = [{ type: top.type, attrs: top.attrs }].concat(wrap);var assign$1;
        assign$1 = last, curType = assign$1.type, curAttrs = assign$1.attrs;
      }
      if (curFragment.size) {
        curFragment = curType.contentExpr.start(curAttrs).fillBefore(curFragment, true).append(curFragment);
        unplaced = curType.create(curAttrs, curFragment);
      } else {
        unplaced = null;
      }
    }
  }

  return placed;
}

function endOfContent(slice, depth) {
  for (var i = 0, content = slice.content; i < depth; i++) {
    if (content.childCount > 1) {
      return false;
    }
    content = content.firstChild.content;
  }
  return true;
}

function findPlacement(fragment, $from, start, placed) {
  var hasMarks = false;
  for (var i = 0; i < fragment.childCount; i++) {
    if (fragment.child(i).marks.length) {
      hasMarks = true;
    }
  }
  for (var d = start; d >= 0; d--) {
    var startMatch = $from.node(d).contentMatchAt($from.indexAfter(d));
    var existing = placed[d];
    if (existing) {
      startMatch = startMatch.matchFragment(existing.content);
    }
    var match = startMatch.fillBefore(fragment);
    if (match) {
      return { depth: d, fragment: (existing ? existing.content.append(match) : match).append(fragment) };
    }
    if (hasMarks) {
      var stripped = matchStrippingMarks(startMatch, fragment);
      if (stripped) {
        return { depth: d, fragment: existing ? existing.content.append(stripped) : stripped };
      }
    }
  }
}

function matchStrippingMarks(match, fragment) {
  var newNodes = [];
  for (var i = 0; i < fragment.childCount; i++) {
    var node = fragment.child(i),
        stripped = node.mark(node.marks.filter(function (m) {
      return match.allowsMark(m.type);
    }));
    match = match.matchNode(stripped);
    if (!match) {
      return null;
    }
    newNodes.push(stripped);
  }
  return Fragment.from(newNodes);
}

function unneccesaryFallthrough($from, dFrom, dFound, slice, dSlice) {
  if (dSlice < 1) {
    return false;
  }
  for (; dFrom > dFound; dFrom--) {
    var here = $from.node(dFrom).contentMatchAt($from.indexAfter(dFrom));
    for (var d = dSlice - 1; d >= 0; d--) {
      if (here.matchNode(nodeLeft(slice.content, d))) {
        return true;
      }
    }
  }
  return false;
}

},{"./replace_step":24,"./structure":26,"./transform":27,"prosemirror-model":7}],24:[function(require,module,exports){
var ref = require("prosemirror-model");
var Slice = ref.Slice;

var ref$1 = require("./step");
var Step = ref$1.Step;
var StepResult = ref$1.StepResult;
var ref$2 = require("./map");
var StepMap = ref$2.StepMap;

// ::- Replace a part of the document with a slice of new content.
var ReplaceStep = function (Step) {
  function ReplaceStep(from, to, slice, structure) {
    Step.call(this);
    this.from = from;
    this.to = to;
    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.prototype.offset = function offset(n) {
    return new ReplaceStep(this.from + n, this.to + n, this.slice, this.structure);
  };

  ReplaceStep.fromJSON = function fromJSON(schema, json) {
    return new ReplaceStep(json.from, json.to, Slice.fromJSON(schema, json.slice), !!json.structure);
  };

  return ReplaceStep;
}(Step);
exports.ReplaceStep = ReplaceStep;

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 = function (Step) {
  function ReplaceAroundStep(from, to, gapFrom, gapTo, slice, insert, structure) {
    Step.call(this);
    this.from = from;
    this.to = to;
    this.gapFrom = gapFrom;
    this.gapTo = gapTo;
    this.slice = slice;
    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.toJSON = function toJSON() {
    var json = { stepType: "replaceAround", from: this.from, to: this.to,
      gapFrom: this.gapFrom, gapTo: this.gapTo, slice: this.slice.toJSON() };
    if (this.structure) {
      json.structure = true;
    }
    return true;
  };

  ReplaceAroundStep.prototype.offset = function offset(n) {
    return new ReplaceAroundStep(this.from + n, this.to + n, this.gapFrom + n, this.gapTo + n, this.slice, this.insert, this.structure);
  };

  ReplaceAroundStep.fromJSON = function fromJSON(schema, json) {
    return new ReplaceAroundStep(json.from, json.to, json.gapFrom, json.gapTo, Slice.fromJSON(schema, json.slice), json.insert, !!json.structure);
  };

  return ReplaceAroundStep;
}(Step);
exports.ReplaceAroundStep = ReplaceAroundStep;

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

},{"./map":20,"./step":25,"prosemirror-model":7}],25:[function(require,module,exports){
var ref = require("prosemirror-model");
var ReplaceError = ref.ReplaceError;

var ref$1 = require("./map");
var StepMap = ref$1.StepMap;

function mustOverride() {
  throw new Error("Override me");
}

var stepsByID = Object.create(null);

// ::- A step object wraps an atomic operation. It generally applies
// only to the document it was created for, since the positions
// associated with 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.
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;
};

// :: (n: number) → Step
// Returns a copy of this step in which all positions have `n` added
// to them. The main use for this is to take a step in one document,
// and make it apply to a sub-document, or a larger document that
// the original document is a part of.
Step.prototype.offset = function offset(_n) {
  return mustOverride();
};

// :: () → Object
// Create a JSON-serializeable representation of this step. By
// default, it'll create an object with the step's [JSON
// id](#transform.Step^jsonID), and each of the steps's own properties,
// automatically calling `toJSON` on the property values that have
// such a method.
Step.prototype.toJSON = function toJSON() {
  var this$1 = this;

  var obj = { stepType: this.jsonID };
  for (var prop in this$1) {
    if (this$1.hasOwnProperty(prop)) {
      var val = this$1[prop];
      obj[prop] = val && val.toJSON ? val.toJSON() : val;
    }
  }
  return obj;
};

// :: (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) {
  return stepsByID[json.stepType].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;
};
exports.Step = Step;

// ::- 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;
  }
};
exports.StepResult = StepResult;

},{"./map":20,"prosemirror-model":7}],26:[function(require,module,exports){
var ref = require("prosemirror-model");
var Slice = ref.Slice;
var Fragment = ref.Fragment;

var ref$1 = require("./transform");
var Transform = ref$1.Transform;
var ref$2 = require("./replace_step");
var ReplaceStep = ref$2.ReplaceStep;
var ReplaceAroundStep = ref$2.ReplaceAroundStep;

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;
    }
  }
}
exports.liftTarget = liftTarget;

// :: (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` to compute `target`, in order to be 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) → ?[{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.
function findWrapping(range, nodeType, attrs, innerRange) {
  if (innerRange === void 0) innerRange = range;

  var wrap = { type: nodeType, attrs: attrs };
  var around = findWrappingOutside(range, wrap);
  var inner = around && findWrappingInside(innerRange, wrap);
  if (!inner) {
    return null;
  }
  return around.concat(wrap).concat(inner);
}
exports.findWrapping = findWrapping;

function findWrappingOutside(range, wrap) {
  var parent = range.parent;
  var startIndex = range.startIndex;
  var endIndex = range.endIndex;
  var around = parent.contentMatchAt(startIndex).findWrapping(wrap.type, wrap.attrs);
  if (!around) {
    return null;
  }
  var outer = around.length ? around[0] : wrap;
  if (!parent.canReplaceWith(startIndex, endIndex, outer.type, outer.attrs)) {
    return null;
  }
  return around;
}

function findWrappingInside(range, wrap) {
  var parent = range.parent;
  var startIndex = range.startIndex;
  var endIndex = range.endIndex;
  var inner = parent.child(startIndex);
  var inside = wrap.type.contentExpr.start(wrap.attrs).findWrappingFor(inner);
  if (!inside) {
    return null;
  }
  var last = inside.length ? inside[inside.length - 1] : wrap;
  var innerMatch = last.type.contentExpr.start(last.attrs);
  for (var i = startIndex; i < endIndex; i++) {
    innerMatch = innerMatch && innerMatch.matchNode(parent.child(i));
  }
  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.prototype.wrap = function (range, wrappers) {
  var content = Fragment.empty;
  for (var i = wrappers.length - 1; i >= 0; i--) {
    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 = 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)) {
      // Ensure all markup that isn't allowed in the new node type is cleared
      this$1.clearNonMatching(this$1.mapping.slice(mapFrom).map(pos, 1), type.contentExpr.start(attrs));
      var mapping = this$1.mapping.slice(mapFrom);
      var startM = mapping.map(pos, 1),
          endM = mapping.map(pos + node.nodeSize, 1);
      this$1.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new Slice(Fragment.from(type.create(attrs)), 0, 0), 1, true));
      return false;
    }
  });
  return this;
};

// :: (number, ?NodeType, ?Object, ?[Mark]) → this
// Change the type and attributes of the node after `pos`.
Transform.prototype.setNodeType = 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, attrs)) {
    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.canReplace($pos.index(), $pos.parent.childCount) || !innerType.type.validContent($pos.parent.content.cutByIndex($pos.index(), $pos.parent.childCount), innerType.attrs)) {
    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);
    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, after.attrs)) {
      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, baseType ? baseType.attrs : $pos.node(base + 1).attrs);
}
exports.canSplit = canSplit;

// :: (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);
}
exports.canJoin = canJoin;

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;
    if (d == $pos.depth) {
      before = $pos.nodeBefore;
      after = $pos.nodeAfter;
    } else if (dir > 0) {
      before = $pos.node(d + 1);
      after = $pos.node(d).maybeChild($pos.index(d) + 1);
    } else {
      before = $pos.node(d).maybeChild($pos.index(d) - 1);
      after = $pos.node(d + 1);
    }
    if (before && !before.isTextblock && joinable(before, after)) {
      return pos;
    }
    if (d == 0) {
      break;
    }
    pos = dir < 0 ? $pos.before(d) : $pos.after(d);
  }
}
exports.joinPoint = joinPoint;

// :: (number, ?number, ?bool) → 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, ?Object) → ?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, attrs) {
  var $pos = doc.resolve(pos);
  if ($pos.parent.canReplaceWith($pos.index(), $pos.index(), nodeType, attrs)) {
    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, attrs)) {
        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, attrs)) {
        return $pos.after(d$1 + 1);
      }
      if (index$1 < $pos.node(d$1).childCount) {
        return null;
      }
    }
  }
}
exports.insertPoint = insertPoint;

},{"./replace_step":24,"./transform":27,"prosemirror-model":7}],27:[function(require,module,exports){
var ref = require("./map");
var Mapping = ref.Mapping;

var TransformError = function (Error) {
  function TransformError(message) {
    Error.call(this, message);
  }

  if (Error) TransformError.__proto__ = Error;
  TransformError.prototype = Object.create(Error && Error.prototype);
  TransformError.prototype.constructor = TransformError;

  var prototypeAccessors = { name: {} };
  prototypeAccessors.name.get = function () {
    return "TransformError";
  };

  Object.defineProperties(TransformError.prototype, prototypeAccessors);

  return TransformError;
}(Error);
exports.TransformError = TransformError;

// ::- Abstraction to build up and track such an array of
// [steps](#transform.Step).
//
// The high-level 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: {}, docChanged: {} };

// :: Node The document at the start of the transformation.
prototypeAccessors$1.before.get = function () {
  return this.docs.length ? this.docs[0] : this.doc;
};

// :: (step: Step) → this
// Apply a new step in this transformation, 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 this transaction changes the document.
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);
exports.Transform = Transform;

},{"./map":20}]},{},[14]);