{"version":3,"file":"static/js/vendors-b5b2e66b.d0baa807.js","mappings":"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","sources":["../node_modules/prop-types/factoryWithThrowingShims.js","../node_modules/prop-types/index.js","../node_modules/prop-types/lib/ReactPropTypesSecret.js","../node_modules/prosemirror-commands/dist/index.js","../node_modules/prosemirror-dropcursor/dist/index.js","../node_modules/prosemirror-gapcursor/dist/index.js","../node_modules/prosemirror-history/dist/index.js","../node_modules/prosemirror-keymap/dist/index.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bigint: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","import { liftTarget, replaceStep, ReplaceStep, canJoin, joinPoint, canSplit, ReplaceAroundStep, findWrapping } from 'prosemirror-transform';\nimport { Slice, Fragment } from 'prosemirror-model';\nimport { NodeSelection, Selection, TextSelection, AllSelection, SelectionRange } from 'prosemirror-state';\n\n/**\nDelete the selection, if there is one.\n*/\nconst deleteSelection = (state, dispatch) => {\n    if (state.selection.empty)\n        return false;\n    if (dispatch)\n        dispatch(state.tr.deleteSelection().scrollIntoView());\n    return true;\n};\nfunction atBlockStart(state, view) {\n    let { $cursor } = state.selection;\n    if (!$cursor || (view ? !view.endOfTextblock(\"backward\", state)\n        : $cursor.parentOffset > 0))\n        return null;\n    return $cursor;\n}\n/**\nIf the selection is empty and at the start of a textblock, try to\nreduce the distance between that block and the one before it—if\nthere's a block directly before it that can be joined, join them.\nIf not, try to move the selected block closer to the next one in\nthe document structure by lifting it out of its parent or moving it\ninto a parent of the previous block. Will use the view for accurate\n(bidi-aware) start-of-textblock detection if given.\n*/\nconst joinBackward = (state, dispatch, view) => {\n    let $cursor = atBlockStart(state, view);\n    if (!$cursor)\n        return false;\n    let $cut = findCutBefore($cursor);\n    // If there is no node before this, try to lift\n    if (!$cut) {\n        let range = $cursor.blockRange(), target = range && liftTarget(range);\n        if (target == null)\n            return false;\n        if (dispatch)\n            dispatch(state.tr.lift(range, target).scrollIntoView());\n        return true;\n    }\n    let before = $cut.nodeBefore;\n    // Apply the joining algorithm\n    if (deleteBarrier(state, $cut, dispatch, -1))\n        return true;\n    // If the node below has no content and the node above is\n    // selectable, delete the node below and select the one above.\n    if ($cursor.parent.content.size == 0 &&\n        (textblockAt(before, \"end\") || NodeSelection.isSelectable(before))) {\n        for (let depth = $cursor.depth;; depth--) {\n            let delStep = replaceStep(state.doc, $cursor.before(depth), $cursor.after(depth), Slice.empty);\n            if (delStep && delStep.slice.size < delStep.to - delStep.from) {\n                if (dispatch) {\n                    let tr = state.tr.step(delStep);\n                    tr.setSelection(textblockAt(before, \"end\")\n                        ? Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos, -1)), -1)\n                        : NodeSelection.create(tr.doc, $cut.pos - before.nodeSize));\n                    dispatch(tr.scrollIntoView());\n                }\n                return true;\n            }\n            if (depth == 1 || $cursor.node(depth - 1).childCount > 1)\n                break;\n        }\n    }\n    // If the node before is an atom, delete it\n    if (before.isAtom && $cut.depth == $cursor.depth - 1) {\n        if (dispatch)\n            dispatch(state.tr.delete($cut.pos - before.nodeSize, $cut.pos).scrollIntoView());\n        return true;\n    }\n    return false;\n};\n/**\nA more limited form of [`joinBackward`]($commands.joinBackward)\nthat only tries to join the current textblock to the one before\nit, if the cursor is at the start of a textblock.\n*/\nconst joinTextblockBackward = (state, dispatch, view) => {\n    let $cursor = atBlockStart(state, view);\n    if (!$cursor)\n        return false;\n    let $cut = findCutBefore($cursor);\n    return $cut ? joinTextblocksAround(state, $cut, dispatch) : false;\n};\n/**\nA more limited form of [`joinForward`]($commands.joinForward)\nthat only tries to join the current textblock to the one after\nit, if the cursor is at the end of a textblock.\n*/\nconst joinTextblockForward = (state, dispatch, view) => {\n    let $cursor = atBlockEnd(state, view);\n    if (!$cursor)\n        return false;\n    let $cut = findCutAfter($cursor);\n    return $cut ? joinTextblocksAround(state, $cut, dispatch) : false;\n};\nfunction joinTextblocksAround(state, $cut, dispatch) {\n    let before = $cut.nodeBefore, beforeText = before, beforePos = $cut.pos - 1;\n    for (; !beforeText.isTextblock; beforePos--) {\n        if (beforeText.type.spec.isolating)\n            return false;\n        let child = beforeText.lastChild;\n        if (!child)\n            return false;\n        beforeText = child;\n    }\n    let after = $cut.nodeAfter, afterText = after, afterPos = $cut.pos + 1;\n    for (; !afterText.isTextblock; afterPos++) {\n        if (afterText.type.spec.isolating)\n            return false;\n        let child = afterText.firstChild;\n        if (!child)\n            return false;\n        afterText = child;\n    }\n    let step = replaceStep(state.doc, beforePos, afterPos, Slice.empty);\n    if (!step || step.from != beforePos ||\n        step instanceof ReplaceStep && step.slice.size >= afterPos - beforePos)\n        return false;\n    if (dispatch) {\n        let tr = state.tr.step(step);\n        tr.setSelection(TextSelection.create(tr.doc, beforePos));\n        dispatch(tr.scrollIntoView());\n    }\n    return true;\n}\nfunction textblockAt(node, side, only = false) {\n    for (let scan = node; scan; scan = (side == \"start\" ? scan.firstChild : scan.lastChild)) {\n        if (scan.isTextblock)\n            return true;\n        if (only && scan.childCount != 1)\n            return false;\n    }\n    return false;\n}\n/**\nWhen the selection is empty and at the start of a textblock, select\nthe node before that textblock, if possible. This is intended to be\nbound to keys like backspace, after\n[`joinBackward`](https://prosemirror.net/docs/ref/#commands.joinBackward) or other deleting\ncommands, as a fall-back behavior when the schema doesn't allow\ndeletion at the selected point.\n*/\nconst selectNodeBackward = (state, dispatch, view) => {\n    let { $head, empty } = state.selection, $cut = $head;\n    if (!empty)\n        return false;\n    if ($head.parent.isTextblock) {\n        if (view ? !view.endOfTextblock(\"backward\", state) : $head.parentOffset > 0)\n            return false;\n        $cut = findCutBefore($head);\n    }\n    let node = $cut && $cut.nodeBefore;\n    if (!node || !NodeSelection.isSelectable(node))\n        return false;\n    if (dispatch)\n        dispatch(state.tr.setSelection(NodeSelection.create(state.doc, $cut.pos - node.nodeSize)).scrollIntoView());\n    return true;\n};\nfunction findCutBefore($pos) {\n    if (!$pos.parent.type.spec.isolating)\n        for (let i = $pos.depth - 1; i >= 0; i--) {\n            if ($pos.index(i) > 0)\n                return $pos.doc.resolve($pos.before(i + 1));\n            if ($pos.node(i).type.spec.isolating)\n                break;\n        }\n    return null;\n}\nfunction atBlockEnd(state, view) {\n    let { $cursor } = state.selection;\n    if (!$cursor || (view ? !view.endOfTextblock(\"forward\", state)\n        : $cursor.parentOffset < $cursor.parent.content.size))\n        return null;\n    return $cursor;\n}\n/**\nIf the selection is empty and the cursor is at the end of a\ntextblock, try to reduce or remove the boundary between that block\nand the one after it, either by joining them or by moving the other\nblock closer to this one in the tree structure. Will use the view\nfor accurate start-of-textblock detection if given.\n*/\nconst joinForward = (state, dispatch, view) => {\n    let $cursor = atBlockEnd(state, view);\n    if (!$cursor)\n        return false;\n    let $cut = findCutAfter($cursor);\n    // If there is no node after this, there's nothing to do\n    if (!$cut)\n        return false;\n    let after = $cut.nodeAfter;\n    // Try the joining algorithm\n    if (deleteBarrier(state, $cut, dispatch, 1))\n        return true;\n    // If the node above has no content and the node below is\n    // selectable, delete the node above and select the one below.\n    if ($cursor.parent.content.size == 0 &&\n        (textblockAt(after, \"start\") || NodeSelection.isSelectable(after))) {\n        let delStep = replaceStep(state.doc, $cursor.before(), $cursor.after(), Slice.empty);\n        if (delStep && delStep.slice.size < delStep.to - delStep.from) {\n            if (dispatch) {\n                let tr = state.tr.step(delStep);\n                tr.setSelection(textblockAt(after, \"start\") ? Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos)), 1)\n                    : NodeSelection.create(tr.doc, tr.mapping.map($cut.pos)));\n                dispatch(tr.scrollIntoView());\n            }\n            return true;\n        }\n    }\n    // If the next node is an atom, delete it\n    if (after.isAtom && $cut.depth == $cursor.depth - 1) {\n        if (dispatch)\n            dispatch(state.tr.delete($cut.pos, $cut.pos + after.nodeSize).scrollIntoView());\n        return true;\n    }\n    return false;\n};\n/**\nWhen the selection is empty and at the end of a textblock, select\nthe node coming after that textblock, if possible. This is intended\nto be bound to keys like delete, after\n[`joinForward`](https://prosemirror.net/docs/ref/#commands.joinForward) and similar deleting\ncommands, to provide a fall-back behavior when the schema doesn't\nallow deletion at the selected point.\n*/\nconst selectNodeForward = (state, dispatch, view) => {\n    let { $head, empty } = state.selection, $cut = $head;\n    if (!empty)\n        return false;\n    if ($head.parent.isTextblock) {\n        if (view ? !view.endOfTextblock(\"forward\", state) : $head.parentOffset < $head.parent.content.size)\n            return false;\n        $cut = findCutAfter($head);\n    }\n    let node = $cut && $cut.nodeAfter;\n    if (!node || !NodeSelection.isSelectable(node))\n        return false;\n    if (dispatch)\n        dispatch(state.tr.setSelection(NodeSelection.create(state.doc, $cut.pos)).scrollIntoView());\n    return true;\n};\nfunction findCutAfter($pos) {\n    if (!$pos.parent.type.spec.isolating)\n        for (let i = $pos.depth - 1; i >= 0; i--) {\n            let parent = $pos.node(i);\n            if ($pos.index(i) + 1 < parent.childCount)\n                return $pos.doc.resolve($pos.after(i + 1));\n            if (parent.type.spec.isolating)\n                break;\n        }\n    return null;\n}\n/**\nJoin the selected block or, if there is a text selection, the\nclosest ancestor block of the selection that can be joined, with\nthe sibling above it.\n*/\nconst joinUp = (state, dispatch) => {\n    let sel = state.selection, nodeSel = sel instanceof NodeSelection, point;\n    if (nodeSel) {\n        if (sel.node.isTextblock || !canJoin(state.doc, sel.from))\n            return false;\n        point = sel.from;\n    }\n    else {\n        point = joinPoint(state.doc, sel.from, -1);\n        if (point == null)\n            return false;\n    }\n    if (dispatch) {\n        let tr = state.tr.join(point);\n        if (nodeSel)\n            tr.setSelection(NodeSelection.create(tr.doc, point - state.doc.resolve(point).nodeBefore.nodeSize));\n        dispatch(tr.scrollIntoView());\n    }\n    return true;\n};\n/**\nJoin the selected block, or the closest ancestor of the selection\nthat can be joined, with the sibling after it.\n*/\nconst joinDown = (state, dispatch) => {\n    let sel = state.selection, point;\n    if (sel instanceof NodeSelection) {\n        if (sel.node.isTextblock || !canJoin(state.doc, sel.to))\n            return false;\n        point = sel.to;\n    }\n    else {\n        point = joinPoint(state.doc, sel.to, 1);\n        if (point == null)\n            return false;\n    }\n    if (dispatch)\n        dispatch(state.tr.join(point).scrollIntoView());\n    return true;\n};\n/**\nLift the selected block, or the closest ancestor block of the\nselection that can be lifted, out of its parent node.\n*/\nconst lift = (state, dispatch) => {\n    let { $from, $to } = state.selection;\n    let range = $from.blockRange($to), target = range && liftTarget(range);\n    if (target == null)\n        return false;\n    if (dispatch)\n        dispatch(state.tr.lift(range, target).scrollIntoView());\n    return true;\n};\n/**\nIf the selection is in a node whose type has a truthy\n[`code`](https://prosemirror.net/docs/ref/#model.NodeSpec.code) property in its spec, replace the\nselection with a newline character.\n*/\nconst newlineInCode = (state, dispatch) => {\n    let { $head, $anchor } = state.selection;\n    if (!$head.parent.type.spec.code || !$head.sameParent($anchor))\n        return false;\n    if (dispatch)\n        dispatch(state.tr.insertText(\"\\n\").scrollIntoView());\n    return true;\n};\nfunction defaultBlockAt(match) {\n    for (let i = 0; i < match.edgeCount; i++) {\n        let { type } = match.edge(i);\n        if (type.isTextblock && !type.hasRequiredAttrs())\n            return type;\n    }\n    return null;\n}\n/**\nWhen the selection is in a node with a truthy\n[`code`](https://prosemirror.net/docs/ref/#model.NodeSpec.code) property in its spec, create a\ndefault block after the code block, and move the cursor there.\n*/\nconst exitCode = (state, dispatch) => {\n    let { $head, $anchor } = state.selection;\n    if (!$head.parent.type.spec.code || !$head.sameParent($anchor))\n        return false;\n    let above = $head.node(-1), after = $head.indexAfter(-1), type = defaultBlockAt(above.contentMatchAt(after));\n    if (!type || !above.canReplaceWith(after, after, type))\n        return false;\n    if (dispatch) {\n        let pos = $head.after(), tr = state.tr.replaceWith(pos, pos, type.createAndFill());\n        tr.setSelection(Selection.near(tr.doc.resolve(pos), 1));\n        dispatch(tr.scrollIntoView());\n    }\n    return true;\n};\n/**\nIf a block node is selected, create an empty paragraph before (if\nit is its parent's first child) or after it.\n*/\nconst createParagraphNear = (state, dispatch) => {\n    let sel = state.selection, { $from, $to } = sel;\n    if (sel instanceof AllSelection || $from.parent.inlineContent || $to.parent.inlineContent)\n        return false;\n    let type = defaultBlockAt($to.parent.contentMatchAt($to.indexAfter()));\n    if (!type || !type.isTextblock)\n        return false;\n    if (dispatch) {\n        let side = (!$from.parentOffset && $to.index() < $to.parent.childCount ? $from : $to).pos;\n        let tr = state.tr.insert(side, type.createAndFill());\n        tr.setSelection(TextSelection.create(tr.doc, side + 1));\n        dispatch(tr.scrollIntoView());\n    }\n    return true;\n};\n/**\nIf the cursor is in an empty textblock that can be lifted, lift the\nblock.\n*/\nconst liftEmptyBlock = (state, dispatch) => {\n    let { $cursor } = state.selection;\n    if (!$cursor || $cursor.parent.content.size)\n        return false;\n    if ($cursor.depth > 1 && $cursor.after() != $cursor.end(-1)) {\n        let before = $cursor.before();\n        if (canSplit(state.doc, before)) {\n            if (dispatch)\n                dispatch(state.tr.split(before).scrollIntoView());\n            return true;\n        }\n    }\n    let range = $cursor.blockRange(), target = range && liftTarget(range);\n    if (target == null)\n        return false;\n    if (dispatch)\n        dispatch(state.tr.lift(range, target).scrollIntoView());\n    return true;\n};\n/**\nCreate a variant of [`splitBlock`](https://prosemirror.net/docs/ref/#commands.splitBlock) that uses\na custom function to determine the type of the newly split off block.\n*/\nfunction splitBlockAs(splitNode) {\n    return (state, dispatch) => {\n        let { $from, $to } = state.selection;\n        if (state.selection instanceof NodeSelection && state.selection.node.isBlock) {\n            if (!$from.parentOffset || !canSplit(state.doc, $from.pos))\n                return false;\n            if (dispatch)\n                dispatch(state.tr.split($from.pos).scrollIntoView());\n            return true;\n        }\n        if (!$from.depth)\n            return false;\n        let types = [];\n        let splitDepth, deflt, atEnd = false, atStart = false;\n        for (let d = $from.depth;; d--) {\n            let node = $from.node(d);\n            if (node.isBlock) {\n                atEnd = $from.end(d) == $from.pos + ($from.depth - d);\n                atStart = $from.start(d) == $from.pos - ($from.depth - d);\n                deflt = defaultBlockAt($from.node(d - 1).contentMatchAt($from.indexAfter(d - 1)));\n                let splitType = splitNode && splitNode($to.parent, atEnd, $from);\n                types.unshift(splitType || (atEnd && deflt ? { type: deflt } : null));\n                splitDepth = d;\n                break;\n            }\n            else {\n                if (d == 1)\n                    return false;\n                types.unshift(null);\n            }\n        }\n        let tr = state.tr;\n        if (state.selection instanceof TextSelection || state.selection instanceof AllSelection)\n            tr.deleteSelection();\n        let splitPos = tr.mapping.map($from.pos);\n        let can = canSplit(tr.doc, splitPos, types.length, types);\n        if (!can) {\n            types[0] = deflt ? { type: deflt } : null;\n            can = canSplit(tr.doc, splitPos, types.length, types);\n        }\n        tr.split(splitPos, types.length, types);\n        if (!atEnd && atStart && $from.node(splitDepth).type != deflt) {\n            let first = tr.mapping.map($from.before(splitDepth)), $first = tr.doc.resolve(first);\n            if (deflt && $from.node(splitDepth - 1).canReplaceWith($first.index(), $first.index() + 1, deflt))\n                tr.setNodeMarkup(tr.mapping.map($from.before(splitDepth)), deflt);\n        }\n        if (dispatch)\n            dispatch(tr.scrollIntoView());\n        return true;\n    };\n}\n/**\nSplit the parent block of the selection. If the selection is a text\nselection, also delete its content.\n*/\nconst splitBlock = splitBlockAs();\n/**\nActs like [`splitBlock`](https://prosemirror.net/docs/ref/#commands.splitBlock), but without\nresetting the set of active marks at the cursor.\n*/\nconst splitBlockKeepMarks = (state, dispatch) => {\n    return splitBlock(state, dispatch && (tr => {\n        let marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());\n        if (marks)\n            tr.ensureMarks(marks);\n        dispatch(tr);\n    }));\n};\n/**\nMove the selection to the node wrapping the current selection, if\nany. (Will not select the document node.)\n*/\nconst selectParentNode = (state, dispatch) => {\n    let { $from, to } = state.selection, pos;\n    let same = $from.sharedDepth(to);\n    if (same == 0)\n        return false;\n    pos = $from.before(same);\n    if (dispatch)\n        dispatch(state.tr.setSelection(NodeSelection.create(state.doc, pos)));\n    return true;\n};\n/**\nSelect the whole document.\n*/\nconst selectAll = (state, dispatch) => {\n    if (dispatch)\n        dispatch(state.tr.setSelection(new AllSelection(state.doc)));\n    return true;\n};\nfunction joinMaybeClear(state, $pos, dispatch) {\n    let before = $pos.nodeBefore, after = $pos.nodeAfter, index = $pos.index();\n    if (!before || !after || !before.type.compatibleContent(after.type))\n        return false;\n    if (!before.content.size && $pos.parent.canReplace(index - 1, index)) {\n        if (dispatch)\n            dispatch(state.tr.delete($pos.pos - before.nodeSize, $pos.pos).scrollIntoView());\n        return true;\n    }\n    if (!$pos.parent.canReplace(index, index + 1) || !(after.isTextblock || canJoin(state.doc, $pos.pos)))\n        return false;\n    if (dispatch)\n        dispatch(state.tr.join($pos.pos).scrollIntoView());\n    return true;\n}\nfunction deleteBarrier(state, $cut, dispatch, dir) {\n    let before = $cut.nodeBefore, after = $cut.nodeAfter, conn, match;\n    let isolated = before.type.spec.isolating || after.type.spec.isolating;\n    if (!isolated && joinMaybeClear(state, $cut, dispatch))\n        return true;\n    let canDelAfter = !isolated && $cut.parent.canReplace($cut.index(), $cut.index() + 1);\n    if (canDelAfter &&\n        (conn = (match = before.contentMatchAt(before.childCount)).findWrapping(after.type)) &&\n        match.matchType(conn[0] || after.type).validEnd) {\n        if (dispatch) {\n            let end = $cut.pos + after.nodeSize, wrap = Fragment.empty;\n            for (let i = conn.length - 1; i >= 0; i--)\n                wrap = Fragment.from(conn[i].create(null, wrap));\n            wrap = Fragment.from(before.copy(wrap));\n            let tr = state.tr.step(new ReplaceAroundStep($cut.pos - 1, end, $cut.pos, end, new Slice(wrap, 1, 0), conn.length, true));\n            let $joinAt = tr.doc.resolve(end + 2 * conn.length);\n            if ($joinAt.nodeAfter && $joinAt.nodeAfter.type == before.type &&\n                canJoin(tr.doc, $joinAt.pos))\n                tr.join($joinAt.pos);\n            dispatch(tr.scrollIntoView());\n        }\n        return true;\n    }\n    let selAfter = after.type.spec.isolating || (dir > 0 && isolated) ? null : Selection.findFrom($cut, 1);\n    let range = selAfter && selAfter.$from.blockRange(selAfter.$to), target = range && liftTarget(range);\n    if (target != null && target >= $cut.depth) {\n        if (dispatch)\n            dispatch(state.tr.lift(range, target).scrollIntoView());\n        return true;\n    }\n    if (canDelAfter && textblockAt(after, \"start\", true) && textblockAt(before, \"end\")) {\n        let at = before, wrap = [];\n        for (;;) {\n            wrap.push(at);\n            if (at.isTextblock)\n                break;\n            at = at.lastChild;\n        }\n        let afterText = after, afterDepth = 1;\n        for (; !afterText.isTextblock; afterText = afterText.firstChild)\n            afterDepth++;\n        if (at.canReplace(at.childCount, at.childCount, afterText.content)) {\n            if (dispatch) {\n                let end = Fragment.empty;\n                for (let i = wrap.length - 1; i >= 0; i--)\n                    end = Fragment.from(wrap[i].copy(end));\n                let tr = state.tr.step(new ReplaceAroundStep($cut.pos - wrap.length, $cut.pos + after.nodeSize, $cut.pos + afterDepth, $cut.pos + after.nodeSize - afterDepth, new Slice(end, wrap.length, 0), 0, true));\n                dispatch(tr.scrollIntoView());\n            }\n            return true;\n        }\n    }\n    return false;\n}\nfunction selectTextblockSide(side) {\n    return function (state, dispatch) {\n        let sel = state.selection, $pos = side < 0 ? sel.$from : sel.$to;\n        let depth = $pos.depth;\n        while ($pos.node(depth).isInline) {\n            if (!depth)\n                return false;\n            depth--;\n        }\n        if (!$pos.node(depth).isTextblock)\n            return false;\n        if (dispatch)\n            dispatch(state.tr.setSelection(TextSelection.create(state.doc, side < 0 ? $pos.start(depth) : $pos.end(depth))));\n        return true;\n    };\n}\n/**\nMoves the cursor to the start of current text block.\n*/\nconst selectTextblockStart = selectTextblockSide(-1);\n/**\nMoves the cursor to the end of current text block.\n*/\nconst selectTextblockEnd = selectTextblockSide(1);\n// Parameterized commands\n/**\nWrap the selection in a node of the given type with the given\nattributes.\n*/\nfunction wrapIn(nodeType, attrs = null) {\n    return function (state, dispatch) {\n        let { $from, $to } = state.selection;\n        let range = $from.blockRange($to), wrapping = range && findWrapping(range, nodeType, attrs);\n        if (!wrapping)\n            return false;\n        if (dispatch)\n            dispatch(state.tr.wrap(range, wrapping).scrollIntoView());\n        return true;\n    };\n}\n/**\nReturns a command that tries to set the selected textblocks to the\ngiven node type with the given attributes.\n*/\nfunction setBlockType(nodeType, attrs = null) {\n    return function (state, dispatch) {\n        let applicable = false;\n        for (let i = 0; i < state.selection.ranges.length && !applicable; i++) {\n            let { $from: { pos: from }, $to: { pos: to } } = state.selection.ranges[i];\n            state.doc.nodesBetween(from, to, (node, pos) => {\n                if (applicable)\n                    return false;\n                if (!node.isTextblock || node.hasMarkup(nodeType, attrs))\n                    return;\n                if (node.type == nodeType) {\n                    applicable = true;\n                }\n                else {\n                    let $pos = state.doc.resolve(pos), index = $pos.index();\n                    applicable = $pos.parent.canReplaceWith(index, index + 1, nodeType);\n                }\n            });\n        }\n        if (!applicable)\n            return false;\n        if (dispatch) {\n            let tr = state.tr;\n            for (let i = 0; i < state.selection.ranges.length; i++) {\n                let { $from: { pos: from }, $to: { pos: to } } = state.selection.ranges[i];\n                tr.setBlockType(from, to, nodeType, attrs);\n            }\n            dispatch(tr.scrollIntoView());\n        }\n        return true;\n    };\n}\nfunction markApplies(doc, ranges, type, enterAtoms) {\n    for (let i = 0; i < ranges.length; i++) {\n        let { $from, $to } = ranges[i];\n        let can = $from.depth == 0 ? doc.inlineContent && doc.type.allowsMarkType(type) : false;\n        doc.nodesBetween($from.pos, $to.pos, (node, pos) => {\n            if (can || !enterAtoms && node.isAtom && node.isInline && pos >= $from.pos && pos + node.nodeSize <= $to.pos)\n                return false;\n            can = node.inlineContent && node.type.allowsMarkType(type);\n        });\n        if (can)\n            return true;\n    }\n    return false;\n}\nfunction removeInlineAtoms(ranges) {\n    let result = [];\n    for (let i = 0; i < ranges.length; i++) {\n        let { $from, $to } = ranges[i];\n        $from.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {\n            if (node.isAtom && node.content.size && node.isInline && pos >= $from.pos && pos + node.nodeSize <= $to.pos) {\n                if (pos + 1 > $from.pos)\n                    result.push(new SelectionRange($from, $from.doc.resolve(pos + 1)));\n                $from = $from.doc.resolve(pos + 1 + node.content.size);\n                return false;\n            }\n        });\n        if ($from.pos < $to.pos)\n            result.push(new SelectionRange($from, $to));\n    }\n    return result;\n}\n/**\nCreate a command function that toggles the given mark with the\ngiven attributes. Will return `false` when the current selection\ndoesn't support that mark. This will remove the mark if any marks\nof that type exist in the selection, or add it otherwise. If the\nselection is empty, this applies to the [stored\nmarks](https://prosemirror.net/docs/ref/#state.EditorState.storedMarks) instead of a range of the\ndocument.\n*/\nfunction toggleMark(markType, attrs = null, options) {\n    let removeWhenPresent = (options && options.removeWhenPresent) !== false;\n    let enterAtoms = (options && options.enterInlineAtoms) !== false;\n    return function (state, dispatch) {\n        let { empty, $cursor, ranges } = state.selection;\n        if ((empty && !$cursor) || !markApplies(state.doc, ranges, markType, enterAtoms))\n            return false;\n        if (dispatch) {\n            if ($cursor) {\n                if (markType.isInSet(state.storedMarks || $cursor.marks()))\n                    dispatch(state.tr.removeStoredMark(markType));\n                else\n                    dispatch(state.tr.addStoredMark(markType.create(attrs)));\n            }\n            else {\n                let add, tr = state.tr;\n                if (!enterAtoms)\n                    ranges = removeInlineAtoms(ranges);\n                if (removeWhenPresent) {\n                    add = !ranges.some(r => state.doc.rangeHasMark(r.$from.pos, r.$to.pos, markType));\n                }\n                else {\n                    add = !ranges.every(r => {\n                        let missing = false;\n                        tr.doc.nodesBetween(r.$from.pos, r.$to.pos, (node, pos, parent) => {\n                            if (missing)\n                                return false;\n                            missing = !markType.isInSet(node.marks) && !!parent && parent.type.allowsMarkType(markType) &&\n                                !(node.isText && /^\\s*$/.test(node.textBetween(Math.max(0, r.$from.pos - pos), Math.min(node.nodeSize, r.$to.pos - pos))));\n                        });\n                        return !missing;\n                    });\n                }\n                for (let i = 0; i < ranges.length; i++) {\n                    let { $from, $to } = ranges[i];\n                    if (!add) {\n                        tr.removeMark($from.pos, $to.pos, markType);\n                    }\n                    else {\n                        let from = $from.pos, to = $to.pos, start = $from.nodeAfter, end = $to.nodeBefore;\n                        let spaceStart = start && start.isText ? /^\\s*/.exec(start.text)[0].length : 0;\n                        let spaceEnd = end && end.isText ? /\\s*$/.exec(end.text)[0].length : 0;\n                        if (from + spaceStart < to) {\n                            from += spaceStart;\n                            to -= spaceEnd;\n                        }\n                        tr.addMark(from, to, markType.create(attrs));\n                    }\n                }\n                dispatch(tr.scrollIntoView());\n            }\n        }\n        return true;\n    };\n}\nfunction wrapDispatchForJoin(dispatch, isJoinable) {\n    return (tr) => {\n        if (!tr.isGeneric)\n            return dispatch(tr);\n        let ranges = [];\n        for (let i = 0; i < tr.mapping.maps.length; i++) {\n            let map = tr.mapping.maps[i];\n            for (let j = 0; j < ranges.length; j++)\n                ranges[j] = map.map(ranges[j]);\n            map.forEach((_s, _e, from, to) => ranges.push(from, to));\n        }\n        // Figure out which joinable points exist inside those ranges,\n        // by checking all node boundaries in their parent nodes.\n        let joinable = [];\n        for (let i = 0; i < ranges.length; i += 2) {\n            let from = ranges[i], to = ranges[i + 1];\n            let $from = tr.doc.resolve(from), depth = $from.sharedDepth(to), parent = $from.node(depth);\n            for (let index = $from.indexAfter(depth), pos = $from.after(depth + 1); pos <= to; ++index) {\n                let after = parent.maybeChild(index);\n                if (!after)\n                    break;\n                if (index && joinable.indexOf(pos) == -1) {\n                    let before = parent.child(index - 1);\n                    if (before.type == after.type && isJoinable(before, after))\n                        joinable.push(pos);\n                }\n                pos += after.nodeSize;\n            }\n        }\n        // Join the joinable points\n        joinable.sort((a, b) => a - b);\n        for (let i = joinable.length - 1; i >= 0; i--) {\n            if (canJoin(tr.doc, joinable[i]))\n                tr.join(joinable[i]);\n        }\n        dispatch(tr);\n    };\n}\n/**\nWrap a command so that, when it produces a transform that causes\ntwo joinable nodes to end up next to each other, those are joined.\nNodes are considered joinable when they are of the same type and\nwhen the `isJoinable` predicate returns true for them or, if an\narray of strings was passed, if their node type name is in that\narray.\n*/\nfunction autoJoin(command, isJoinable) {\n    let canJoin = Array.isArray(isJoinable) ? (node) => isJoinable.indexOf(node.type.name) > -1\n        : isJoinable;\n    return (state, dispatch, view) => command(state, dispatch && wrapDispatchForJoin(dispatch, canJoin), view);\n}\n/**\nCombine a number of command functions into a single function (which\ncalls them one by one until one returns true).\n*/\nfunction chainCommands(...commands) {\n    return function (state, dispatch, view) {\n        for (let i = 0; i < commands.length; i++)\n            if (commands[i](state, dispatch, view))\n                return true;\n        return false;\n    };\n}\nlet backspace = chainCommands(deleteSelection, joinBackward, selectNodeBackward);\nlet del = chainCommands(deleteSelection, joinForward, selectNodeForward);\n/**\nA basic keymap containing bindings not specific to any schema.\nBinds the following keys (when multiple commands are listed, they\nare chained with [`chainCommands`](https://prosemirror.net/docs/ref/#commands.chainCommands)):\n\n* **Enter** to `newlineInCode`, `createParagraphNear`, `liftEmptyBlock`, `splitBlock`\n* **Mod-Enter** to `exitCode`\n* **Backspace** and **Mod-Backspace** to `deleteSelection`, `joinBackward`, `selectNodeBackward`\n* **Delete** and **Mod-Delete** to `deleteSelection`, `joinForward`, `selectNodeForward`\n* **Mod-Delete** to `deleteSelection`, `joinForward`, `selectNodeForward`\n* **Mod-a** to `selectAll`\n*/\nconst pcBaseKeymap = {\n    \"Enter\": chainCommands(newlineInCode, createParagraphNear, liftEmptyBlock, splitBlock),\n    \"Mod-Enter\": exitCode,\n    \"Backspace\": backspace,\n    \"Mod-Backspace\": backspace,\n    \"Shift-Backspace\": backspace,\n    \"Delete\": del,\n    \"Mod-Delete\": del,\n    \"Mod-a\": selectAll\n};\n/**\nA copy of `pcBaseKeymap` that also binds **Ctrl-h** like Backspace,\n**Ctrl-d** like Delete, **Alt-Backspace** like Ctrl-Backspace, and\n**Ctrl-Alt-Backspace**, **Alt-Delete**, and **Alt-d** like\nCtrl-Delete.\n*/\nconst macBaseKeymap = {\n    \"Ctrl-h\": pcBaseKeymap[\"Backspace\"],\n    \"Alt-Backspace\": pcBaseKeymap[\"Mod-Backspace\"],\n    \"Ctrl-d\": pcBaseKeymap[\"Delete\"],\n    \"Ctrl-Alt-Backspace\": pcBaseKeymap[\"Mod-Delete\"],\n    \"Alt-Delete\": pcBaseKeymap[\"Mod-Delete\"],\n    \"Alt-d\": pcBaseKeymap[\"Mod-Delete\"],\n    \"Ctrl-a\": selectTextblockStart,\n    \"Ctrl-e\": selectTextblockEnd\n};\nfor (let key in pcBaseKeymap)\n    macBaseKeymap[key] = pcBaseKeymap[key];\nconst mac = typeof navigator != \"undefined\" ? /Mac|iP(hone|[oa]d)/.test(navigator.platform)\n    // @ts-ignore\n    : typeof os != \"undefined\" && os.platform ? os.platform() == \"darwin\" : false;\n/**\nDepending on the detected platform, this will hold\n[`pcBasekeymap`](https://prosemirror.net/docs/ref/#commands.pcBaseKeymap) or\n[`macBaseKeymap`](https://prosemirror.net/docs/ref/#commands.macBaseKeymap).\n*/\nconst baseKeymap = mac ? macBaseKeymap : pcBaseKeymap;\n\nexport { autoJoin, baseKeymap, chainCommands, createParagraphNear, deleteSelection, exitCode, joinBackward, joinDown, joinForward, joinTextblockBackward, joinTextblockForward, joinUp, lift, liftEmptyBlock, macBaseKeymap, newlineInCode, pcBaseKeymap, selectAll, selectNodeBackward, selectNodeForward, selectParentNode, selectTextblockEnd, selectTextblockStart, setBlockType, splitBlock, splitBlockAs, splitBlockKeepMarks, toggleMark, wrapIn };\n","import { Plugin } from 'prosemirror-state';\nimport { dropPoint } from 'prosemirror-transform';\n\n/**\nCreate a plugin that, when added to a ProseMirror instance,\ncauses a decoration to show up at the drop position when something\nis dragged over the editor.\n\nNodes may add a `disableDropCursor` property to their spec to\ncontrol the showing of a drop cursor inside them. This may be a\nboolean or a function, which will be called with a view and a\nposition, and should return a boolean.\n*/\nfunction dropCursor(options = {}) {\n    return new Plugin({\n        view(editorView) { return new DropCursorView(editorView, options); }\n    });\n}\nclass DropCursorView {\n    constructor(editorView, options) {\n        var _a;\n        this.editorView = editorView;\n        this.cursorPos = null;\n        this.element = null;\n        this.timeout = -1;\n        this.width = (_a = options.width) !== null && _a !== void 0 ? _a : 1;\n        this.color = options.color === false ? undefined : (options.color || \"black\");\n        this.class = options.class;\n        this.handlers = [\"dragover\", \"dragend\", \"drop\", \"dragleave\"].map(name => {\n            let handler = (e) => { this[name](e); };\n            editorView.dom.addEventListener(name, handler);\n            return { name, handler };\n        });\n    }\n    destroy() {\n        this.handlers.forEach(({ name, handler }) => this.editorView.dom.removeEventListener(name, handler));\n    }\n    update(editorView, prevState) {\n        if (this.cursorPos != null && prevState.doc != editorView.state.doc) {\n            if (this.cursorPos > editorView.state.doc.content.size)\n                this.setCursor(null);\n            else\n                this.updateOverlay();\n        }\n    }\n    setCursor(pos) {\n        if (pos == this.cursorPos)\n            return;\n        this.cursorPos = pos;\n        if (pos == null) {\n            this.element.parentNode.removeChild(this.element);\n            this.element = null;\n        }\n        else {\n            this.updateOverlay();\n        }\n    }\n    updateOverlay() {\n        let $pos = this.editorView.state.doc.resolve(this.cursorPos);\n        let isBlock = !$pos.parent.inlineContent, rect;\n        if (isBlock) {\n            let before = $pos.nodeBefore, after = $pos.nodeAfter;\n            if (before || after) {\n                let node = this.editorView.nodeDOM(this.cursorPos - (before ? before.nodeSize : 0));\n                if (node) {\n                    let nodeRect = node.getBoundingClientRect();\n                    let top = before ? nodeRect.bottom : nodeRect.top;\n                    if (before && after)\n                        top = (top + this.editorView.nodeDOM(this.cursorPos).getBoundingClientRect().top) / 2;\n                    rect = { left: nodeRect.left, right: nodeRect.right, top: top - this.width / 2, bottom: top + this.width / 2 };\n                }\n            }\n        }\n        if (!rect) {\n            let coords = this.editorView.coordsAtPos(this.cursorPos);\n            rect = { left: coords.left - this.width / 2, right: coords.left + this.width / 2, top: coords.top, bottom: coords.bottom };\n        }\n        let parent = this.editorView.dom.offsetParent;\n        if (!this.element) {\n            this.element = parent.appendChild(document.createElement(\"div\"));\n            if (this.class)\n                this.element.className = this.class;\n            this.element.style.cssText = \"position: absolute; z-index: 50; pointer-events: none;\";\n            if (this.color) {\n                this.element.style.backgroundColor = this.color;\n            }\n        }\n        this.element.classList.toggle(\"prosemirror-dropcursor-block\", isBlock);\n        this.element.classList.toggle(\"prosemirror-dropcursor-inline\", !isBlock);\n        let parentLeft, parentTop;\n        if (!parent || parent == document.body && getComputedStyle(parent).position == \"static\") {\n            parentLeft = -pageXOffset;\n            parentTop = -pageYOffset;\n        }\n        else {\n            let rect = parent.getBoundingClientRect();\n            parentLeft = rect.left - parent.scrollLeft;\n            parentTop = rect.top - parent.scrollTop;\n        }\n        this.element.style.left = (rect.left - parentLeft) + \"px\";\n        this.element.style.top = (rect.top - parentTop) + \"px\";\n        this.element.style.width = (rect.right - rect.left) + \"px\";\n        this.element.style.height = (rect.bottom - rect.top) + \"px\";\n    }\n    scheduleRemoval(timeout) {\n        clearTimeout(this.timeout);\n        this.timeout = setTimeout(() => this.setCursor(null), timeout);\n    }\n    dragover(event) {\n        if (!this.editorView.editable)\n            return;\n        let pos = this.editorView.posAtCoords({ left: event.clientX, top: event.clientY });\n        let node = pos && pos.inside >= 0 && this.editorView.state.doc.nodeAt(pos.inside);\n        let disableDropCursor = node && node.type.spec.disableDropCursor;\n        let disabled = typeof disableDropCursor == \"function\" ? disableDropCursor(this.editorView, pos, event) : disableDropCursor;\n        if (pos && !disabled) {\n            let target = pos.pos;\n            if (this.editorView.dragging && this.editorView.dragging.slice) {\n                let point = dropPoint(this.editorView.state.doc, target, this.editorView.dragging.slice);\n                if (point != null)\n                    target = point;\n            }\n            this.setCursor(target);\n            this.scheduleRemoval(5000);\n        }\n    }\n    dragend() {\n        this.scheduleRemoval(20);\n    }\n    drop() {\n        this.scheduleRemoval(20);\n    }\n    dragleave(event) {\n        if (event.target == this.editorView.dom || !this.editorView.dom.contains(event.relatedTarget))\n            this.setCursor(null);\n    }\n}\n\nexport { dropCursor };\n","import { keydownHandler } from 'prosemirror-keymap';\nimport { Selection, NodeSelection, TextSelection, Plugin } from 'prosemirror-state';\nimport { Slice, Fragment } from 'prosemirror-model';\nimport { DecorationSet, Decoration } from 'prosemirror-view';\n\n/**\nGap cursor selections are represented using this class. Its\n`$anchor` and `$head` properties both point at the cursor position.\n*/\nclass GapCursor extends Selection {\n    /**\n    Create a gap cursor.\n    */\n    constructor($pos) {\n        super($pos, $pos);\n    }\n    map(doc, mapping) {\n        let $pos = doc.resolve(mapping.map(this.head));\n        return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos);\n    }\n    content() { return Slice.empty; }\n    eq(other) {\n        return other instanceof GapCursor && other.head == this.head;\n    }\n    toJSON() {\n        return { type: \"gapcursor\", pos: this.head };\n    }\n    /**\n    @internal\n    */\n    static fromJSON(doc, json) {\n        if (typeof json.pos != \"number\")\n            throw new RangeError(\"Invalid input for GapCursor.fromJSON\");\n        return new GapCursor(doc.resolve(json.pos));\n    }\n    /**\n    @internal\n    */\n    getBookmark() { return new GapBookmark(this.anchor); }\n    /**\n    @internal\n    */\n    static valid($pos) {\n        let parent = $pos.parent;\n        if (parent.isTextblock || !closedBefore($pos) || !closedAfter($pos))\n            return false;\n        let override = parent.type.spec.allowGapCursor;\n        if (override != null)\n            return override;\n        let deflt = parent.contentMatchAt($pos.index()).defaultType;\n        return deflt && deflt.isTextblock;\n    }\n    /**\n    @internal\n    */\n    static findGapCursorFrom($pos, dir, mustMove = false) {\n        search: for (;;) {\n            if (!mustMove && GapCursor.valid($pos))\n                return $pos;\n            let pos = $pos.pos, next = null;\n            // Scan up from this position\n            for (let d = $pos.depth;; d--) {\n                let parent = $pos.node(d);\n                if (dir > 0 ? $pos.indexAfter(d) < parent.childCount : $pos.index(d) > 0) {\n                    next = parent.child(dir > 0 ? $pos.indexAfter(d) : $pos.index(d) - 1);\n                    break;\n                }\n                else if (d == 0) {\n                    return null;\n                }\n                pos += dir;\n                let $cur = $pos.doc.resolve(pos);\n                if (GapCursor.valid($cur))\n                    return $cur;\n            }\n            // And then down into the next node\n            for (;;) {\n                let inside = dir > 0 ? next.firstChild : next.lastChild;\n                if (!inside) {\n                    if (next.isAtom && !next.isText && !NodeSelection.isSelectable(next)) {\n                        $pos = $pos.doc.resolve(pos + next.nodeSize * dir);\n                        mustMove = false;\n                        continue search;\n                    }\n                    break;\n                }\n                next = inside;\n                pos += dir;\n                let $cur = $pos.doc.resolve(pos);\n                if (GapCursor.valid($cur))\n                    return $cur;\n            }\n            return null;\n        }\n    }\n}\nGapCursor.prototype.visible = false;\nGapCursor.findFrom = GapCursor.findGapCursorFrom;\nSelection.jsonID(\"gapcursor\", GapCursor);\nclass GapBookmark {\n    constructor(pos) {\n        this.pos = pos;\n    }\n    map(mapping) {\n        return new GapBookmark(mapping.map(this.pos));\n    }\n    resolve(doc) {\n        let $pos = doc.resolve(this.pos);\n        return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos);\n    }\n}\nfunction closedBefore($pos) {\n    for (let d = $pos.depth; d >= 0; d--) {\n        let index = $pos.index(d), parent = $pos.node(d);\n        // At the start of this parent, look at next one\n        if (index == 0) {\n            if (parent.type.spec.isolating)\n                return true;\n            continue;\n        }\n        // See if the node before (or its first ancestor) is closed\n        for (let before = parent.child(index - 1);; before = before.lastChild) {\n            if ((before.childCount == 0 && !before.inlineContent) || before.isAtom || before.type.spec.isolating)\n                return true;\n            if (before.inlineContent)\n                return false;\n        }\n    }\n    // Hit start of document\n    return true;\n}\nfunction closedAfter($pos) {\n    for (let d = $pos.depth; d >= 0; d--) {\n        let index = $pos.indexAfter(d), parent = $pos.node(d);\n        if (index == parent.childCount) {\n            if (parent.type.spec.isolating)\n                return true;\n            continue;\n        }\n        for (let after = parent.child(index);; after = after.firstChild) {\n            if ((after.childCount == 0 && !after.inlineContent) || after.isAtom || after.type.spec.isolating)\n                return true;\n            if (after.inlineContent)\n                return false;\n        }\n    }\n    return true;\n}\n\n/**\nCreate a gap cursor plugin. When enabled, this will capture clicks\nnear and arrow-key-motion past places that don't have a normally\nselectable position nearby, and create a gap cursor selection for\nthem. The cursor is drawn as an element with class\n`ProseMirror-gapcursor`. You can either include\n`style/gapcursor.css` from the package's directory or add your own\nstyles to make it visible.\n*/\nfunction gapCursor() {\n    return new Plugin({\n        props: {\n            decorations: drawGapCursor,\n            createSelectionBetween(_view, $anchor, $head) {\n                return $anchor.pos == $head.pos && GapCursor.valid($head) ? new GapCursor($head) : null;\n            },\n            handleClick,\n            handleKeyDown,\n            handleDOMEvents: { beforeinput: beforeinput }\n        }\n    });\n}\nconst handleKeyDown = keydownHandler({\n    \"ArrowLeft\": arrow(\"horiz\", -1),\n    \"ArrowRight\": arrow(\"horiz\", 1),\n    \"ArrowUp\": arrow(\"vert\", -1),\n    \"ArrowDown\": arrow(\"vert\", 1)\n});\nfunction arrow(axis, dir) {\n    const dirStr = axis == \"vert\" ? (dir > 0 ? \"down\" : \"up\") : (dir > 0 ? \"right\" : \"left\");\n    return function (state, dispatch, view) {\n        let sel = state.selection;\n        let $start = dir > 0 ? sel.$to : sel.$from, mustMove = sel.empty;\n        if (sel instanceof TextSelection) {\n            if (!view.endOfTextblock(dirStr) || $start.depth == 0)\n                return false;\n            mustMove = false;\n            $start = state.doc.resolve(dir > 0 ? $start.after() : $start.before());\n        }\n        let $found = GapCursor.findGapCursorFrom($start, dir, mustMove);\n        if (!$found)\n            return false;\n        if (dispatch)\n            dispatch(state.tr.setSelection(new GapCursor($found)));\n        return true;\n    };\n}\nfunction handleClick(view, pos, event) {\n    if (!view || !view.editable)\n        return false;\n    let $pos = view.state.doc.resolve(pos);\n    if (!GapCursor.valid($pos))\n        return false;\n    let clickPos = view.posAtCoords({ left: event.clientX, top: event.clientY });\n    if (clickPos && clickPos.inside > -1 && NodeSelection.isSelectable(view.state.doc.nodeAt(clickPos.inside)))\n        return false;\n    view.dispatch(view.state.tr.setSelection(new GapCursor($pos)));\n    return true;\n}\n// This is a hack that, when a composition starts while a gap cursor\n// is active, quickly creates an inline context for the composition to\n// happen in, to avoid it being aborted by the DOM selection being\n// moved into a valid position.\nfunction beforeinput(view, event) {\n    if (event.inputType != \"insertCompositionText\" || !(view.state.selection instanceof GapCursor))\n        return false;\n    let { $from } = view.state.selection;\n    let insert = $from.parent.contentMatchAt($from.index()).findWrapping(view.state.schema.nodes.text);\n    if (!insert)\n        return false;\n    let frag = Fragment.empty;\n    for (let i = insert.length - 1; i >= 0; i--)\n        frag = Fragment.from(insert[i].createAndFill(null, frag));\n    let tr = view.state.tr.replace($from.pos, $from.pos, new Slice(frag, 0, 0));\n    tr.setSelection(TextSelection.near(tr.doc.resolve($from.pos + 1)));\n    view.dispatch(tr);\n    return false;\n}\nfunction drawGapCursor(state) {\n    if (!(state.selection instanceof GapCursor))\n        return null;\n    let node = document.createElement(\"div\");\n    node.className = \"ProseMirror-gapcursor\";\n    return DecorationSet.create(state.doc, [Decoration.widget(state.selection.head, node, { key: \"gapcursor\" })]);\n}\n\nexport { GapCursor, gapCursor };\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// Used to schedule history compression\nconst max_empty_items = 500;\nclass Branch {\n    constructor(items, eventCount) {\n        this.items = items;\n        this.eventCount = eventCount;\n    }\n    // Pop the latest event off the branch's history and apply it\n    // to a document transform.\n    popEvent(state, preserveItems) {\n        if (this.eventCount == 0)\n            return null;\n        let end = this.items.length;\n        for (;; end--) {\n            let next = this.items.get(end - 1);\n            if (next.selection) {\n                --end;\n                break;\n            }\n        }\n        let remap, mapFrom;\n        if (preserveItems) {\n            remap = this.remapping(end, this.items.length);\n            mapFrom = remap.maps.length;\n        }\n        let transform = state.tr;\n        let selection, remaining;\n        let addAfter = [], addBefore = [];\n        this.items.forEach((item, i) => {\n            if (!item.step) {\n                if (!remap) {\n                    remap = this.remapping(end, i + 1);\n                    mapFrom = remap.maps.length;\n                }\n                mapFrom--;\n                addBefore.push(item);\n                return;\n            }\n            if (remap) {\n                addBefore.push(new Item(item.map));\n                let step = item.step.map(remap.slice(mapFrom)), map;\n                if (step && transform.maybeStep(step).doc) {\n                    map = transform.mapping.maps[transform.mapping.maps.length - 1];\n                    addAfter.push(new Item(map, undefined, undefined, addAfter.length + addBefore.length));\n                }\n                mapFrom--;\n                if (map)\n                    remap.appendMap(map, mapFrom);\n            }\n            else {\n                transform.maybeStep(item.step);\n            }\n            if (item.selection) {\n                selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;\n                remaining = new Branch(this.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), this.eventCount - 1);\n                return false;\n            }\n        }, this.items.length, 0);\n        return { remaining: remaining, transform, selection: selection };\n    }\n    // Create a new branch with the given transform added.\n    addTransform(transform, selection, histOptions, preserveItems) {\n        let newItems = [], eventCount = this.eventCount;\n        let oldItems = this.items, lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;\n        for (let i = 0; i < transform.steps.length; i++) {\n            let step = transform.steps[i].invert(transform.docs[i]);\n            let item = new Item(transform.mapping.maps[i], step, selection), merged;\n            if (merged = lastItem && lastItem.merge(item)) {\n                item = merged;\n                if (i)\n                    newItems.pop();\n                else\n                    oldItems = oldItems.slice(0, oldItems.length - 1);\n            }\n            newItems.push(item);\n            if (selection) {\n                eventCount++;\n                selection = undefined;\n            }\n            if (!preserveItems)\n                lastItem = item;\n        }\n        let 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    remapping(from, to) {\n        let maps = new Mapping;\n        this.items.forEach((item, i) => {\n            let mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from\n                ? maps.maps.length - item.mirrorOffset : undefined;\n            maps.appendMap(item.map, mirrorPos);\n        }, from, to);\n        return maps;\n    }\n    addMaps(array) {\n        if (this.eventCount == 0)\n            return this;\n        return new Branch(this.items.append(array.map(map => new Item(map))), this.eventCount);\n    }\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.\n    rebased(rebasedTransform, rebasedCount) {\n        if (!this.eventCount)\n            return this;\n        let rebasedItems = [], start = Math.max(0, this.items.length - rebasedCount);\n        let mapping = rebasedTransform.mapping;\n        let newUntil = rebasedTransform.steps.length;\n        let eventCount = this.eventCount;\n        this.items.forEach(item => { if (item.selection)\n            eventCount--; }, start);\n        let iRebased = rebasedCount;\n        this.items.forEach(item => {\n            let pos = mapping.getMirror(--iRebased);\n            if (pos == null)\n                return;\n            newUntil = Math.min(newUntil, pos);\n            let map = mapping.maps[pos];\n            if (item.step) {\n                let step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);\n                let selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));\n                if (selection)\n                    eventCount++;\n                rebasedItems.push(new Item(map, step, selection));\n            }\n            else {\n                rebasedItems.push(new Item(map));\n            }\n        }, start);\n        let newMaps = [];\n        for (let i = rebasedCount; i < newUntil; i++)\n            newMaps.push(new Item(mapping.maps[i]));\n        let items = this.items.slice(0, start).append(newMaps).append(rebasedItems);\n        let branch = new Branch(items, eventCount);\n        if (branch.emptyItemCount() > max_empty_items)\n            branch = branch.compress(this.items.length - rebasedItems.length);\n        return branch;\n    }\n    emptyItemCount() {\n        let count = 0;\n        this.items.forEach(item => { if (!item.step)\n            count++; });\n        return count;\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.\n    compress(upto = this.items.length) {\n        let remap = this.remapping(0, upto), mapFrom = remap.maps.length;\n        let items = [], events = 0;\n        this.items.forEach((item, i) => {\n            if (i >= upto) {\n                items.push(item);\n                if (item.selection)\n                    events++;\n            }\n            else if (item.step) {\n                let step = item.step.map(remap.slice(mapFrom)), map = step && step.getMap();\n                mapFrom--;\n                if (map)\n                    remap.appendMap(map, mapFrom);\n                if (step) {\n                    let selection = item.selection && item.selection.map(remap.slice(mapFrom));\n                    if (selection)\n                        events++;\n                    let 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            }\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);\nfunction cutOffEvents(items, n) {\n    let cutPoint;\n    items.forEach((item, i) => {\n        if (item.selection && (n-- == 0)) {\n            cutPoint = i;\n            return false;\n        }\n    });\n    return items.slice(cutPoint);\n}\nclass Item {\n    constructor(\n    // The (forward) step map for this item.\n    map, \n    // The inverted step\n    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    selection, \n    // If this item is the inverse of a previous mapping on the stack,\n    // this points at the inverse's offset\n    mirrorOffset) {\n        this.map = map;\n        this.step = step;\n        this.selection = selection;\n        this.mirrorOffset = mirrorOffset;\n    }\n    merge(other) {\n        if (this.step && other.step && !other.selection) {\n            let step = other.step.merge(this.step);\n            if (step)\n                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.\nclass HistoryState {\n    constructor(done, undone, prevRanges, prevTime, prevComposition) {\n        this.done = done;\n        this.undone = undone;\n        this.prevRanges = prevRanges;\n        this.prevTime = prevTime;\n        this.prevComposition = prevComposition;\n    }\n}\nconst DEPTH_OVERFLOW = 20;\n// Record a transformation in undo history.\nfunction applyTransaction(history, state, tr, options) {\n    let historyTr = tr.getMeta(historyKey), rebased;\n    if (historyTr)\n        return historyTr.historyState;\n    if (tr.getMeta(closeHistoryKey))\n        history = new HistoryState(history.done, history.undone, null, 0, -1);\n    let appended = tr.getMeta(\"appendedTransaction\");\n    if (tr.steps.length == 0) {\n        return history;\n    }\n    else if (appended && appended.getMeta(historyKey)) {\n        if (appended.getMeta(historyKey).redo)\n            return new HistoryState(history.done.addTransform(tr, undefined, options, mustPreserveItems(state)), history.undone, rangesFor(tr.mapping.maps), history.prevTime, history.prevComposition);\n        else\n            return new HistoryState(history.done, history.undone.addTransform(tr, undefined, options, mustPreserveItems(state)), null, history.prevTime, history.prevComposition);\n    }\n    else if (tr.getMeta(\"addToHistory\") !== false && !(appended && appended.getMeta(\"addToHistory\") === false)) {\n        // Group transforms that occur in quick succession into one event.\n        let composition = tr.getMeta(\"composition\");\n        let newGroup = history.prevTime == 0 ||\n            (!appended && history.prevComposition != composition &&\n                (history.prevTime < (tr.time || 0) - options.newGroupDelay || !isAdjacentTo(tr, history.prevRanges)));\n        let prevRanges = appended ? mapRanges(history.prevRanges, tr.mapping) : rangesFor(tr.mapping.maps);\n        return new HistoryState(history.done.addTransform(tr, newGroup ? state.selection.getBookmark() : undefined, options, mustPreserveItems(state)), Branch.empty, prevRanges, tr.time, composition == null ? history.prevComposition : composition);\n    }\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), history.undone.rebased(tr, rebased), mapRanges(history.prevRanges, tr.mapping), history.prevTime, history.prevComposition);\n    }\n    else {\n        return new HistoryState(history.done.addMaps(tr.mapping.maps), history.undone.addMaps(tr.mapping.maps), mapRanges(history.prevRanges, tr.mapping), history.prevTime, history.prevComposition);\n    }\n}\nfunction isAdjacentTo(transform, prevRanges) {\n    if (!prevRanges)\n        return false;\n    if (!transform.docChanged)\n        return true;\n    let adjacent = false;\n    transform.mapping.maps[0].forEach((start, end) => {\n        for (let i = 0; i < prevRanges.length; i += 2)\n            if (start <= prevRanges[i + 1] && end >= prevRanges[i])\n                adjacent = true;\n    });\n    return adjacent;\n}\nfunction rangesFor(maps) {\n    let result = [];\n    for (let i = maps.length - 1; i >= 0 && result.length == 0; i--)\n        maps[i].forEach((_from, _to, from, to) => result.push(from, to));\n    return result;\n}\nfunction mapRanges(ranges, mapping) {\n    if (!ranges)\n        return null;\n    let result = [];\n    for (let i = 0; i < ranges.length; i += 2) {\n        let from = mapping.map(ranges[i], 1), to = mapping.map(ranges[i + 1], -1);\n        if (from <= to)\n            result.push(from, to);\n    }\n    return result;\n}\n// Apply the latest event from one branch to the document and shift the event\n// onto the other branch.\nfunction histTransaction(history, state, redo) {\n    let preserveItems = mustPreserveItems(state);\n    let histOptions = historyKey.get(state).spec.config;\n    let pop = (redo ? history.undone : history.done).popEvent(state, preserveItems);\n    if (!pop)\n        return null;\n    let selection = pop.selection.resolve(pop.transform.doc);\n    let added = (redo ? history.done : history.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);\n    let newHist = new HistoryState(redo ? added : pop.remaining, redo ? pop.remaining : added, null, 0, -1);\n    return pop.transform.setSelection(selection).setMeta(historyKey, { redo, historyState: newHist });\n}\nlet 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    let plugins = state.plugins;\n    if (cachedPreserveItemsPlugins != plugins) {\n        cachedPreserveItems = false;\n        cachedPreserveItemsPlugins = plugins;\n        for (let i = 0; i < plugins.length; i++)\n            if (plugins[i].spec.historyPreserveItems) {\n                cachedPreserveItems = true;\n                break;\n            }\n    }\n    return cachedPreserveItems;\n}\n/**\nSet a flag on the given transaction that will prevent further steps\nfrom being appended to an existing history event (so that they\nrequire a separate undo command to undo).\n*/\nfunction closeHistory(tr) {\n    return tr.setMeta(closeHistoryKey, true);\n}\nconst historyKey = new PluginKey(\"history\");\nconst closeHistoryKey = new PluginKey(\"closeHistory\");\n/**\nReturns a plugin that enables the undo history for an editor. The\nplugin will track undo and redo stacks, which can be used with the\n[`undo`](https://prosemirror.net/docs/ref/#history.undo) and [`redo`](https://prosemirror.net/docs/ref/#history.redo) commands.\n\nYou can set an `\"addToHistory\"` [metadata\nproperty](https://prosemirror.net/docs/ref/#state.Transaction.setMeta) of `false` on a transaction\nto prevent it from being rolled back by undo.\n*/\nfunction history(config = {}) {\n    config = { depth: config.depth || 100,\n        newGroupDelay: config.newGroupDelay || 500 };\n    return new Plugin({\n        key: historyKey,\n        state: {\n            init() {\n                return new HistoryState(Branch.empty, Branch.empty, null, 0, -1);\n            },\n            apply(tr, hist, state) {\n                return applyTransaction(hist, state, tr, config);\n            }\n        },\n        config,\n        props: {\n            handleDOMEvents: {\n                beforeinput(view, e) {\n                    let inputType = e.inputType;\n                    let command = inputType == \"historyUndo\" ? undo : inputType == \"historyRedo\" ? redo : null;\n                    if (!command)\n                        return false;\n                    e.preventDefault();\n                    return command(view.state, view.dispatch);\n                }\n            }\n        }\n    });\n}\nfunction buildCommand(redo, scroll) {\n    return (state, dispatch) => {\n        let hist = historyKey.getState(state);\n        if (!hist || (redo ? hist.undone : hist.done).eventCount == 0)\n            return false;\n        if (dispatch) {\n            let tr = histTransaction(hist, state, redo);\n            if (tr)\n                dispatch(scroll ? tr.scrollIntoView() : tr);\n        }\n        return true;\n    };\n}\n/**\nA command function that undoes the last change, if any.\n*/\nconst undo = buildCommand(false, true);\n/**\nA command function that redoes the last undone change, if any.\n*/\nconst redo = buildCommand(true, true);\n/**\nA command function that undoes the last change. Don't scroll the\nselection into view.\n*/\nconst undoNoScroll = buildCommand(false, false);\n/**\nA command function that redoes the last undone change. Don't\nscroll the selection into view.\n*/\nconst redoNoScroll = buildCommand(true, false);\n/**\nThe amount of undoable events available in a given state.\n*/\nfunction undoDepth(state) {\n    let hist = historyKey.getState(state);\n    return hist ? hist.done.eventCount : 0;\n}\n/**\nThe amount of redoable events available in a given editor state.\n*/\nfunction redoDepth(state) {\n    let hist = historyKey.getState(state);\n    return hist ? hist.undone.eventCount : 0;\n}\n\nexport { closeHistory, history, redo, redoDepth, redoNoScroll, undo, undoDepth, undoNoScroll };\n","import { keyName, base } from 'w3c-keyname';\nimport { Plugin } from 'prosemirror-state';\n\nconst mac = typeof navigator != \"undefined\" ? /Mac|iP(hone|[oa]d)/.test(navigator.platform) : false;\nfunction normalizeKeyName(name) {\n    let parts = name.split(/-(?!$)/), result = parts[parts.length - 1];\n    if (result == \"Space\")\n        result = \" \";\n    let alt, ctrl, shift, meta;\n    for (let i = 0; i < parts.length - 1; i++) {\n        let mod = parts[i];\n        if (/^(cmd|meta|m)$/i.test(mod))\n            meta = true;\n        else if (/^a(lt)?$/i.test(mod))\n            alt = true;\n        else if (/^(c|ctrl|control)$/i.test(mod))\n            ctrl = true;\n        else if (/^s(hift)?$/i.test(mod))\n            shift = true;\n        else if (/^mod$/i.test(mod)) {\n            if (mac)\n                meta = true;\n            else\n                ctrl = true;\n        }\n        else\n            throw new Error(\"Unrecognized modifier name: \" + mod);\n    }\n    if (alt)\n        result = \"Alt-\" + result;\n    if (ctrl)\n        result = \"Ctrl-\" + result;\n    if (meta)\n        result = \"Meta-\" + result;\n    if (shift)\n        result = \"Shift-\" + result;\n    return result;\n}\nfunction normalize(map) {\n    let copy = Object.create(null);\n    for (let prop in map)\n        copy[normalizeKeyName(prop)] = map[prop];\n    return copy;\n}\nfunction modifiers(name, event, shift = true) {\n    if (event.altKey)\n        name = \"Alt-\" + name;\n    if (event.ctrlKey)\n        name = \"Ctrl-\" + name;\n    if (event.metaKey)\n        name = \"Meta-\" + name;\n    if (shift && event.shiftKey)\n        name = \"Shift-\" + name;\n    return name;\n}\n/**\nCreate a keymap plugin for the given set of bindings.\n\nBindings should map key names to [command](https://prosemirror.net/docs/ref/#commands)-style\nfunctions, which will be called with `(EditorState, dispatch,\nEditorView)` arguments, and should return true when they've handled\nthe key. Note that the view argument isn't part of the command\nprotocol, but can be used as an escape hatch if a binding needs to\ndirectly interact with the UI.\n\nKey names may be strings like `\"Shift-Ctrl-Enter\"`—a key\nidentifier prefixed with zero or more modifiers. Key identifiers\nare based on the strings that can appear in\n[`KeyEvent.key`](https:developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key).\nUse lowercase letters to refer to letter keys (or uppercase letters\nif you want shift to be held). You may use `\"Space\"` as an alias\nfor the `\" \"` name.\n\nModifiers 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\nshift, the `Shift-` prefix is implied, and should not be added\nexplicitly.\n\nYou can use `Mod-` as a shorthand for `Cmd-` on Mac and `Ctrl-` on\nother platforms.\n\nYou can add multiple keymap plugins to an editor. The order in\nwhich they appear determines their precedence (the ones early in\nthe array get to dispatch first).\n*/\nfunction keymap(bindings) {\n    return new Plugin({ props: { handleKeyDown: keydownHandler(bindings) } });\n}\n/**\nGiven a set of bindings (using the same format as\n[`keymap`](https://prosemirror.net/docs/ref/#keymap.keymap)), return a [keydown\nhandler](https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyDown) that handles them.\n*/\nfunction keydownHandler(bindings) {\n    let map = normalize(bindings);\n    return function (view, event) {\n        let name = keyName(event), baseName, direct = map[modifiers(name, event)];\n        if (direct && direct(view.state, view.dispatch, view))\n            return true;\n        // A character key\n        if (name.length == 1 && name != \" \") {\n            if (event.shiftKey) {\n                // In case the name was already modified by shift, try looking\n                // it up without its shift modifier\n                let noShift = map[modifiers(name, event, false)];\n                if (noShift && noShift(view.state, view.dispatch, view))\n                    return true;\n            }\n            if ((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                let fromCode = map[modifiers(baseName, event)];\n                if (fromCode && fromCode(view.state, view.dispatch, view))\n                    return true;\n            }\n        }\n        return false;\n    };\n}\n\nexport { keydownHandler, keymap };\n"],"names":["ReactPropTypesSecret","require","emptyFunction","emptyFunctionWithReset","resetWarningCache","module","exports","shim","props","propName","componentName","location","propFullName","secret","err","Error","name","getShim","isRequired","ReactPropTypes","array","bigint","bool","func","number","object","string","symbol","any","arrayOf","element","elementType","instanceOf","node","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","deleteSelection","state","dispatch","selection","empty","tr","scrollIntoView","atBlockStart","view","$cursor","endOfTextblock","parentOffset","joinBackward","$cut","findCutBefore","range","blockRange","target","liftTarget","lift","before","nodeBefore","deleteBarrier","parent","content","size","textblockAt","NodeSelection","isSelectable","depth","delStep","replaceStep","doc","after","Slice","slice","to","from","step","setSelection","Selection","findFrom","resolve","mapping","map","pos","create","nodeSize","childCount","isAtom","delete","joinTextblockBackward","joinTextblocksAround","joinTextblockForward","atBlockEnd","findCutAfter","beforeText","beforePos","isTextblock","type","spec","isolating","child","lastChild","afterText","nodeAfter","afterPos","firstChild","ReplaceStep","TextSelection","side","only","arguments","length","undefined","scan","selectNodeBackward","$head","$pos","i","index","joinForward","selectNodeForward","joinUp","point","sel","nodeSel","canJoin","joinPoint","join","joinDown","$from","$to","newlineInCode","$anchor","code","sameParent","insertText","defaultBlockAt","match","edgeCount","edge","hasRequiredAttrs","exitCode","above","indexAfter","contentMatchAt","canReplaceWith","replaceWith","createAndFill","near","createParagraphNear","AllSelection","inlineContent","insert","liftEmptyBlock","end","canSplit","split","splitBlock","isBlock","splitDepth","deflt","types","atEnd","atStart","d","start","splitType","splitNode","unshift","splitPos","can","first","$first","setNodeMarkup","selectParentNode","same","sharedDepth","dir","conn","isolated","compatibleContent","canReplace","joinMaybeClear","canDelAfter","findWrapping","matchType","validEnd","wrap","Fragment","copy","ReplaceAroundStep","$joinAt","selAfter","at","push","afterDepth","selectTextblockSide","isInline","selectTextblockStart","selectTextblockEnd","wrapIn","nodeType","attrs","wrapping","setBlockType","applicable","ranges","nodesBetween","hasMarkup","chainCommands","_len","commands","Array","_key","backspace","del","pcBaseKeymap","selectAll","macBaseKeymap","key","navigator","test","platform","os","dropCursor","options","Plugin","editorView","DropCursorView","constructor","_a","this","cursorPos","timeout","width","color","class","handlers","handler","e","dom","addEventListener","destroy","forEach","_ref","removeEventListener","update","prevState","setCursor","updateOverlay","parentNode","removeChild","rect","nodeDOM","nodeRect","getBoundingClientRect","top","bottom","left","right","coords","coordsAtPos","parentLeft","parentTop","offsetParent","appendChild","document","createElement","className","style","cssText","backgroundColor","classList","toggle","body","getComputedStyle","position","pageXOffset","pageYOffset","scrollLeft","scrollTop","height","scheduleRemoval","clearTimeout","setTimeout","dragover","event","editable","posAtCoords","clientX","clientY","inside","nodeAt","disableDropCursor","disabled","dragging","dropPoint","dragend","drop","dragleave","contains","relatedTarget","GapCursor","super","head","valid","eq","other","toJSON","fromJSON","json","RangeError","getBookmark","GapBookmark","anchor","closedBefore","closedAfter","override","allowGapCursor","defaultType","findGapCursorFrom","mustMove","search","next","$cur","isText","prototype","visible","jsonID","gapCursor","decorations","drawGapCursor","createSelectionBetween","_view","handleClick","handleKeyDown","handleDOMEvents","beforeinput","keydownHandler","arrow","axis","dirStr","$start","$found","clickPos","inputType","schema","nodes","text","frag","replace","DecorationSet","Decoration","widget","Branch","items","eventCount","popEvent","preserveItems","remap","mapFrom","get","remapping","maps","remaining","transform","addAfter","addBefore","item","Item","maybeStep","appendMap","append","reverse","concat","addTransform","histOptions","newItems","oldItems","lastItem","steps","merged","invert","docs","merge","pop","overflow","DEPTH_OVERFLOW","n","cutPoint","cutOffEvents","Mapping","mirrorPos","mirrorOffset","addMaps","rebased","rebasedTransform","rebasedCount","rebasedItems","Math","max","newUntil","iRebased","getMirror","min","newMaps","branch","emptyItemCount","compress","count","upto","events","getMap","newItem","last","RopeSequence","HistoryState","done","undone","prevRanges","prevTime","prevComposition","rangesFor","result","_from","_to","mapRanges","cachedPreserveItems","cachedPreserveItemsPlugins","mustPreserveItems","plugins","historyPreserveItems","historyKey","PluginKey","closeHistoryKey","history","config","newGroupDelay","init","apply","hist","historyTr","getMeta","historyState","appended","redo","composition","newGroup","time","docChanged","adjacent","isAdjacentTo","applyTransaction","command","undo","preventDefault","buildCommand","scroll","getState","added","newHist","setMeta","histTransaction","mac","normalizeKeyName","alt","ctrl","shift","meta","parts","mod","modifiers","altKey","ctrlKey","metaKey","shiftKey","keymap","bindings","Object","prop","normalize","baseName","keyName","direct","noShift","charCodeAt","base","keyCode","fromCode"],"sourceRoot":""}