prosemirror-view 0.20.1 → 0.20.5

package/dist/browser.js

@@ -9,6 +9,7 @@ if (typeof navigator != "undefined") {
   var ie = result.ie = !!(ie_upto10 || ie_11up || ie_edge)
   result.ie_version = ie_upto10 ? document.documentMode || 6 : ie_11up ? +ie_11up[1] : ie_edge ? +ie_edge[1] : null
   result.gecko = !ie && /gecko\/\d/i.test(navigator.userAgent)
+  result.chrome = !ie && /Chrome\//.test(navigator.userAgent)
   result.ios = !ie && /AppleWebKit/.test(navigator.userAgent) && /Mobile\/\w+/.test(navigator.userAgent)
   result.webkit = !ie && 'WebkitAppearance' in document.documentElement.style
 }

package/dist/capturekeys.js

@@ -209,9 +209,9 @@ function getMods(event) {
 
 function captureKeyDown(view, event) {
   var code = event.keyCode, mods = getMods(event)
-  if (code == 8) { // Backspace
+  if (code == 8 || (browser.mac && code == 72 && mods == "c")) { // Backspace, Ctrl-h on Mac
     return stopNativeHorizontalDelete(view, -1) || skipIgnoredNodesLeft(view)
-  } else if (code == 46) { // Delete
+  } else if (code == 46 || (browser.mac && code == 68 && mods == "c")) { // Delete, Ctrl-d on Mac
     return stopNativeHorizontalDelete(view, 1) || skipIgnoredNodesRight(view)
   } else if (code == 13 || code == 27) { // Enter, Esc
     return true
@@ -226,10 +226,6 @@ function captureKeyDown(view, event) {
   } else if (mods == (browser.mac ? "m" : "c") &&
              (code == 66 || code == 73 || code == 89 || code == 90)) { // Mod-[biyz]
     return true
-  } else if (browser.mac && // Ctrl-[dh] and Alt-d on Mac
-             ((code == 68 || code == 72) && mods == "c") ||
-              (code == 68 && mods == "a")) {
-    return stopNativeHorizontalDelete(view, code == 68 ? 1 : -1) || skipIgnoredNodesRight(view)
   }
   return false
 }

package/dist/clipboard.js

@@ -4,8 +4,6 @@ var Fragment = ref.Fragment;
 var DOMParser = ref.DOMParser;
 var DOMSerializer = ref.DOMSerializer;
 
-var browser = require("./browser")
-
 function serializeForClipboard(view, slice) {
   var context = [];
   var content = slice.content;
@@ -35,7 +33,7 @@ exports.serializeForClipboard = serializeForClipboard
 // Read a slice of content from the clipboard (or drop data).
 function parseFromClipboard(view, text, html, plainText, $context) {
   var dom, inCode = $context.parent.type.spec.code
-  if (!html && (!text || browser.ie && !(inCode, plainText))) { return null }
+  if (!html && !text) { return null }
   if ((plainText || inCode || !html) && text) {
     view.someProp("transformPastedText", function (f) { return text = f(text); })
     if (inCode) { return new Slice(Fragment.from(view.state.schema.text(text)), 0, 0) }

package/dist/dom.js

@@ -27,12 +27,14 @@ exports.isEquivalentPosition = function(node, off, targetNode, targetOff) {
                         scanFor(node, off, targetNode, targetOff, 1))
 }
 
+var atomElements = /^(img|br|input|textarea|hr)$/i
+
 function scanFor(node, off, targetNode, targetOff, dir) {
   for (;;) {
     if (node == targetNode && off == targetOff) { return true }
     if (off == (dir < 0 ? 0 : nodeSize(node))) {
       var parent = node.parentNode
-      if (parent.nodeType != 1 || hasBlockDesc(parent)) { return false }
+      if (parent.nodeType != 1 || hasBlockDesc(node) || atomElements.test(node.nodeName)) { return false }
       off = domIndex(node) + (dir < 0 ? 0 : 1)
       node = parent
     } else if (node.nodeType == 1) {

package/dist/domcoords.js

@@ -197,10 +197,13 @@ function posAtCoords(view, coords) {
       ((assign$1 = range, node = assign$1.startContainer, offset = assign$1.startOffset)) }
   }
 
-  var elt = root.elementFromPoint(coords.left, coords.top + 1)
+  var elt = root.elementFromPoint(coords.left, coords.top + 1), pos
   if (!elt) { return null }
-  var pos = node ? posFromCaret(view, node, offset, coords) : posFromElement(view, elt, coords)
-  if (pos == null) { return null }
+  if (node) { pos = posFromCaret(view, node, offset, coords) }
+  if (pos == null) {
+    pos = posFromElement(view, elt, coords)
+    if (pos == null) { return null }
+  }
 
   var desc = view.docView.nearestDesc(elt, true)
   return {pos: pos, inside: desc ? desc.posAtStart - desc.border : -1}

package/dist/input.js

@@ -419,14 +419,16 @@ function sliceSingleNode(slice) {
 }
 
 function capturePaste(view, e) {
-  var target = document.body.appendChild(document.createElement("div"))
+  var plainText = view.shiftKey || view.state.selection.$from.parent.type.spec.code
+  var target = document.body.appendChild(document.createElement(plainText ? "textarea" : "div"))
+  if (!plainText) { target.contentEditable = "true" }
   target.style.cssText = "position: fixed; left: -10000px; top: 10px"
-  target.contentEditable = "true"
   target.focus()
   setTimeout(function () {
     view.focus()
     document.body.removeChild(target)
-    doPaste(view, target.textContent, target.innerHTML, e)
+    if (plainText) { doPaste(view, target.value, null, e) }
+    else { doPaste(view, target.textContent, target.innerHTML, e) }
   }, 50)
 }
 
@@ -484,8 +486,8 @@ handlers.dragstart = function (view, e) {
   }
   var slice = view.state.selection.content(), dom = serializeForClipboard(view, slice)
   e.dataTransfer.clearData()
-  e.dataTranser.setData("text/html", dom.innerHTML)
-  e.dataTranser.setData("text/plain", slice.content.textBetween(0, slice.content.size, "\n\n"))
+  e.dataTransfer.setData("text/html", dom.innerHTML)
+  e.dataTransfer.setData("text/plain", slice.content.textBetween(0, slice.content.size, "\n\n"))
   view.dragging = new Dragging(slice, !e.ctrlKey)
 }
 

package/dist/selection.js

@@ -75,8 +75,8 @@ SelectionReader.prototype.readFromDOM = function (origin) {
   if (selectionCollapsed(domSel)) {
     $anchor = $head
     while (nearestDesc && !nearestDesc.node) { nearestDesc = nearestDesc.parent }
-    if (nearestDesc && nearestDesc.node.isAtom && NodeSelection.isSelectable(nearestDesc.node)) {
-      var pos = nearestDesc.posAtStart
+    if (nearestDesc && nearestDesc.node.isAtom && NodeSelection.isSelectable(nearestDesc.node) && nearestDesc.parent) {
+      var pos = nearestDesc.posBefore
       selection = new NodeSelection(head == pos ? $head : doc.resolve(pos))
     }
   } else {
@@ -287,5 +287,5 @@ exports.selectionBetween = selectionBetween
 function hasFocusAndSelection(view) {
   if (view.editable && view.root.activeElement != view.dom) { return false }
   var sel = view.root.getSelection()
-  return sel.rangeCount && view.dom.contains(sel.anchorNode.nodeType == 3 ? sel.anchorNode.parentNode : sel.anchorNode)
+  return sel.anchorNode && view.dom.contains(sel.anchorNode.nodeType == 3 ? sel.anchorNode.parentNode : sel.anchorNode)
 }

package/dist/viewdesc.js

@@ -282,6 +282,9 @@ ViewDesc.prototype.parseRange = function (from, to, base) {
     var this$1 = this;
     if ( base === void 0 ) base = 0;
 
+  if (this.children.length == 0)
+    { return {node: this.contentDOM, from: from, to: to, fromOffset: 0, toOffset: this.contentDOM.childNodes.length} }
+
   var fromOffset = -1, toOffset = -1
   for (var offset = 0, i = 0;; i++) {
     var child = this$1.children[i], end = offset + child.size
@@ -703,7 +706,8 @@ var TextViewDesc = (function (NodeViewDesc) {
   TextViewDesc.prototype.constructor = TextViewDesc;
 
   TextViewDesc.prototype.parseRule = function () {
-    return {skip: this.nodeDOM.parentNode}
+    var parent = this.nodeDOM.parentNode
+    return parent ? {skip: parent} : {ignore: true}
   };
 
   TextViewDesc.prototype.update = function (node, outerDeco) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-view",
-  "version": "0.20.1",
+  "version": "0.20.5",
   "description": "ProseMirror's view component",
   "main": "dist/index.js",
   "style": "style/prosemirror.css",

package/src/browser.js

@@ -9,6 +9,7 @@ if (typeof navigator != "undefined") {
   let ie = result.ie = !!(ie_upto10 || ie_11up || ie_edge)
   result.ie_version = ie_upto10 ? document.documentMode || 6 : ie_11up ? +ie_11up[1] : ie_edge ? +ie_edge[1] : null
   result.gecko = !ie && /gecko\/\d/i.test(navigator.userAgent)
+  result.chrome = !ie && /Chrome\//.test(navigator.userAgent)
   result.ios = !ie && /AppleWebKit/.test(navigator.userAgent) && /Mobile\/\w+/.test(navigator.userAgent)
   result.webkit = !ie && 'WebkitAppearance' in document.documentElement.style
 }

package/src/capturekeys.js

@@ -199,9 +199,9 @@ function getMods(event) {
 
 function captureKeyDown(view, event) {
   let code = event.keyCode, mods = getMods(event)
-  if (code == 8) { // Backspace
+  if (code == 8 || (browser.mac && code == 72 && mods == "c")) { // Backspace, Ctrl-h on Mac
     return stopNativeHorizontalDelete(view, -1) || skipIgnoredNodesLeft(view)
-  } else if (code == 46) { // Delete
+  } else if (code == 46 || (browser.mac && code == 68 && mods == "c")) { // Delete, Ctrl-d on Mac
     return stopNativeHorizontalDelete(view, 1) || skipIgnoredNodesRight(view)
   } else if (code == 13 || code == 27) { // Enter, Esc
     return true
@@ -216,10 +216,6 @@ function captureKeyDown(view, event) {
   } else if (mods == (browser.mac ? "m" : "c") &&
              (code == 66 || code == 73 || code == 89 || code == 90)) { // Mod-[biyz]
     return true
-  } else if (browser.mac && // Ctrl-[dh] and Alt-d on Mac
-             ((code == 68 || code == 72) && mods == "c") ||
-              (code == 68 && mods == "a")) {
-    return stopNativeHorizontalDelete(view, code == 68 ? 1 : -1) || skipIgnoredNodesRight(view)
   }
   return false
 }

package/src/clipboard.js

@@ -1,7 +1,5 @@
 const {Slice, Fragment, DOMParser, DOMSerializer} = require("prosemirror-model")
 
-const browser = require("./browser")
-
 function serializeForClipboard(view, slice) {
   let context = [], {content, openLeft, openRight} = slice
   while (openLeft > 1 && openRight > 1 && content.childCount == 1 && content.firstChild.childCount == 1) {
@@ -28,7 +26,7 @@ exports.serializeForClipboard = serializeForClipboard
 // Read a slice of content from the clipboard (or drop data).
 function parseFromClipboard(view, text, html, plainText, $context) {
   let dom, inCode = $context.parent.type.spec.code
-  if (!html && (!text || browser.ie && !(inCode, plainText))) return null
+  if (!html && !text) return null
   if ((plainText || inCode || !html) && text) {
     view.someProp("transformPastedText", f => text = f(text))
     if (inCode) return new Slice(Fragment.from(view.state.schema.text(text)), 0, 0)

package/src/dom.js

@@ -27,12 +27,14 @@ exports.isEquivalentPosition = function(node, off, targetNode, targetOff) {
                         scanFor(node, off, targetNode, targetOff, 1))
 }
 
+const atomElements = /^(img|br|input|textarea|hr)$/i
+
 function scanFor(node, off, targetNode, targetOff, dir) {
   for (;;) {
     if (node == targetNode && off == targetOff) return true
     if (off == (dir < 0 ? 0 : nodeSize(node))) {
       let parent = node.parentNode
-      if (parent.nodeType != 1 || hasBlockDesc(parent)) return false
+      if (parent.nodeType != 1 || hasBlockDesc(node) || atomElements.test(node.nodeName)) return false
       off = domIndex(node) + (dir < 0 ? 0 : 1)
       node = parent
     } else if (node.nodeType == 1) {

package/src/domcoords.js

@@ -183,10 +183,13 @@ function posAtCoords(view, coords) {
     if (range) ({startContainer: node, startOffset: offset} = range)
   }
 
-  let elt = root.elementFromPoint(coords.left, coords.top + 1)
+  let elt = root.elementFromPoint(coords.left, coords.top + 1), pos
   if (!elt) return null
-  let pos = node ? posFromCaret(view, node, offset, coords) : posFromElement(view, elt, coords)
-  if (pos == null) return null
+  if (node) pos = posFromCaret(view, node, offset, coords)
+  if (pos == null) {
+    pos = posFromElement(view, elt, coords)
+    if (pos == null) return null
+  }
 
   let desc = view.docView.nearestDesc(elt, true)
   return {pos, inside: desc ? desc.posAtStart - desc.border : -1}

package/src/input.js

@@ -402,14 +402,16 @@ function sliceSingleNode(slice) {
 }
 
 function capturePaste(view, e) {
-  let target = document.body.appendChild(document.createElement("div"))
+  let plainText = view.shiftKey || view.state.selection.$from.parent.type.spec.code
+  let target = document.body.appendChild(document.createElement(plainText ? "textarea" : "div"))
+  if (!plainText) target.contentEditable = "true"
   target.style.cssText = "position: fixed; left: -10000px; top: 10px"
-  target.contentEditable = "true"
   target.focus()
   setTimeout(() => {
     view.focus()
     document.body.removeChild(target)
-    doPaste(view, target.textContent, target.innerHTML, e)
+    if (plainText) doPaste(view, target.value, null, e)
+    else doPaste(view, target.textContent, target.innerHTML, e)
   }, 50)
 }
 
@@ -469,8 +471,8 @@ handlers.dragstart = (view, e) => {
   }
   let slice = view.state.selection.content(), dom = serializeForClipboard(view, slice)
   e.dataTransfer.clearData()
-  e.dataTranser.setData("text/html", dom.innerHTML)
-  e.dataTranser.setData("text/plain", slice.content.textBetween(0, slice.content.size, "\n\n"))
+  e.dataTransfer.setData("text/html", dom.innerHTML)
+  e.dataTransfer.setData("text/plain", slice.content.textBetween(0, slice.content.size, "\n\n"))
   view.dragging = new Dragging(slice, !e.ctrlKey)
 }
 

package/src/selection.js

@@ -71,8 +71,8 @@ class SelectionReader {
     if (selectionCollapsed(domSel)) {
       $anchor = $head
       while (nearestDesc && !nearestDesc.node) nearestDesc = nearestDesc.parent
-      if (nearestDesc && nearestDesc.node.isAtom && NodeSelection.isSelectable(nearestDesc.node)) {
-        let pos = nearestDesc.posAtStart
+      if (nearestDesc && nearestDesc.node.isAtom && NodeSelection.isSelectable(nearestDesc.node) && nearestDesc.parent) {
+        let pos = nearestDesc.posBefore
         selection = new NodeSelection(head == pos ? $head : doc.resolve(pos))
       }
     } else {
@@ -282,5 +282,5 @@ exports.selectionBetween = selectionBetween
 function hasFocusAndSelection(view) {
   if (view.editable && view.root.activeElement != view.dom) return false
   let sel = view.root.getSelection()
-  return sel.rangeCount && view.dom.contains(sel.anchorNode.nodeType == 3 ? sel.anchorNode.parentNode : sel.anchorNode)
+  return sel.anchorNode && view.dom.contains(sel.anchorNode.nodeType == 3 ? sel.anchorNode.parentNode : sel.anchorNode)
 }

package/src/viewdesc.js

@@ -257,6 +257,9 @@ class ViewDesc {
   // Used to find a DOM range in a single parent for a given changed
   // range.
   parseRange(from, to, base = 0) {
+    if (this.children.length == 0)
+      return {node: this.contentDOM, from, to, fromOffset: 0, toOffset: this.contentDOM.childNodes.length}
+
     let fromOffset = -1, toOffset = -1
     for (let offset = 0, i = 0;; i++) {
       let child = this.children[i], end = offset + child.size
@@ -633,7 +636,8 @@ class TextViewDesc extends NodeViewDesc {
   }
 
   parseRule() {
-    return {skip: this.nodeDOM.parentNode}
+    let parent = this.nodeDOM.parentNode
+    return parent ? {skip: parent} : {ignore: true}
   }
 
   update(node, outerDeco) {

package/src/#input.js#

@@ -1,532 +0,0 @@
-const {Selection, NodeSelection, TextSelection} = require("prosemirror-state")
-
-const browser = require("./browser")
-const {captureKeyDown} = require("./capturekeys")
-const {DOMChange} = require("./domchange")
-const {parseFromClipboard, serializeForClipboard} = require("./clipboard")
-const {DOMObserver} = require("./domobserver")
-const {selectionBetween} = require("./selection")
-
-// A collection of DOM events that occur within the editor, and callback functions
-// to invoke when the event fires.
-const handlers = {}, editHandlers = {}
-
-function initInput(view) {
-  view.shiftKey = false
-  view.mouseDown = null
-  view.dragging = null
-  view.inDOMChange = null
-  view.domObserver = new DOMObserver(view)
-  view.domObserver.start()
-
-  for (let event in handlers) {
-    let handler = handlers[event]
-    view.dom.addEventListener(event, event => {
-      if (eventBelongsToView(view, event) && !runCustomHandler(view, event) &&
-          (view.editable || !(event.type in editHandlers)))
-        handler(view, event)
-    })
-  }
-  view.extraHandlers = Object.create(null)
-  ensureListeners(view)
-}
-exports.initInput = initInput
-
-function destroyInput(view) {
-  view.domObserver.stop()
-  if (view.inDOMChange) view.inDOMChange.destroy()
-}
-exports.destroyInput = destroyInput
-
-function ensureListeners(view) {
-  view.someProp("handleDOMEvents", currentHandlers => {
-    for (let type in currentHandlers) if (!view.extraHandlers[type] && !handlers.hasOwnProperty(type)) {
-      view.extraHandlers[type] = true
-      view.dom.addEventListener(type, event => runCustomHandler(view, event))
-    }
-  })
-}
-exports.ensureListeners = ensureListeners
-
-function runCustomHandler(view, event) {
-  return view.someProp("handleDOMEvents", handlers => {
-    let handler = handlers[event.type]
-    return handler ? handler(view, event) || event.defaultPrevented : false
-  })
-}
-
-function eventBelongsToView(view, event) {
-  if (!event.bubbles) return true
-  if (event.defaultPrevented) return false
-  for (let node = event.target; node != view.dom; node = node.parentNode)
-    if (!node || node.nodeType == 11 ||
-        (node.pmViewDesc && node.pmViewDesc.stopEvent(event)))
-      return false
-  return true
-}
-
-function dispatchEvent(view, event) {
-  if (!runCustomHandler(view, event) && handlers[event.type] &&
-      (view.editable || !(event.type in editHandlers)))
-    handlers[event.type](view, event)
-}
-exports.dispatchEvent = dispatchEvent
-
-editHandlers.keydown = (view, event) => {
-  if (event.keyCode == 16) view.shiftKey = true
-  if (view.inDOMChange) return
-  if (view.someProp("handleKeyDown", f => f(view, event)) || captureKeyDown(view, event))
-    event.preventDefault()
-  else
-    view.selectionReader.poll()
-}
-
-editHandlers.keyup = (view, e) => {
-  if (e.keyCode == 16) view.shiftKey = false
-}
-
-editHandlers.keypress = (view, event) => {
-  if (view.inDOMChange || !event.charCode ||
-      event.ctrlKey && !event.altKey || browser.mac && event.metaKey) return
-
-  if (view.someProp("handleKeyPress", f => f(view, event))) {
-    event.preventDefault()
-    return
-  }
-
-  let sel = view.state.selection
-  if (!(sel instanceof TextSelection) || !sel.$from.sameParent(sel.$to)) {
-    let text = String.fromCharCode(event.charCode)
-    if (!view.someProp("handleTextInput", f => f(view, sel.$from.pos, sel.$to.pos, text)))
-      view.dispatch(view.state.tr.insertText(text).scrollIntoView())
-    event.preventDefault()
-  }
-}
-
-function eventCoords(event) { return {left: event.clientX, top: event.clientY} }
-
-let lastClick = {time: 0, x: 0, y: 0}, oneButLastClick = lastClick
-
-function isNear(event, click) {
-  let dx = click.x - event.clientX, dy = click.y - event.clientY
-  return dx * dx + dy * dy < 100
-}
-
-function runHandlerOnContext(view, propName, pos, inside, event) {
-  if (inside == -1) return false
-  let $pos = view.state.doc.resolve(inside)
-  for (let i = $pos.depth + 1; i > 0; i--) {
-    if (view.someProp(propName, f => i > $pos.depth ? f(view, pos, $pos.nodeAfter, $pos.before(i), event, true)
-                                                    : f(view, pos, $pos.node(i), $pos.before(i), event, false)))
-      return true
-  }
-  return false
-}
-
-function updateSelection(view, selection, origin) {
-  if (!view.focused) view.focus()
-  let tr = view.state.tr.setSelection(selection)
-  if (origin == "pointer") tr.setMeta("pointer", true)
-  view.dispatch(tr)
-}
-
-function selectClickedLeaf(view, inside) {
-  if (inside == -1) return false
-  let $pos = view.state.doc.resolve(inside), node = $pos.nodeAfter
-  if (node && node.isAtom && NodeSelection.isSelectable(node)) {
-    updateSelection(view, new NodeSelection($pos), "pointer")
-    return true
-  }
-  return false
-}
-
-function selectClickedNode(view, inside) {
-  if (inside == -1) return false
-  let sel = view.state.selection, selectedNode, selectAt
-  if (sel instanceof NodeSelection) selectedNode = sel.node
-
-  let $pos = view.state.doc.resolve(inside)
-  for (let i = $pos.depth + 1; i > 0; i--) {
-    let node = i > $pos.depth ? $pos.nodeAfter : $pos.node(i)
-    if (NodeSelection.isSelectable(node)) {
-      if (selectedNode && sel.$from.depth > 0 &&
-          i >= sel.$from.depth && $pos.before(sel.$from.depth + 1) == sel.$from.pos)
-        selectAt = $pos.before(sel.$from.depth)
-      else
-        selectAt = $pos.before(i)
-      break
-    }
-  }
-
-  if (selectAt != null) {
-    updateSelection(view, NodeSelection.create(view.state.doc, selectAt), "pointer")
-    return true
-  } else {
-    return false
-  }
-}
-
-function handleSingleClick(view, pos, inside, event, selectNode) {
-  return runHandlerOnContext(view, "handleClickOn", pos, inside, event) ||
-    view.someProp("handleClick", f => f(view, pos, event)) ||
-    (selectNode ? selectClickedNode(view, inside) : selectClickedLeaf(view, inside))
-}
-
-function handleDoubleClick(view, pos, inside, event) {
-  return runHandlerOnContext(view, "handleDoubleClickOn", pos, inside, event) ||
-    view.someProp("handleDoubleClick", f => f(view, pos, event))
-}
-
-function handleTripleClick(view, pos, inside, event) {
-  return runHandlerOnContext(view, "handleTripleClickOn", pos, inside, event) ||
-    view.someProp("handleTripleClick", f => f(view, pos, event)) ||
-    defaultTripleClick(view, inside)
-}
-
-function defaultTripleClick(view, inside) {
-  let doc = view.state.doc
-  if (inside == -1) {
-    if (doc.inlineContent) {
-      updateSelection(view, TextSelection.create(doc, 0, doc.content.size), "pointer")
-      return true
-    }
-    return false
-  }
-
-  let $pos = doc.resolve(inside)
-  for (let i = $pos.depth + 1; i > 0; i--) {
-    let node = i > $pos.depth ? $pos.nodeAfter : $pos.node(i)
-    let nodePos = $pos.before(i)
-    if (node.inlineContent)
-      updateSelection(view, TextSelection.create(doc, nodePos + 1, nodePos + 1 + node.content.size), "pointer")
-    else if (NodeSelection.isSelectable(node))
-      updateSelection(view, NodeSelection.create(doc, nodePos), "pointer")
-    else
-      continue
-    return true
-  }
-}
-
-function forceDOMFlush(view) {
-  if (!view.inDOMChange) return false
-  view.inDOMChange.finish(true)
-  return true
-}
-
-const selectNodeModifier = browser.mac ? "metaKey" : "ctrlKey"
-
-handlers.mousedown = (view, event) => {
-  let flushed = forceDOMFlush(view)
-  let now = Date.now(), type
-  if (now - lastClick.time >= 500 || !isNear(event, lastClick) || event[selectNodeModifier]) type = "singleClick"
-  else if (now - oneButLastClick.time >= 600 || !isNear(event, oneButLastClick)) type = "doubleClick"
-  else type = "tripleClick"
-  oneButLastClick = lastClick
-  lastClick = {time: now, x: event.clientX, y: event.clientY}
-
-  let pos = view.posAtCoords(eventCoords(event))
-  if (!pos) return
-
-  if (type == "singleClick")
-    view.mouseDown = new MouseDown(view, pos, event, flushed)
-  else if ((type == "doubleClick" ? handleDoubleClick : handleTripleClick)(view, pos.pos, pos.inside, event))
-    event.preventDefault()
-  else
-    view.selectionReader.poll("pointer")
-}
-
-class MouseDown {
-  constructor(view, pos, event, flushed) {
-    this.view = view
-    this.pos = pos
-    this.event = event
-    this.flushed = flushed
-    this.selectNode = event[selectNodeModifier]
-    this.allowDefault = event.shiftKey
-
-    let targetNode, targetPos
-    if (pos.inside > -1) {
-      targetNode = view.state.doc.nodeAt(pos.inside)
-      targetPos = pos.inside
-    } else {
-      let $pos = view.state.doc.resolve(pos.pos)
-      targetNode = $pos.parent
-      targetPos = $pos.depth ? $pos.before() : 0
-    }
-
-    this.mightDrag = null
-    if (targetNode.type.spec.draggable && targetNode.type.spec.selectable !== false ||
-        view.state.selection instanceof NodeSelection && targetPos == view.state.selection.from)
-      this.mightDrag = {node: targetNode, pos: targetPos}
-
-    this.target = flushed ? null : event.target
-    if (this.target && this.mightDrag) {
-      this.view.domObserver.stop()
-      this.target.draggable = true
-      if (browser.gecko && (this.setContentEditable = !this.target.hasAttribute("contentEditable")))
-        setTimeout(() => this.target.setAttribute("contentEditable", "false"), 20)
-      this.view.domObserver.start()
-    }
-
-    view.root.addEventListener("mouseup", this.up = this.up.bind(this))
-    view.root.addEventListener("mousemove", this.move = this.move.bind(this))
-    view.selectionReader.poll("pointer")
-  }
-
-  done() {
-    this.view.root.removeEventListener("mouseup", this.up)
-    this.view.root.removeEventListener("mousemove", this.move)
-    if (this.mightDrag && this.target) {
-      this.view.domObserver.stop()
-      this.target.draggable = false
-      if (browser.gecko && this.setContentEditable)
-        this.target.removeAttribute("contentEditable")
-      this.view.domObserver.start()
-    }
-  }
-
-  up(event) {
-    this.done()
-
-    if (!this.view.dom.contains(event.target.nodeType == 3 ? event.target.parentNode : event.target))
-      return
-
-    if (this.allowDefault) {
-      this.view.selectionReader.poll("pointer")
-    } else if (handleSingleClick(this.view, this.pos.pos, this.pos.inside, event, this.selectNode)) {
-      event.preventDefault()
-    } else if (this.flushed) {
-      updateSelection(this.view, Selection.near(this.view.state.doc.resolve(this.pos.pos)), "pointer")
-      event.preventDefault()
-    } else {
-      this.view.selectionReader.poll("pointer")
-    }
-  }
-
-  move(event) {
-    if (!this.allowDefault && (Math.abs(this.event.x - event.clientX) > 4 ||
-                               Math.abs(this.event.y - event.clientY) > 4))
-      this.allowDefault = true
-    this.view.selectionReader.poll("pointer")
-  }
-}
-
-handlers.touchdown = view => {
-  forceDOMFlush(view)
-  view.selectionReader.poll("pointer")
-}
-
-handlers.contextmenu = (view, e) => {
-  forceDOMFlush(view)
-  let pos = view.posAtCoords(eventCoords(e))
-  if (pos && view.someProp("handleContextMenu", f => f(view, pos.pos, e)))
-    e.preventDefault()
-}
-
-// Input compositions are hard. Mostly because the events fired by
-// browsers are A) very unpredictable and inconsistent, and B) not
-// cancelable.
-//
-// ProseMirror has the problem that it must not update the DOM during
-// a composition, or the browser will cancel it. What it does is keep
-// long-running operations (delayed DOM updates) when a composition is
-// active.
-//
-// We _do not_ trust the information in the composition events which,
-// apart from being very uninformative to begin with, is often just
-// plain wrong. Instead, when a composition ends, we parse the dom
-// around the original selection, and derive an update from that.
-
-editHandlers.compositionstart = editHandlers.compositionupdate = view => {
-  DOMChange.start(view, true)
-}
-
-editHandlers.compositionend = (view, e) => {
-  if (!view.inDOMChange) {
-    // We received a compositionend without having seen any previous
-    // events for the composition. If there's data in the event
-    // object, we assume that it's a real change, and start a
-    // composition. Otherwise, we just ignore it.
-    if (e.data) DOMChange.start(view, true)
-    else return
-  }
-
-  view.inDOMChange.compositionEnd()
-}
-
-editHandlers.input = view => DOMChange.start(view)
-
-function captureCopy(view, dom) {
-  // The extra wrapper is somehow necessary on IE/Edge to prevent the
-  // content from being mangled when it is put onto the clipboard
-  let wrap = document.body.appendChild(document.createElement("div"))
-  wrap.appendChild(dom)
-  wrap.style.cssText = "position: fixed; left: -10000px; top: 10px"
-  let sel = getSelection(), range = document.createRange()
-  range.selectNodeContents(dom)
-  sel.removeAllRanges()
-  sel.addRange(range)
-  setTimeout(() => {
-    document.body.removeChild(wrap)
-    view.focus()
-  }, 50)
-}
-
-// This is very crude, but unfortunately both these browsers _pretend_
-// that they have a clipboard API---all the objects and methods are there
-const brokenClipboardAPI = browser.ie || browser.ios
-
-handlers.copy = editHandlers.cut = (view, e) => {
-  let sel = view.state.selection, cut = e.type == "cut"
-  if (sel.empty) return
-
-  // IE and Edge's clipboard interface is completely broken
-  let data = brokenClipboardAPI ? null : e.clipboardData
-  let slice = sel.content(), dom = serializeForClipboard(view, slice)
-  if (data) {
-    e.preventDefault()
-    data.clearData()
-    data.setData("text/html", dom.innerHTML)
-    data.setData("text/plain", slice.content.textBetween(0, slice.content.size, "\n\n"))
-  } else {
-    captureCopy(view, dom)
-  }
-  if (cut) view.dispatch(view.state.tr.deleteSelection().scrollIntoView())
-}
-
-function sliceSingleNode(slice) {
-  return slice.openLeft == 0 && slice.openRight == 0 && slice.content.childCount == 1 ? slice.content.firstChild : null
-}
-
-function capturePaste(view, e) {
-  let target = document.body.appendChild(document.createElement("div"))
-  target.style.cssText = "position: fixed; left: -10000px; top: 10px"
-  target.contentEditable = "true"
-  target.focus()
-  setTimeout(() => {
-    view.focus()
-    document.body.removeChild(target)
-    doPaste(view, target.textContent, target.innerHTML, e)
-  }, 50)
-}
-
-function doPaste(view, text, html, e) {
-  let slice = parseFromClipboard(view, text, html, view.shiftKey, view.state.selection.$from)
-  if (!slice) return false
-
-  if (view.someProp("handlePaste", f => f(view, e, slice))) return true
-
-  let singleNode = sliceSingleNode(slice)
-  let tr = singleNode ? view.state.tr.replaceSelectionWith(singleNode) : view.state.tr.replaceSelection(slice)
-  view.dispatch(tr.scrollIntoView())
-  return true
-}
-
-editHandlers.paste = (view, e) => {
-  let data = brokenClipboardAPI ? null : e.clipboardData
-  if (data && doPaste(view, data.getData("text/plain"), data.getData("text/html"), e))
-    e.preventDefault()
-  else
-    capturePaste(view, e)
-}
-
-class Dragging {
-  constructor(slice, move) {
-    this.slice = slice
-    this.move = move
-  }
-}
-
-function dropPos(slice, $pos) {
-  if (!slice || !slice.content.size) return $pos.pos
-  let content = slice.content
-  for (let i = 0; i < slice.openLeft; i++) content = content.firstChild.content
-  for (let d = $pos.depth; d >= 0; d--) {
-    let bias = d == $pos.depth ? 0 : $pos.pos <= ($pos.start(d + 1) + $pos.end(d + 1)) / 2 ? -1 : 1
-    let insertPos = $pos.index(d) + (bias > 0 ? 1 : 0)
-    if ($pos.node(d).canReplace(insertPos, insertPos, content))
-      return bias == 0 ? $pos.pos : bias < 0 ? $pos.before(d + 1) : $pos.after(d + 1)
-  }
-  return $pos.pos
-}
-
-handlers.dragstart = (view, e) => {
-  let mouseDown = view.mouseDown
-  if (mouseDown) mouseDown.done()
-  if (!e.dataTransfer) return
-
-  let sel = view.state.selection
-  let pos = sel.empty ? null : view.posAtCoords(eventCoords(e))
-  if (pos && pos.pos >= sel.from && pos.pos <= sel.to) {
-    // In selection
-  } else if (mouseDown && mouseDown.mightDrag) {
-    view.dispatch(view.state.tr.setSelection(NodeSelection.create(view.state.doc, mouseDown.mightDrag.pos)))
-  } else {
-    return
-  }
-  let slice = view.state.selection.content(), dom = serializeForClipboard(view, slice)
-  e.dataTransfer.clearData()
-  e.dataTranser.setData("text/html", dom.innerHTML)
-  e.dataTranser.setData("text/plain", slice.content.textBetween(0, slice.content.size, "\n\n"))
-  view.dragging = new Dragging(slice, !e.ctrlKey)
-}
-
-handlers.dragend = view => {
-  window.setTimeout(() => view.dragging = null, 50)
-}
-
-editHandlers.dragover = editHandlers.dragenter = (_, e) => e.preventDefault()
-
-editHandlers.drop = (view, e) => {
-  let dragging = view.dragging
-  view.dragging = null
-
-  if (!e.dataTransfer) return
-
-  let $mouse = view.state.doc.resolve(view.posAtCoords(eventCoords(e)).pos)
-  if (!$mouse) return
-  let slice = dragging && dragging.slice ||
-      parseFromClipboard(view, e.dataTransfer.getData("text/plain"), e.dataTransfer.getData("text/html"), false, $mouse)
-  if (!slice) return
-
-  e.preventDefault()
-  if (view.someProp("handleDrop", e, slice, dragging && dragging.move)) return
-  let insertPos = dropPos(slice, view.state.doc.resolve($mouse.pos))
-
-  let tr = view.state.tr
-  if (dragging && dragging.move) tr.deleteSelection()
-
-  let pos = tr.mapping.map(insertPos)
-  let isNode = slice.openLeft == 0 && slice.openRight == 0 && slice.content.childCount == 1
-  if (isNode)
-    tr.replaceRangeWith(pos, pos, slice.content.firstChild)
-  else
-    tr.replaceRange(pos, pos, slice)
-  let $pos = tr.doc.resolve(pos)
-  if (isNode && NodeSelection.isSelectable(slice.content.firstChild) &&
-      $pos.nodeAfter && $pos.nodeAfter.sameMarkup(slice.content.firstChild))
-    tr.setSelection(new NodeSelection($pos))
-  else
-    tr.setSelection(selectionBetween(view, $pos, tr.doc.resolve(tr.mapping.map(insertPos))))
-  view.focus()
-  view.dispatch(tr)
-}
-
-handlers.focus = (view, event) => {
-  if (!view.focused) {
-    view.dom.classList.add("ProseMirror-focused")
-    view.focused = true
-  }
-  view.someProp("onFocus", f => { f(view, event) })
-}
-
-handlers.blur = (view, event) => {
-  if (view.focused) {
-    view.dom.classList.remove("ProseMirror-focused")
-    view.focused = false
-  }
-  view.someProp("onBlur", f => { f(view, event) })
-}
-
-// Make sure all handlers get registered
-for (let prop in editHandlers) handlers[prop] = editHandlers[prop]