{"version":3,"sources":["webpack:///./node_modules/prosemirror-keymap/dist/index.es.js","webpack:///./node_modules/prosemirror-history/dist/index.es.js","webpack:///./node_modules/prosemirror-inputrules/dist/index.es.js"],"names":["mac","navigator","test","platform","normalizeKeyName","name","alt","ctrl","shift","meta","parts","split","result","length","i","mod","Error","normalize","map","copy","Object","create","prop","modifiers","event","altKey","ctrlKey","metaKey","shiftKey","keymap","bindings","props","handleKeyDown","keydownHandler","view","baseName","isChar","direct","state","dispatch","charCodeAt","keyCode","fromCode","withShift","max_empty_items","Branch","items","eventCount","this","cutOffEvents","n","cutPoint","forEach","item","selection","slice","prototype","popEvent","preserveItems","this$1","remap","mapFrom","end","next","get","remapping","maps","remaining","transform","tr","addAfter","addBefore","step","push","Item","maybeStep","doc","mapping","appendMap","append","reverse","concat","addTransform","histOptions","newItems","oldItems","lastItem","steps","invert","docs","merged","merge","pop","overflow","depth","DEPTH_OVERFLOW","from","to","mirrorPos","mirrorOffset","addMaps","array","rebased","rebasedTransform","rebasedCount","rebasedItems","start","Math","max","newUntil","iRebased","pos","getMirror","min","newMaps","branch","emptyItemCount","compress","count","upto","events","getMap","newItem","last","empty","other","HistoryState","done","undone","prevRanges","prevTime","applyTransaction","history","options","historyTr","getMeta","historyKey","historyState","closeHistoryKey","appended","redo","mustPreserveItems","rangesFor","mapRanges","newGroup","time","newGroupDelay","isAdjacentTo","getBookmark","docChanged","adjacent","_from","_to","ranges","histTransaction","spec","config","resolve","added","newHist","setSelection","setMeta","scrollIntoView","cachedPreserveItems","cachedPreserveItemsPlugins","plugins","historyPreserveItems","key","init","apply","hist","handleDOMEvents","beforeinput","e","handled","inputType","undo","preventDefault","getState","undoDepth","redoDepth","InputRule","match","handler","stringHandler","string","insert","offset","lastIndexOf","cutOff","insertText","MAX_MATCH","inputRules","ref","rules","plugin","prev","stored","selectionSet","handleTextInput","text","run","compositionend","setTimeout","$cursor","isInputRules","composing","$from","parent","type","code","textBefore","textBetween","parentOffset","exec","undoInputRule","undoable","toUndo","j","marks","replaceWith","schema","delete","wrappingInputRule","regexp","nodeType","getAttrs","joinPredicate","attrs","Function","$start","range","blockRange","wrapping","wrap","before","nodeBefore","join","textblockTypeInputRule","node","canReplaceWith","index","indexAfter","setBlockType"],"mappings":"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","file":"js/chunk-vendors~04bd46bb.dfa1c7fb.js","sourcesContent":["import { keyName, base } from 'w3c-keyname';\nimport { Plugin } from 'prosemirror-state';\n\n// declare global: navigator\n\nvar mac = typeof navigator != \"undefined\" ? /Mac/.test(navigator.platform) : false;\n\nfunction normalizeKeyName(name) {\n  var parts = name.split(/-(?!$)/), result = parts[parts.length - 1];\n  if (result == \"Space\") { result = \" \"; }\n  var alt, ctrl, shift, meta;\n  for (var i = 0; i < parts.length - 1; i++) {\n    var mod = parts[i];\n    if (/^(cmd|meta|m)$/i.test(mod)) { meta = true; }\n    else if (/^a(lt)?$/i.test(mod)) { alt = true; }\n    else if (/^(c|ctrl|control)$/i.test(mod)) { ctrl = true; }\n    else if (/^s(hift)?$/i.test(mod)) { shift = true; }\n    else if (/^mod$/i.test(mod)) { if (mac) { meta = true; } else { ctrl = true; } }\n    else { throw new Error(\"Unrecognized modifier name: \" + mod) }\n  }\n  if (alt) { result = \"Alt-\" + result; }\n  if (ctrl) { result = \"Ctrl-\" + result; }\n  if (meta) { result = \"Meta-\" + result; }\n  if (shift) { result = \"Shift-\" + result; }\n  return result\n}\n\nfunction normalize(map) {\n  var copy = Object.create(null);\n  for (var prop in map) { copy[normalizeKeyName(prop)] = map[prop]; }\n  return copy\n}\n\nfunction modifiers(name, event, shift) {\n  if (event.altKey) { name = \"Alt-\" + name; }\n  if (event.ctrlKey) { name = \"Ctrl-\" + name; }\n  if (event.metaKey) { name = \"Meta-\" + name; }\n  if (shift !== false && event.shiftKey) { name = \"Shift-\" + name; }\n  return name\n}\n\n// :: (Object) → Plugin\n// Create a keymap plugin for the given set of bindings.\n//\n// Bindings should map key names to [command](#commands)-style\n// functions, which will be called with `(EditorState, dispatch,\n// EditorView)` arguments, and should return true when they've handled\n// the key. Note that the view argument isn't part of the command\n// protocol, but can be used as an escape hatch if a binding needs to\n// directly interact with the UI.\n//\n// Key names may be strings like `\"Shift-Ctrl-Enter\"`—a key\n// identifier prefixed with zero or more modifiers. Key identifiers\n// are based on the strings that can appear in\n// [`KeyEvent.key`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key).\n// Use lowercase letters to refer to letter keys (or uppercase letters\n// if you want shift to be held). You may use `\"Space\"` as an alias\n// for the `\" \"` name.\n//\n// Modifiers can be given in any order. `Shift-` (or `s-`), `Alt-` (or\n// `a-`), `Ctrl-` (or `c-` or `Control-`) and `Cmd-` (or `m-` or\n// `Meta-`) are recognized. For characters that are created by holding\n// shift, the `Shift-` prefix is implied, and should not be added\n// explicitly.\n//\n// You can use `Mod-` as a shorthand for `Cmd-` on Mac and `Ctrl-` on\n// other platforms.\n//\n// You can add multiple keymap plugins to an editor. The order in\n// which they appear determines their precedence (the ones early in\n// the array get to dispatch first).\nfunction keymap(bindings) {\n  return new Plugin({props: {handleKeyDown: keydownHandler(bindings)}})\n}\n\n// :: (Object) → (view: EditorView, event: dom.Event) → bool\n// Given a set of bindings (using the same format as\n// [`keymap`](#keymap.keymap), return a [keydown\n// handler](#view.EditorProps.handleKeyDown) that handles them.\nfunction keydownHandler(bindings) {\n  var map = normalize(bindings);\n  return function(view, event) {\n    var name = keyName(event), isChar = name.length == 1 && name != \" \", baseName;\n    var direct = map[modifiers(name, event, !isChar)];\n    if (direct && direct(view.state, view.dispatch, view)) { return true }\n    if (isChar && (event.shiftKey || event.altKey || event.metaKey || name.charCodeAt(0) > 127) &&\n        (baseName = base[event.keyCode]) && baseName != name) {\n      // Try falling back to the keyCode when there's a modifier\n      // active or the character produced isn't ASCII, and our table\n      // produces a different name from the the keyCode. See #668,\n      // #1060\n      var fromCode = map[modifiers(baseName, event, true)];\n      if (fromCode && fromCode(view.state, view.dispatch, view)) { return true }\n    } else if (isChar && event.shiftKey) {\n      // Otherwise, if shift is active, also try the binding with the\n      // Shift- prefix enabled. See #997\n      var withShift = map[modifiers(name, event, true)];\n      if (withShift && withShift(view.state, view.dispatch, view)) { return true }\n    }\n    return false\n  }\n}\n\nexport { keydownHandler, keymap };\n//# sourceMappingURL=index.es.js.map\n","import RopeSequence from 'rope-sequence';\nimport { Mapping } from 'prosemirror-transform';\nimport { PluginKey, Plugin } from 'prosemirror-state';\n\n// ProseMirror's history isn't simply a way to roll back to a previous\n// state, because ProseMirror supports applying changes without adding\n// them to the history (for example during collaboration).\n//\n// To this end, each 'Branch' (one for the undo history and one for\n// the redo history) keeps an array of 'Items', which can optionally\n// hold a step (an actual undoable change), and always hold a position\n// map (which is needed to move changes below them to apply to the\n// current document).\n//\n// An item that has both a step and a selection bookmark is the start\n// of an 'event' — a group of changes that will be undone or redone at\n// once. (It stores only the bookmark, since that way we don't have to\n// provide a document until the selection is actually applied, which\n// is useful when compressing.)\n\n// Used to schedule history compression\nvar max_empty_items = 500;\n\nvar Branch = function Branch(items, eventCount) {\n  this.items = items;\n  this.eventCount = eventCount;\n};\n\n// : (EditorState, bool) → ?{transform: Transform, selection: ?SelectionBookmark, remaining: Branch}\n// Pop the latest event off the branch's history and apply it\n// to a document transform.\nBranch.prototype.popEvent = function popEvent (state, preserveItems) {\n    var this$1 = this;\n\n  if (this.eventCount == 0) { return null }\n\n  var end = this.items.length;\n  for (;; end--) {\n    var next = this.items.get(end - 1);\n    if (next.selection) { --end; break }\n  }\n\n  var remap, mapFrom;\n  if (preserveItems) {\n    remap = this.remapping(end, this.items.length);\n    mapFrom = remap.maps.length;\n  }\n  var transform = state.tr;\n  var selection, remaining;\n  var addAfter = [], addBefore = [];\n\n  this.items.forEach(function (item, i) {\n    if (!item.step) {\n      if (!remap) {\n        remap = this$1.remapping(end, i + 1);\n        mapFrom = remap.maps.length;\n      }\n      mapFrom--;\n      addBefore.push(item);\n      return\n    }\n\n    if (remap) {\n      addBefore.push(new Item(item.map));\n      var step = item.step.map(remap.slice(mapFrom)), map;\n\n      if (step && transform.maybeStep(step).doc) {\n        map = transform.mapping.maps[transform.mapping.maps.length - 1];\n        addAfter.push(new Item(map, null, null, addAfter.length + addBefore.length));\n      }\n      mapFrom--;\n      if (map) { remap.appendMap(map, mapFrom); }\n    } else {\n      transform.maybeStep(item.step);\n    }\n\n    if (item.selection) {\n      selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;\n      remaining = new Branch(this$1.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), this$1.eventCount - 1);\n      return false\n    }\n  }, this.items.length, 0);\n\n  return {remaining: remaining, transform: transform, selection: selection}\n};\n\n// : (Transform, ?SelectionBookmark, Object) → Branch\n// Create a new branch with the given transform added.\nBranch.prototype.addTransform = function addTransform (transform, selection, histOptions, preserveItems) {\n  var newItems = [], eventCount = this.eventCount;\n  var oldItems = this.items, lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;\n\n  for (var i = 0; i < transform.steps.length; i++) {\n    var step = transform.steps[i].invert(transform.docs[i]);\n    var item = new Item(transform.mapping.maps[i], step, selection), merged = (void 0);\n    if (merged = lastItem && lastItem.merge(item)) {\n      item = merged;\n      if (i) { newItems.pop(); }\n      else { oldItems = oldItems.slice(0, oldItems.length - 1); }\n    }\n    newItems.push(item);\n    if (selection) {\n      eventCount++;\n      selection = null;\n    }\n    if (!preserveItems) { lastItem = item; }\n  }\n  var overflow = eventCount - histOptions.depth;\n  if (overflow > DEPTH_OVERFLOW) {\n    oldItems = cutOffEvents(oldItems, overflow);\n    eventCount -= overflow;\n  }\n  return new Branch(oldItems.append(newItems), eventCount)\n};\n\nBranch.prototype.remapping = function remapping (from, to) {\n  var maps = new Mapping;\n  this.items.forEach(function (item, i) {\n    var mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from\n        ? maps.maps.length - item.mirrorOffset : null;\n    maps.appendMap(item.map, mirrorPos);\n  }, from, to);\n  return maps\n};\n\nBranch.prototype.addMaps = function addMaps (array) {\n  if (this.eventCount == 0) { return this }\n  return new Branch(this.items.append(array.map(function (map) { return new Item(map); })), this.eventCount)\n};\n\n// : (Transform, number)\n// When the collab module receives remote changes, the history has\n// to know about those, so that it can adjust the steps that were\n// rebased on top of the remote changes, and include the position\n// maps for the remote changes in its array of items.\nBranch.prototype.rebased = function rebased (rebasedTransform, rebasedCount) {\n  if (!this.eventCount) { return this }\n\n  var rebasedItems = [], start = Math.max(0, this.items.length - rebasedCount);\n\n  var mapping = rebasedTransform.mapping;\n  var newUntil = rebasedTransform.steps.length;\n  var eventCount = this.eventCount;\n  this.items.forEach(function (item) { if (item.selection) { eventCount--; } }, start);\n\n  var iRebased = rebasedCount;\n  this.items.forEach(function (item) {\n    var pos = mapping.getMirror(--iRebased);\n    if (pos == null) { return }\n    newUntil = Math.min(newUntil, pos);\n    var map = mapping.maps[pos];\n    if (item.step) {\n      var step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);\n      var selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));\n      if (selection) { eventCount++; }\n      rebasedItems.push(new Item(map, step, selection));\n    } else {\n      rebasedItems.push(new Item(map));\n    }\n  }, start);\n\n  var newMaps = [];\n  for (var i = rebasedCount; i < newUntil; i++)\n    { newMaps.push(new Item(mapping.maps[i])); }\n  var items = this.items.slice(0, start).append(newMaps).append(rebasedItems);\n  var branch = new Branch(items, eventCount);\n\n  if (branch.emptyItemCount() > max_empty_items)\n    { branch = branch.compress(this.items.length - rebasedItems.length); }\n  return branch\n};\n\nBranch.prototype.emptyItemCount = function emptyItemCount () {\n  var count = 0;\n  this.items.forEach(function (item) { if (!item.step) { count++; } });\n  return count\n};\n\n// Compressing a branch means rewriting it to push the air (map-only\n// items) out. During collaboration, these naturally accumulate\n// because each remote change adds one. The `upto` argument is used\n// to ensure that only the items below a given level are compressed,\n// because `rebased` relies on a clean, untouched set of items in\n// order to associate old items with rebased steps.\nBranch.prototype.compress = function compress (upto) {\n    if ( upto === void 0 ) upto = this.items.length;\n\n  var remap = this.remapping(0, upto), mapFrom = remap.maps.length;\n  var items = [], events = 0;\n  this.items.forEach(function (item, i) {\n    if (i >= upto) {\n      items.push(item);\n      if (item.selection) { events++; }\n    } else if (item.step) {\n      var step = item.step.map(remap.slice(mapFrom)), map = step && step.getMap();\n      mapFrom--;\n      if (map) { remap.appendMap(map, mapFrom); }\n      if (step) {\n        var selection = item.selection && item.selection.map(remap.slice(mapFrom));\n        if (selection) { events++; }\n        var newItem = new Item(map.invert(), step, selection), merged, last = items.length - 1;\n        if (merged = items.length && items[last].merge(newItem))\n          { items[last] = merged; }\n        else\n          { items.push(newItem); }\n      }\n    } else if (item.map) {\n      mapFrom--;\n    }\n  }, this.items.length, 0);\n  return new Branch(RopeSequence.from(items.reverse()), events)\n};\n\nBranch.empty = new Branch(RopeSequence.empty, 0);\n\nfunction cutOffEvents(items, n) {\n  var cutPoint;\n  items.forEach(function (item, i) {\n    if (item.selection && (n-- == 0)) {\n      cutPoint = i;\n      return false\n    }\n  });\n  return items.slice(cutPoint)\n}\n\nvar Item = function Item(map, step, selection, mirrorOffset) {\n  // The (forward) step map for this item.\n  this.map = map;\n  // The inverted step\n  this.step = step;\n  // If this is non-null, this item is the start of a group, and\n  // this selection is the starting selection for the group (the one\n  // that was active before the first step was applied)\n  this.selection = selection;\n  // If this item is the inverse of a previous mapping on the stack,\n  // this points at the inverse's offset\n  this.mirrorOffset = mirrorOffset;\n};\n\nItem.prototype.merge = function merge (other) {\n  if (this.step && other.step && !other.selection) {\n    var step = other.step.merge(this.step);\n    if (step) { return new Item(step.getMap().invert(), step, this.selection) }\n  }\n};\n\n// The value of the state field that tracks undo/redo history for that\n// state. Will be stored in the plugin state when the history plugin\n// is active.\nvar HistoryState = function HistoryState(done, undone, prevRanges, prevTime) {\n  this.done = done;\n  this.undone = undone;\n  this.prevRanges = prevRanges;\n  this.prevTime = prevTime;\n};\n\nvar DEPTH_OVERFLOW = 20;\n\n// : (HistoryState, EditorState, Transaction, Object)\n// Record a transformation in undo history.\nfunction applyTransaction(history, state, tr, options) {\n  var historyTr = tr.getMeta(historyKey), rebased;\n  if (historyTr) { return historyTr.historyState }\n\n  if (tr.getMeta(closeHistoryKey)) { history = new HistoryState(history.done, history.undone, null, 0); }\n\n  var appended = tr.getMeta(\"appendedTransaction\");\n\n  if (tr.steps.length == 0) {\n    return history\n  } else if (appended && appended.getMeta(historyKey)) {\n    if (appended.getMeta(historyKey).redo)\n      { return new HistoryState(history.done.addTransform(tr, null, options, mustPreserveItems(state)),\n                              history.undone, rangesFor(tr.mapping.maps[tr.steps.length - 1]), history.prevTime) }\n    else\n      { return new HistoryState(history.done, history.undone.addTransform(tr, null, options, mustPreserveItems(state)),\n                              null, history.prevTime) }\n  } else if (tr.getMeta(\"addToHistory\") !== false && !(appended && appended.getMeta(\"addToHistory\") === false)) {\n    // Group transforms that occur in quick succession into one event.\n    var newGroup = history.prevTime == 0 || !appended && (history.prevTime < (tr.time || 0) - options.newGroupDelay ||\n                                                          !isAdjacentTo(tr, history.prevRanges));\n    var prevRanges = appended ? mapRanges(history.prevRanges, tr.mapping) : rangesFor(tr.mapping.maps[tr.steps.length - 1]);\n    return new HistoryState(history.done.addTransform(tr, newGroup ? state.selection.getBookmark() : null,\n                                                      options, mustPreserveItems(state)),\n                            Branch.empty, prevRanges, tr.time)\n  } else if (rebased = tr.getMeta(\"rebased\")) {\n    // Used by the collab module to tell the history that some of its\n    // content has been rebased.\n    return new HistoryState(history.done.rebased(tr, rebased),\n                            history.undone.rebased(tr, rebased),\n                            mapRanges(history.prevRanges, tr.mapping), history.prevTime)\n  } else {\n    return new HistoryState(history.done.addMaps(tr.mapping.maps),\n                            history.undone.addMaps(tr.mapping.maps),\n                            mapRanges(history.prevRanges, tr.mapping), history.prevTime)\n  }\n}\n\nfunction isAdjacentTo(transform, prevRanges) {\n  if (!prevRanges) { return false }\n  if (!transform.docChanged) { return true }\n  var adjacent = false;\n  transform.mapping.maps[0].forEach(function (start, end) {\n    for (var i = 0; i < prevRanges.length; i += 2)\n      { if (start <= prevRanges[i + 1] && end >= prevRanges[i])\n        { adjacent = true; } }\n  });\n  return adjacent\n}\n\nfunction rangesFor(map) {\n  var result = [];\n  map.forEach(function (_from, _to, from, to) { return result.push(from, to); });\n  return result\n}\n\nfunction mapRanges(ranges, mapping) {\n  if (!ranges) { return null }\n  var result = [];\n  for (var i = 0; i < ranges.length; i += 2) {\n    var from = mapping.map(ranges[i], 1), to = mapping.map(ranges[i + 1], -1);\n    if (from <= to) { result.push(from, to); }\n  }\n  return result\n}\n\n// : (HistoryState, EditorState, (tr: Transaction), bool)\n// Apply the latest event from one branch to the document and shift the event\n// onto the other branch.\nfunction histTransaction(history, state, dispatch, redo) {\n  var preserveItems = mustPreserveItems(state), histOptions = historyKey.get(state).spec.config;\n  var pop = (redo ? history.undone : history.done).popEvent(state, preserveItems);\n  if (!pop) { return }\n\n  var selection = pop.selection.resolve(pop.transform.doc);\n  var added = (redo ? history.done : history.undone).addTransform(pop.transform, state.selection.getBookmark(),\n                                                                  histOptions, preserveItems);\n\n  var newHist = new HistoryState(redo ? added : pop.remaining, redo ? pop.remaining : added, null, 0);\n  dispatch(pop.transform.setSelection(selection).setMeta(historyKey, {redo: redo, historyState: newHist}).scrollIntoView());\n}\n\nvar cachedPreserveItems = false, cachedPreserveItemsPlugins = null;\n// Check whether any plugin in the given state has a\n// `historyPreserveItems` property in its spec, in which case we must\n// preserve steps exactly as they came in, so that they can be\n// rebased.\nfunction mustPreserveItems(state) {\n  var plugins = state.plugins;\n  if (cachedPreserveItemsPlugins != plugins) {\n    cachedPreserveItems = false;\n    cachedPreserveItemsPlugins = plugins;\n    for (var i = 0; i < plugins.length; i++) { if (plugins[i].spec.historyPreserveItems) {\n      cachedPreserveItems = true;\n      break\n    } }\n  }\n  return cachedPreserveItems\n}\n\n// :: (Transaction) → Transaction\n// Set a flag on the given transaction that will prevent further steps\n// from being appended to an existing history event (so that they\n// require a separate undo command to undo).\nfunction closeHistory(tr) {\n  return tr.setMeta(closeHistoryKey, true)\n}\n\nvar historyKey = new PluginKey(\"history\");\nvar closeHistoryKey = new PluginKey(\"closeHistory\");\n\n// :: (?Object) → Plugin\n// Returns a plugin that enables the undo history for an editor. The\n// plugin will track undo and redo stacks, which can be used with the\n// [`undo`](#history.undo) and [`redo`](#history.redo) commands.\n//\n// You can set an `\"addToHistory\"` [metadata\n// property](#state.Transaction.setMeta) of `false` on a transaction\n// to prevent it from being rolled back by undo.\n//\n//   config::-\n//   Supports the following configuration options:\n//\n//     depth:: ?number\n//     The amount of history events that are collected before the\n//     oldest events are discarded. Defaults to 100.\n//\n//     newGroupDelay:: ?number\n//     The delay between changes after which a new group should be\n//     started. Defaults to 500 (milliseconds). Note that when changes\n//     aren't adjacent, a new group is always started.\nfunction history(config) {\n  config = {depth: config && config.depth || 100,\n            newGroupDelay: config && config.newGroupDelay || 500};\n  return new Plugin({\n    key: historyKey,\n\n    state: {\n      init: function init() {\n        return new HistoryState(Branch.empty, Branch.empty, null, 0)\n      },\n      apply: function apply(tr, hist, state) {\n        return applyTransaction(hist, state, tr, config)\n      }\n    },\n\n    config: config,\n\n    props: {\n      handleDOMEvents: {\n        beforeinput: function beforeinput(view, e) {\n          var handled = e.inputType == \"historyUndo\" ? undo(view.state, view.dispatch) :\n              e.inputType == \"historyRedo\" ? redo(view.state, view.dispatch) : false;\n          if (handled) { e.preventDefault(); }\n          return handled\n        }\n      }\n    }\n  })\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// A command function that undoes the last change, if any.\nfunction undo(state, dispatch) {\n  var hist = historyKey.getState(state);\n  if (!hist || hist.done.eventCount == 0) { return false }\n  if (dispatch) { histTransaction(hist, state, dispatch, false); }\n  return true\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// A command function that redoes the last undone change, if any.\nfunction redo(state, dispatch) {\n  var hist = historyKey.getState(state);\n  if (!hist || hist.undone.eventCount == 0) { return false }\n  if (dispatch) { histTransaction(hist, state, dispatch, true); }\n  return true\n}\n\n// :: (EditorState) → number\n// The amount of undoable events available in a given state.\nfunction undoDepth(state) {\n  var hist = historyKey.getState(state);\n  return hist ? hist.done.eventCount : 0\n}\n\n// :: (EditorState) → number\n// The amount of redoable events available in a given editor state.\nfunction redoDepth(state) {\n  var hist = historyKey.getState(state);\n  return hist ? hist.undone.eventCount : 0\n}\n\nexport { HistoryState, closeHistory, history, redo, redoDepth, undo, undoDepth };\n//# sourceMappingURL=index.es.js.map\n","import { Plugin } from 'prosemirror-state';\nimport { findWrapping, canJoin } from 'prosemirror-transform';\n\n// ::- Input rules are regular expressions describing a piece of text\n// that, when typed, causes something to happen. This might be\n// changing two dashes into an emdash, wrapping a paragraph starting\n// with `\"> \"` into a blockquote, or something entirely different.\nvar InputRule = function InputRule(match, handler) {\n  this.match = match;\n  this.handler = typeof handler == \"string\" ? stringHandler(handler) : handler;\n};\n\nfunction stringHandler(string) {\n  return function(state, match, start, end) {\n    var insert = string;\n    if (match[1]) {\n      var offset = match[0].lastIndexOf(match[1]);\n      insert += match[0].slice(offset + match[1].length);\n      start += offset;\n      var cutOff = start - end;\n      if (cutOff > 0) {\n        insert = match[0].slice(offset - cutOff, offset) + insert;\n        start = end;\n      }\n    }\n    return state.tr.insertText(insert, start, end)\n  }\n}\n\nvar MAX_MATCH = 500;\n\n// :: (config: {rules: [InputRule]}) → Plugin\n// Create an input rules plugin. When enabled, it will cause text\n// input that matches any of the given rules to trigger the rule's\n// action.\nfunction inputRules(ref) {\n  var rules = ref.rules;\n\n  var plugin = new Plugin({\n    state: {\n      init: function init() { return null },\n      apply: function apply(tr, prev) {\n        var stored = tr.getMeta(this);\n        if (stored) { return stored }\n        return tr.selectionSet || tr.docChanged ? null : prev\n      }\n    },\n\n    props: {\n      handleTextInput: function handleTextInput(view, from, to, text) {\n        return run(view, from, to, text, rules, plugin)\n      },\n      handleDOMEvents: {\n        compositionend: function (view) {\n          setTimeout(function () {\n            var ref = view.state.selection;\n            var $cursor = ref.$cursor;\n            if ($cursor) { run(view, $cursor.pos, $cursor.pos, \"\", rules, plugin); }\n          });\n        }\n      }\n    },\n\n    isInputRules: true\n  });\n  return plugin\n}\n\nfunction run(view, from, to, text, rules, plugin) {\n  if (view.composing) { return false }\n  var state = view.state, $from = state.doc.resolve(from);\n  if ($from.parent.type.spec.code) { return false }\n  var textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset,\n                                            null, \"\\ufffc\") + text;\n  for (var i = 0; i < rules.length; i++) {\n    var match = rules[i].match.exec(textBefore);\n    var tr = match && rules[i].handler(state, match, from - (match[0].length - text.length), to);\n    if (!tr) { continue }\n    view.dispatch(tr.setMeta(plugin, {transform: tr, from: from, to: to, text: text}));\n    return true\n  }\n  return false\n}\n\n// :: (EditorState, ?(Transaction)) → bool\n// This is a command that will undo an input rule, if applying such a\n// rule was the last thing that the user did.\nfunction undoInputRule(state, dispatch) {\n  var plugins = state.plugins;\n  for (var i = 0; i < plugins.length; i++) {\n    var plugin = plugins[i], undoable = (void 0);\n    if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {\n      if (dispatch) {\n        var tr = state.tr, toUndo = undoable.transform;\n        for (var j = toUndo.steps.length - 1; j >= 0; j--)\n          { tr.step(toUndo.steps[j].invert(toUndo.docs[j])); }\n        if (undoable.text) {\n          var marks = tr.doc.resolve(undoable.from).marks();\n          tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));\n        } else {\n          tr.delete(undoable.from, undoable.to);\n        }\n        dispatch(tr);\n      }\n      return true\n    }\n  }\n  return false\n}\n\n// :: InputRule Converts double dashes to an emdash.\nvar emDash = new InputRule(/--$/, \"—\");\n// :: InputRule Converts three dots to an ellipsis character.\nvar ellipsis = new InputRule(/\\.\\.\\.$/, \"…\");\n// :: InputRule “Smart” opening double quotes.\nvar openDoubleQuote = new InputRule(/(?:^|[\\s\\{\\[\\(\\<'\"\\u2018\\u201C])(\")$/, \"“\");\n// :: InputRule “Smart” closing double quotes.\nvar closeDoubleQuote = new InputRule(/\"$/, \"”\");\n// :: InputRule “Smart” opening single quotes.\nvar openSingleQuote = new InputRule(/(?:^|[\\s\\{\\[\\(\\<'\"\\u2018\\u201C])(')$/, \"‘\");\n// :: InputRule “Smart” closing single quotes.\nvar closeSingleQuote = new InputRule(/'$/, \"’\");\n\n// :: [InputRule] Smart-quote related input rules.\nvar smartQuotes = [openDoubleQuote, closeDoubleQuote, openSingleQuote, closeSingleQuote];\n\n// :: (RegExp, NodeType, ?union<Object, ([string]) → ?Object>, ?([string], Node) → bool) → InputRule\n// Build an input rule for automatically wrapping a textblock when a\n// given string is typed. The `regexp` argument is\n// directly passed through to the `InputRule` constructor. You'll\n// probably want the regexp to start with `^`, so that the pattern can\n// only occur at the start of a textblock.\n//\n// `nodeType` is the type of node to wrap in. If it needs attributes,\n// you can either pass them directly, or pass a function that will\n// compute them from the regular expression match.\n//\n// By default, if there's a node with the same type above the newly\n// wrapped node, the rule will try to [join](#transform.Transform.join) those\n// two nodes. You can pass a join predicate, which takes a regular\n// expression match and the node before the wrapped node, and can\n// return a boolean to indicate whether a join should happen.\nfunction wrappingInputRule(regexp, nodeType, getAttrs, joinPredicate) {\n  return new InputRule(regexp, function (state, match, start, end) {\n    var attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;\n    var tr = state.tr.delete(start, end);\n    var $start = tr.doc.resolve(start), range = $start.blockRange(), wrapping = range && findWrapping(range, nodeType, attrs);\n    if (!wrapping) { return null }\n    tr.wrap(range, wrapping);\n    var before = tr.doc.resolve(start - 1).nodeBefore;\n    if (before && before.type == nodeType && canJoin(tr.doc, start - 1) &&\n        (!joinPredicate || joinPredicate(match, before)))\n      { tr.join(start - 1); }\n    return tr\n  })\n}\n\n// :: (RegExp, NodeType, ?union<Object, ([string]) → ?Object>) → InputRule\n// Build an input rule that changes the type of a textblock when the\n// matched text is typed into it. You'll usually want to start your\n// regexp with `^` to that it is only matched at the start of a\n// textblock. The optional `getAttrs` parameter can be used to compute\n// the new node's attributes, and works the same as in the\n// `wrappingInputRule` function.\nfunction textblockTypeInputRule(regexp, nodeType, getAttrs) {\n  return new InputRule(regexp, function (state, match, start, end) {\n    var $start = state.doc.resolve(start);\n    var attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;\n    if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) { return null }\n    return state.tr\n      .delete(start, end)\n      .setBlockType(start, start, nodeType, attrs)\n  })\n}\n\nexport { InputRule, closeDoubleQuote, closeSingleQuote, ellipsis, emDash, inputRules, openDoubleQuote, openSingleQuote, smartQuotes, textblockTypeInputRule, undoInputRule, wrappingInputRule };\n//# sourceMappingURL=index.es.js.map\n"],"sourceRoot":""}