prosemirror-view 1.42.4 → 1.42.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-view",
-  "version": "1.42.4",
+  "version": "1.42.6",
   "description": "ProseMirror's view component",
   "type": "module",
   "main": "dist/index.cjs",
@@ -28,7 +28,7 @@
     "url": "git+https://code.haverbeke.berlin/prosemirror/prosemirror-view.git"
   },
   "dependencies": {
-    "prosemirror-model": "^1.25.8",
+    "prosemirror-model": "^1.25.12",
     "prosemirror-state": "^1.0.0",
     "prosemirror-transform": "^1.1.0"
   },

package/src/capturekeys.ts

@@ -1,7 +1,7 @@
 import {Selection, NodeSelection, TextSelection, AllSelection, EditorState} from "prosemirror-state"
 import {EditorView} from "./index"
 import * as browser from "./browser"
-import {domIndex, selectionCollapsed, hasBlockDesc} from "./dom"
+import {domIndex, selectionCollapsed, hasBlockDesc, isElt, isText, nodeSize} from "./dom"
 import {selectionToDOM} from "./selection"
 
 function moveSelectionBlock(state: EditorState, dir: number) {
@@ -37,13 +37,13 @@ function selectHorizontally(view: EditorView, dir: number, mods: string) {
       if (!(node.isAtom || (desc = view.docView.descAt(nodePos)) && !desc.contentDOM)) return false
       if (NodeSelection.isSelectable(node)) {
         return apply(view, new NodeSelection(dir < 0 ? view.state.doc.resolve($head.pos - node.nodeSize) : $head))
-      } else if (browser.webkit) {
+      } else {
         // Chrome and Safari will introduce extra pointless cursor
-        // positions around inline uneditable nodes, so we have to
-        // take over and move the cursor past them (#937)
+        // positions around inline uneditable nodes (#937), and
+        // Firefox will sometimes just plain refuse to move across
+        // them (#1592), so in this situation we move the cursor
+        // ourselves.
         return apply(view, new TextSelection(view.state.doc.resolve(dir < 0 ? nodePos : nodePos + node.nodeSize)))
-      } else {
-        return false
       }
     }
   } else if (sel instanceof NodeSelection && sel.node.isInline) {
@@ -55,14 +55,10 @@ function selectHorizontally(view: EditorView, dir: number, mods: string) {
   }
 }
 
-function nodeLen(node: Node) {
-  return node.nodeType == 3 ? node.nodeValue!.length : node.childNodes.length
-}
-
 function isIgnorable(dom: Node, dir: number) {
   let desc = dom.pmViewDesc
   return desc ? desc.size == 0 && (dir < 0 || dom.nextSibling || dom.nodeName != "BR")
-    : dom.nodeType == 1 && (dom as HTMLElement).contentEditable == "false"
+    : isElt(dom) && dom.contentEditable == "false"
 }
 
 function skipIgnoredNodes(view: EditorView, dir: number) {
@@ -79,20 +75,19 @@ function skipIgnoredNodesBefore(view: EditorView) {
   // Gecko will do odd things when the selection is directly in front
   // of a non-editable node, so in that case, move it into the next
   // node if possible. Issue prosemirror/prosemirror#832.
-  if (browser.gecko && node.nodeType == 1 && offset < nodeLen(node) && isIgnorable(node.childNodes[offset], -1)) force = true
+  if (browser.gecko && isElt(node) && offset < nodeSize(node) && isIgnorable(node.childNodes[offset], -1)) force = true
   for (;;) {
     if (offset > 0) {
-      if (node.nodeType != 1) {
-        break
+      if (!isElt(node)) break
+      let before = node.childNodes[offset - 1]
+      if (isIgnorable(before, -1)) {
+        moveNode = node
+        moveOffset = --offset
+      } else if (isText(before)) {
+        node = before
+        offset = node.nodeValue!.length
       } else {
-        let before = node.childNodes[offset - 1]
-        if (isIgnorable(before, -1)) {
-          moveNode = node
-          moveOffset = --offset
-        } else if (before.nodeType == 3) {
-          node = before
-          offset = node.nodeValue!.length
-        } else break
+        break
       }
     } else if (isBlockNode(node)) {
       break
@@ -109,7 +104,7 @@ function skipIgnoredNodesBefore(view: EditorView) {
         offset = 0
       } else {
         node = prev
-        offset = nodeLen(node)
+        offset = nodeSize(node)
       }
     }
   }
@@ -123,17 +118,18 @@ function skipIgnoredNodesAfter(view: EditorView) {
   let sel = view.domSelectionRange()
   let node = sel.focusNode!, offset = sel.focusOffset
   if (!node) return
-  let len = nodeLen(node)
+  let len = nodeSize(node)
   let moveNode, moveOffset: number | undefined
   for (;;) {
     if (offset < len) {
-      if (node.nodeType != 1) break
+      if (!isElt(node)) break
       let after = node.childNodes[offset]
       if (isIgnorable(after, 1)) {
         moveNode = node
         moveOffset = ++offset
+      } else {
+        break
       }
-      else break
     } else if (isBlockNode(node)) {
       break
     } else {
@@ -150,7 +146,7 @@ function skipIgnoredNodesAfter(view: EditorView) {
       } else {
         node = next
         offset = 0
-        len = nodeLen(node)
+        len = nodeSize(node)
       }
     }
   }
@@ -169,8 +165,8 @@ function textNodeAfter(node: Node | null, offset: number): Text | undefined {
   }
   while (node && offset < node.childNodes.length) {
     let next = node.childNodes[offset]
-    if (next.nodeType == 3) return next as Text
-    if (next.nodeType == 1 && (next as HTMLElement).contentEditable == "false") break
+    if (isText(next)) return next
+    if (isElt(next) && next.contentEditable == "false") break
     node = next
     offset = 0
   }
@@ -183,15 +179,15 @@ function textNodeBefore(node: Node | null, offset: number): Text | undefined {
   }
   while (node && offset) {
     let next = node.childNodes[offset - 1]
-    if (next.nodeType == 3) return next as Text
-    if (next.nodeType == 1 && (next as HTMLElement).contentEditable == "false") break
+    if (isText(next)) return next
+    if (isElt(next) && next.contentEditable == "false") break
     node = next
     offset = node.childNodes.length
   }
 }
 
 function setSelFocus(view: EditorView, node: Node, offset: number) {
-  if (node.nodeType != 3) {
+  if (!isText(node)) {
     let before, after
     if (after = textNodeAfter(node, offset)) {
       node = after
@@ -295,9 +291,9 @@ function switchEditable(view: EditorView, node: HTMLElement, state: string) {
 function safariDownArrowBug(view: EditorView) {
   if (!browser.safari || view.state.selection.$head.parentOffset > 0) return false
   let {focusNode, focusOffset} = view.domSelectionRange()
-  if (focusNode && focusNode.nodeType == 1 && focusOffset == 0 &&
-      focusNode.firstChild && (focusNode.firstChild as HTMLElement).contentEditable == "false") {
-    let child = focusNode.firstChild as HTMLElement
+  if (focusNode && isElt(focusNode) && focusOffset == 0 &&
+      focusNode.firstChild && isElt(focusNode.firstChild) && focusNode.firstChild.contentEditable == "false") {
+    let child = focusNode.firstChild
     switchEditable(view, child, "true")
     setTimeout(() => switchEditable(view, child, "false"), 20)
   }

package/src/clipboard.ts

@@ -1,6 +1,7 @@
 import {Slice, Fragment, DOMParser, DOMSerializer, ResolvedPos, NodeType, Node} from "prosemirror-model"
 import * as browser from "./browser"
 import {EditorView} from "./index"
+import {isElt} from "./dom"
 
 export function serializeForClipboard(view: EditorView, slice: Slice) {
   view.someProp("transformCopied", f => { slice = f(slice!, view) })
@@ -19,7 +20,7 @@ export function serializeForClipboard(view: EditorView, slice: Slice) {
   wrap.appendChild(serializer.serializeFragment(content, {document: doc}))
 
   let firstChild = wrap.firstChild, needsWrap, wrappers = 0
-  while (firstChild && firstChild.nodeType == 1 && (needsWrap = wrapMap[firstChild.nodeName.toLowerCase()])) {
+  while (firstChild && isElt(firstChild) && (needsWrap = wrapMap[firstChild.nodeName.toLowerCase()])) {
     for (let i = needsWrap.length - 1; i >= 0; i--) {
       let wrapper = doc.createElement(needsWrap[i])
       while (wrap.firstChild) wrapper.appendChild(wrap.firstChild)
@@ -29,8 +30,8 @@ export function serializeForClipboard(view: EditorView, slice: Slice) {
     firstChild = wrap.firstChild
   }
 
-  if (firstChild && firstChild.nodeType == 1)
-    (firstChild as HTMLElement).setAttribute(
+  if (firstChild && isElt(firstChild))
+    firstChild.setAttribute(
       "data-pm-slice", `${openStart} ${openEnd}${wrappers ? ` -${wrappers}` : ""} ${JSON.stringify(context)}`)
 
   let text = view.someProp("clipboardTextSerializer", f => f(slice, view)) ||
@@ -74,7 +75,7 @@ export function parseFromClipboard(view: EditorView, text: string, html: string
   let sliceData = contextNode && /^(\d+) (\d+)(?: -(\d+))? (.*)/.exec(contextNode.getAttribute("data-pm-slice") || "")
   if (sliceData && sliceData[3]) for (let i = +sliceData[3]; i > 0; i--) {
     let child = dom!.firstChild
-    while (child && child.nodeType != 1) child = child.nextSibling
+    while (child && !isElt(child)) child = child.nextSibling
     if (!child) break
     dom = child as HTMLElement
   }
@@ -270,9 +271,11 @@ function addContext(slice: Slice, context: string) {
   for (let i = array.length - 2; i >= 0; i -= 2) {
     let type = schema.nodes[array[i]]
     if (!type || type.hasRequiredAttrs()) break
-    try { type.checkAttrs(array[i + 1]) }
-    catch(e) { break }
-    content = Fragment.from(type.create(array[i + 1], content))
+    try {
+      content = Fragment.from(type.create(array[i + 1], content))
+    } catch(e) {
+      break
+    }
     openStart++; openEnd++
   }
   return new Slice(content, openStart, openEnd)

package/src/dom.ts

@@ -48,14 +48,14 @@ function scanFor(node: Node, off: number, targetNode: Node, targetOff: number, d
     if (node == targetNode && off == targetOff) return true
     if (off == (dir < 0 ? 0 : nodeSize(node))) {
       let parent = node.parentNode
-      if (!parent || parent.nodeType != 1 || hasBlockDesc(node) || atomElements.test(node.nodeName) ||
+      if (!parent || !isElt(parent) || hasBlockDesc(node) || atomElements.test(node.nodeName) ||
           (node as HTMLElement).contentEditable == "false")
         return false
       off = domIndex(node) + (dir < 0 ? 0 : 1)
       node = parent
-    } else if (node.nodeType == 1) {
+    } else if (isElt(node)) {
       let child = node.childNodes[off + (dir < 0 ? -1 : 0)]
-      if (child.nodeType == 1 && (child as HTMLElement).contentEditable == "false") {
+      if (isElt(child) && child.contentEditable == "false") {
         if (child.pmViewDesc?.ignoreForSelection) off += dir
         else return false
       } else {
@@ -72,10 +72,17 @@ export function nodeSize(node: Node) {
   return node.nodeType == 3 ? node.nodeValue!.length : node.childNodes.length
 }
 
+export function isElt(node: Node): node is HTMLElement { return node.nodeType == 1 }
+export function isText(node: Node): node is Text { return node.nodeType == 3 }
+
+export function contains(parent: Node, child: Node | null) {
+  return child ? parent.contains(isElt(child) ? child : child.parentNode) : false
+}
+
 export function textNodeBefore(node: Node, offset: number) {
   for (;;) {
-    if (node.nodeType == 3 && offset) return node as Text
-    if (node.nodeType == 1 && offset > 0) {
+    if (isText(node) && offset) return node
+    if (isElt(node) && offset > 0) {
       if ((node as HTMLElement).contentEditable == "false") return null
       node = node.childNodes[offset - 1]
       offset = nodeSize(node)
@@ -90,9 +97,9 @@ export function textNodeBefore(node: Node, offset: number) {
 
 export function textNodeAfter(node: Node, offset: number) {
   for (;;) {
-    if (node.nodeType == 3 && offset < node.nodeValue!.length) return node as Text
-    if (node.nodeType == 1 && offset < node.childNodes.length) {
-      if ((node as HTMLElement).contentEditable == "false") return null
+    if (isText(node) && offset < node.nodeValue!.length) return node as Text
+    if (isElt(node) && offset < node.childNodes.length) {
+      if (node.contentEditable == "false") return null
       node = node.childNodes[offset]
       offset = 0
     } else if (node.parentNode && !hasBlockDesc(node)) {

package/src/domchange.ts

@@ -2,7 +2,7 @@ import {Fragment, DOMParser, TagParseRule, Node, Mark, ResolvedPos} from "prosem
 import {TextSelection, Transaction} from "prosemirror-state"
 
 import {selectionBetween, selectionFromDOM, selectionToDOM} from "./selection"
-import {selectionCollapsed, keyEvent, DOMNode} from "./dom"
+import {selectionCollapsed, keyEvent, DOMNode, isElt, contains} from "./dom"
 import * as browser from "./browser"
 import {EditorView} from "./index"
 
@@ -18,7 +18,7 @@ function parseBetween(view: EditorView, from_: number, to_: number, addedNodes:
   let domSel = view.domSelectionRange()
   let find: {node: DOMNode, offset: number, pos?: number}[] | undefined
   let anchor = domSel.anchorNode
-  if (anchor && view.dom.contains(anchor.nodeType == 1 ? anchor : anchor.parentNode)) {
+  if (anchor && contains(view.dom, anchor)) {
     find = [{node: anchor, offset: domSel.anchorOffset}]
     if (!selectionCollapsed(domSel))
       find.push({node: domSel.focusNode!, offset: domSel.focusOffset})
@@ -122,7 +122,7 @@ export function readDOMChange(view: EditorView, from: number, to: number, typeOv
   let change = findDiff(compare.content, parse.doc.content, parse.from, preferredPos, preferredSide)
   if (change) view.input.domChangeCount++
   if ((browser.ios && view.input.lastIOSEnter > Date.now() - 225 || browser.android) &&
-      addedNodes.some(n => n.nodeType == 1 && !isInline.test(n.nodeName)) &&
+      addedNodes.some(n => isElt(n) && !isInline.test(n.nodeName)) &&
       (!change || change.endA >= change.endB) &&
       view.someProp("handleKeyDown", f => f(view, keyEvent(13, "Enter")))) {
     view.input.lastIOSEnter = 0
@@ -180,9 +180,7 @@ export function readDOMChange(view: EditorView, from: number, to: number, typeOv
   // as being an iOS enter press), just dispatch an Enter key instead.
   if (((browser.ios && view.input.lastIOSEnter > Date.now() - 225 &&
         (!inlineChange || addedNodes.some(n => n.nodeName == "DIV" || n.nodeName == "P"))) ||
-       (!inlineChange && $from.pos < parse.doc.content.size &&
-        (!$from.sameParent($to) || !$from.parent.inlineContent) &&
-        $from.pos < $to.pos && !/\S/.test(parse.doc.textBetween($from.pos, $to.pos, "", "")))) &&
+       (!inlineChange && looksLikeEnter(parse.doc, $from.pos, $to.pos))) &&
       view.someProp("handleKeyDown", f => f(view, keyEvent(13, "Enter")))) {
     view.input.lastIOSEnter = 0
     return
@@ -333,6 +331,17 @@ function looksLikeBackspace(old: Node, start: number, end: number, $newStart: Re
   return $newStart.parent.content.cut($newStart.parentOffset).eq($next.parent.content)
 }
 
+function looksLikeEnter(content: Node, from: number, to: number) {
+  let newTextlines = 0, newLeaves = 0
+  content.nodesBetween(from, to, (node, pos) => {
+    if (node.isTextblock && pos >= from && pos < to)
+      newTextlines++
+    else if (node.isText ? /\S/.test(node.text!.slice(Math.max(0, from - pos), Math.min(node.nodeSize, to - pos))) : node.isLeaf)
+      newLeaves++
+  })
+  return newLeaves == 0 && newTextlines == 1
+}
+
 function skipClosingAndOpening($pos: ResolvedPos, fromEnd: boolean, mayOpen: boolean) {
   let depth = $pos.depth, end = fromEnd ? $pos.end() : $pos.pos
   while (depth > 0 && (fromEnd || $pos.indexAfter(depth) == $pos.node(depth).childCount)) {

package/src/domcoords.ts

@@ -1,5 +1,5 @@
 import {EditorState} from "prosemirror-state"
-import {nodeSize, textRange, parentNode, caretFromPoint} from "./dom"
+import {nodeSize, textRange, parentNode, caretFromPoint, isElt, isText, contains} from "./dom"
 import * as browser from "./browser"
 import {EditorView} from "./index"
 
@@ -37,10 +37,9 @@ export function scrollRectIntoView(view: EditorView, rect: Rect, startDOM: Node)
   let doc = view.dom.ownerDocument
   for (let parent: Node | null = startDOM || view.dom;;) {
     if (!parent) break
-    if (parent.nodeType != 1) { parent = parentNode(parent); continue }
-    let elt = parent as HTMLElement
-    let atTop = elt == doc.body
-    let bounding = atTop ? windowRect(doc) : clientRect(elt as HTMLElement)
+    if (!isElt(parent)) { parent = parentNode(parent); continue }
+    let atTop = parent == doc.body
+    let bounding = atTop ? windowRect(doc) : clientRect(parent)
     let moveX = 0, moveY = 0
     if (rect.top < bounding.top + getSide(scrollThreshold, "top"))
       moveY = -(bounding.top - rect.top + getSide(scrollMargin, "top"))
@@ -56,16 +55,16 @@ export function scrollRectIntoView(view: EditorView, rect: Rect, startDOM: Node)
       if (atTop) {
         doc.defaultView!.scrollBy(moveX, moveY)
       } else {
-        let startX = elt.scrollLeft, startY = elt.scrollTop
-        if (moveY) elt.scrollTop += moveY
-        if (moveX) elt.scrollLeft += moveX
-        let dX = elt.scrollLeft - startX, dY = elt.scrollTop - startY
+        let startX = parent.scrollLeft, startY = parent.scrollTop
+        if (moveY) parent.scrollTop += moveY
+        if (moveX) parent.scrollLeft += moveX
+        let dX = parent.scrollLeft - startX, dY = parent.scrollTop - startY
         rect = {left: rect.left - dX, top: rect.top - dY, right: rect.right - dX, bottom: rect.bottom - dY}
       }
     }
-    let pos: string = atTop ? "fixed" : getComputedStyle(parent as HTMLElement).position
+    let pos: string = atTop ? "fixed" : getComputedStyle(parent).position
     if (/^(fixed|sticky)$/.test(pos)) break
-    parent = pos == "absolute" ? (parent as HTMLElement).offsetParent : parentNode(parent)
+    parent = pos == "absolute" ? parent.offsetParent : parentNode(parent)
   }
 }
 
@@ -84,7 +83,7 @@ export function storeScrollPos(view: EditorView): {
        y < Math.min(innerHeight, rect.bottom); y += 5) {
     let dom = view.root.elementFromPoint(x, y)
     if (!dom || dom == view.dom || !view.dom.contains(dom)) continue
-    let localRect = (dom as HTMLElement).getBoundingClientRect()
+    let localRect = dom.getBoundingClientRect()
     if (localRect.top >= startY - 20) {
       refDOM = dom as HTMLElement
       refTop = localRect.top
@@ -143,13 +142,14 @@ export function focusPreventScroll(dom: HTMLElement) {
 }
 
 function findOffsetInNode(node: HTMLElement, coords: {top: number, left: number}): {node: Node, offset: number} {
-  let closest, dxClosest = 2e8, coordsClosest: {left: number, top: number} | undefined, offset = 0
+  let closest: Text | HTMLElement | undefined
+  let dxClosest = 2e8, coordsClosest: {left: number, top: number} | undefined, offset = 0
   let rowBot = coords.top, rowTop = coords.top
-  let firstBelow: Node | undefined, coordsBelow: {left: number, top: number} | undefined
+  let firstBelow: Text | HTMLElement | undefined, coordsBelow: {left: number, top: number} | undefined
   for (let child = node.firstChild, childIndex = 0; child; child = child.nextSibling, childIndex++) {
     let rects
-    if (child.nodeType == 1) rects = (child as HTMLElement).getClientRects()
-    else if (child.nodeType == 3) rects = textRange(child as Text).getClientRects()
+    if (isElt(child)) rects = child.getClientRects()
+    else if (isText(child)) rects = textRange(child).getClientRects()
     else continue
 
     for (let i = 0; i < rects.length; i++) {
@@ -162,11 +162,11 @@ function findOffsetInNode(node: HTMLElement, coords: {top: number, left: number}
         if (dx < dxClosest) {
           closest = child
           dxClosest = dx
-          coordsClosest = dx && closest.nodeType == 3 ? {
+          coordsClosest = dx && isText(closest) ? {
             left: rect.right < coords.left ? rect.right : rect.left,
             top: coords.top
           } : coords
-          if (child.nodeType == 1 && dx)
+          if (isElt(child) && dx)
             offset = childIndex + (coords.left >= (rect.left + rect.right) / 2 ? 1 : 0)
           continue
         }
@@ -180,9 +180,9 @@ function findOffsetInNode(node: HTMLElement, coords: {top: number, left: number}
     }
   }
   if (!closest && firstBelow) { closest = firstBelow; coordsClosest = coordsBelow; dxClosest = 0 }
-  if (closest && closest.nodeType == 3) return findOffsetInText(closest as Text, coordsClosest!)
-  if (!closest || (dxClosest && closest.nodeType == 1)) return {node, offset}
-  return findOffsetInNode(closest as HTMLElement, coordsClosest!)
+  if (closest && isText(closest)) return findOffsetInText(closest, coordsClosest!)
+  if (!closest || dxClosest) return {node, offset}
+  return findOffsetInNode(closest, coordsClosest!)
 }
 
 function findOffsetInText(node: Text, coords: {top: number, left: number}) {
@@ -216,8 +216,8 @@ function targetKludge(dom: HTMLElement, coords: {top: number, left: number}) {
 
 function posFromElement(view: EditorView, elt: HTMLElement, coords: {top: number, left: number}) {
   let {node, offset} = findOffsetInNode(elt, coords), bias = -1
-  if (node.nodeType == 1 && !node.firstChild) {
-    let rect = (node as HTMLElement).getBoundingClientRect()
+  if (isElt(node) && !node.firstChild) {
+    let rect = node.getBoundingClientRect()
     bias = rect.left != rect.right && coords.left > (rect.left + rect.right) / 2 ? 1 : -1
   }
   return view.docView.posFromDOM(node, offset, bias)
@@ -235,9 +235,9 @@ function posFromCaret(view: EditorView, node: Node, offset: number, coords: {top
     if (cur == view.dom) break
     let desc = view.docView.nearestDesc(cur, true), rect
     if (!desc) return null
-    if (desc.dom.nodeType == 1 && (desc.node.isBlock && desc.parent || !desc.contentDOM) &&
+    if (isElt(desc.dom) && (desc.node.isBlock && desc.parent || !desc.contentDOM) &&
         // Ignore elements with zero-size bounding rectangles
-        ((rect = (desc.dom as HTMLElement).getBoundingClientRect()).width || rect.height)) {
+        ((rect = desc.dom.getBoundingClientRect()).width || rect.height)) {
       if (desc.node.isBlock && desc.parent && !/^T(R|BODY|HEAD|FOOT)$/.test(desc.dom!.nodeName)) {
         // Only apply the horizontal test to the innermost block. Vertical for any parent.
         if (!sawBlock && rect.left > coords.left || rect.top > coords.top) outsideBlock = desc.posBefore
@@ -261,11 +261,11 @@ function elementFromPoint(element: HTMLElement, coords: {top: number, left: numb
   if (len && box.top < box.bottom) {
     for (let startI = Math.max(0, Math.min(len - 1, Math.floor(len * (coords.top - box.top) / (box.bottom - box.top)) - 2)), i = startI;;) {
       let child = element.childNodes[i]
-      if (child.nodeType == 1) {
-        let rects = (child as HTMLElement).getClientRects()
+      if (isElt(child)) {
+        let rects = child.getClientRects()
         for (let j = 0; j < rects.length; j++) {
           let rect = rects[j]
-          if (inRect(coords, rect)) return elementFromPoint(child as HTMLElement, coords, rect)
+          if (inRect(coords, rect)) return elementFromPoint(child, coords, rect)
         }
       }
       if ((i = (i + 1) % len) == startI) break
@@ -283,7 +283,7 @@ export function posAtCoords(view: EditorView, coords: {top: number, left: number
   let elt = ((view.root as any).elementFromPoint ? view.root : doc)
               .elementFromPoint(coords.left, coords.top) as HTMLElement
   let pos
-  if (!elt || !view.dom.contains(elt.nodeType != 1 ? elt.parentNode : elt)) {
+  if (!elt || !view.dom.contains(elt)) {
     let box = view.dom.getBoundingClientRect()
     if (!inRect(coords, box)) return null
     elt = elementFromPoint(view.dom, coords, box)
@@ -296,7 +296,7 @@ export function posAtCoords(view: EditorView, coords: {top: number, left: number
   }
   elt = targetKludge(elt, coords)
   if (node) {
-    if (browser.gecko && node.nodeType == 1) {
+    if (browser.gecko && isElt(node)) {
       // Firefox will sometimes return offsets into <input> nodes, which
       // have no actual children, from caretPositionFromPoint (#953)
       offset = Math.min(offset, node.childNodes.length)
@@ -311,18 +311,18 @@ export function posAtCoords(view: EditorView, coords: {top: number, left: number
     }
     let prev
     // When clicking above the right side of an uneditable node, Chrome will report a cursor position after that node.
-    if (browser.webkit && offset && node.nodeType == 1 && (prev = node.childNodes[offset - 1]).nodeType == 1 &&
-        (prev as HTMLElement).contentEditable == "false" && (prev as HTMLElement).getBoundingClientRect().top >= coords.top)
+    if (browser.webkit && offset && isElt(node) && isElt(prev = node.childNodes[offset - 1]) &&
+        prev.contentEditable == "false" && prev.getBoundingClientRect().top >= coords.top)
       offset--
     // Suspiciously specific kludge to work around caret*FromPoint
     // never returning a position at the end of the document
-    if (node == view.dom && offset == node.childNodes.length - 1 && node.lastChild!.nodeType == 1 &&
-        coords.top > (node.lastChild as HTMLElement).getBoundingClientRect().bottom)
+    if (node == view.dom && offset == node.childNodes.length - 1 && isElt(node.lastChild!) &&
+        coords.top > node.lastChild.getBoundingClientRect().bottom)
       pos = view.state.doc.content.size
     // Ignore positions directly after a BR, since caret*FromPoint
     // 'round up' positions that would be more accurately placed
     // before the BR node.
-    else if (offset == 0 || node.nodeType != 1 || node.childNodes[offset - 1].nodeName != "BR")
+    else if (offset == 0 || !isElt(node) || node.childNodes[offset - 1].nodeName != "BR")
       pos = posFromCaret(view, node, offset, coords)
   }
   if (pos == null) pos = posFromElement(view, elt, coords)
@@ -352,18 +352,18 @@ export function coordsAtPos(view: EditorView, pos: number, side: number): Rect {
   let {node, offset, atom} = view.docView.domFromPos(pos, side < 0 ? -1 : 1)
 
   let supportEmptyRange = browser.webkit || browser.gecko
-  if (node.nodeType == 3) {
+  if (isText(node)) {
     // These browsers support querying empty text ranges. Prefer that in
     // bidi context or when at the end of a node.
     if (supportEmptyRange && (BIDI.test(node.nodeValue!) || (side < 0 ? !offset : offset == node.nodeValue!.length))) {
-      let rect = singleRect(textRange(node as Text, offset, offset), side)
+      let rect = singleRect(textRange(node, offset, offset), side)
       // Firefox returns bad results (the position before the space)
       // when querying a position directly after line-broken
       // whitespace. Detect this situation and and kludge around it
       if (browser.gecko && offset && /\s/.test(node.nodeValue![offset - 1]) && offset < node.nodeValue!.length) {
-        let rectBefore = singleRect(textRange(node as Text, offset - 1, offset - 1), -1)
+        let rectBefore = singleRect(textRange(node, offset - 1, offset - 1), -1)
         if (rectBefore.top == rect.top) {
-          let rectAfter = singleRect(textRange(node as Text, offset, offset + 1), -1)
+          let rectAfter = singleRect(textRange(node, offset, offset + 1), -1)
           if (rectAfter.top != rect.top)
             return flattenV(rectAfter, rectAfter.left < rectBefore.left)
         }
@@ -375,7 +375,7 @@ export function coordsAtPos(view: EditorView, pos: number, side: number): Rect {
       else if (side >= 0 && offset == node.nodeValue!.length) { from--; takeSide = 1 }
       else if (side < 0) { from-- }
       else { to ++ }
-      return flattenV(singleRect(textRange(node as Text, from, to), takeSide), takeSide < 0)
+      return flattenV(singleRect(textRange(node, from, to), takeSide), takeSide < 0)
     }
   }
 
@@ -384,11 +384,11 @@ export function coordsAtPos(view: EditorView, pos: number, side: number): Rect {
   if (!$dom.parent.inlineContent) {
     if (atom == null && offset && (side < 0 || offset == nodeSize(node))) {
       let before = node.childNodes[offset - 1]
-      if (before.nodeType == 1) return flattenH((before as HTMLElement).getBoundingClientRect(), false)
+      if (isElt(before)) return flattenH(before.getBoundingClientRect(), false)
     }
     if (atom == null && offset < nodeSize(node)) {
       let after = node.childNodes[offset]
-      if (after.nodeType == 1) return flattenH((after as HTMLElement).getBoundingClientRect(), true)
+      if (isElt(after)) return flattenH(after.getBoundingClientRect(), true)
     }
     return flattenH((node as HTMLElement).getBoundingClientRect(), side >= 0)
   }
@@ -396,21 +396,21 @@ export function coordsAtPos(view: EditorView, pos: number, side: number): Rect {
   // Inline, not in text node (this is not Bidi-safe)
   if (atom == null && offset && (side < 0 || offset == nodeSize(node))) {
     let before = node.childNodes[offset - 1]
-    let target = before.nodeType == 3 ? textRange(before as Text, nodeSize(before) - (supportEmptyRange ? 0 : 1))
+    let target = isText(before) ? textRange(before, nodeSize(before) - (supportEmptyRange ? 0 : 1))
         // BR nodes tend to only return the rectangle before them.
         // Only use them if they are the last element in their parent
-        : before.nodeType == 1 && (before.nodeName != "BR" || !before.nextSibling) ? before : null
-    if (target) return flattenV(singleRect(target as Range | HTMLElement, 1), false)
+        : isElt(before) && (before.nodeName != "BR" || !before.nextSibling) ? before : null
+    if (target) return flattenV(singleRect(target, 1), false)
   }
   if (atom == null && offset < nodeSize(node)) {
     let after = node.childNodes[offset]
     while (after.pmViewDesc && after.pmViewDesc.ignoreForCoords) after = after.nextSibling!
-    let target = !after ? null : after.nodeType == 3 ? textRange(after as Text, 0, (supportEmptyRange ? 0 : 1))
-        : after.nodeType == 1 ? after : null
-    if (target) return flattenV(singleRect(target as Range | HTMLElement, -1), true)
+    let target = !after ? null : isText(after) ? textRange(after, 0, (supportEmptyRange ? 0 : 1))
+        : isElt(after) ? after : null
+    if (target) return flattenV(singleRect(target, -1), true)
   }
   // All else failed, just try to get a rectangle for the target node
-  return flattenV(singleRect(node.nodeType == 3 ? textRange(node as Text) : node as HTMLElement, -side), side >= 0)
+  return flattenV(singleRect(isText(node) ? textRange(node) : node as HTMLElement, -side), side >= 0)
 }
 
 function flattenV(rect: DOMRect, left: boolean) {
@@ -453,8 +453,8 @@ function endOfTextblockVertical(view: EditorView, state: EditorState, dir: "up"
     let coords = coordsAtPos(view, $pos.pos, 1)
     for (let child = dom.firstChild; child; child = child.nextSibling) {
       let boxes
-      if (child.nodeType == 1) boxes = (child as HTMLElement).getClientRects()
-      else if (child.nodeType == 3) boxes = textRange(child as Text, 0, child.nodeValue!.length).getClientRects()
+      if (isElt(child)) boxes = child.getClientRects()
+      else if (isText(child)) boxes = textRange(child, 0, child.nodeValue!.length).getClientRects()
       else continue
       for (let i = 0; i < boxes.length; i++) {
         let box = boxes[i]
@@ -492,8 +492,7 @@ function endOfTextblockHorizontal(view: EditorView, state: EditorState, dir: "le
     ;(sel as any).modify("move", dir, "character")
     let parentDOM = $head.depth ? view.docView.domAfterPos($head.before()) : view.dom
     let {focusNode: newNode, focusOffset: newOff} = view.domSelectionRange()
-    let result = newNode && !parentDOM.contains(newNode.nodeType == 1 ? newNode : newNode.parentNode) ||
-        (oldNode == newNode && oldOff == newOff)
+    let result = newNode && !contains(parentDOM, newNode) || (oldNode == newNode && oldOff == newOff)
     // Restore the previous selection
     try {
       sel.collapse(anchorNode, anchorOffset)

package/src/domobserver.ts

@@ -1,6 +1,6 @@
 import {Selection} from "prosemirror-state"
 import * as browser from "./browser"
-import {domIndex, isEquivalentPosition, selectionCollapsed, parentNode, DOMSelectionRange, DOMNode, DOMSelection} from "./dom"
+import {domIndex, isEquivalentPosition, selectionCollapsed, parentNode, DOMSelectionRange, DOMNode, DOMSelection, isText, isElt} from "./dom"
 import {hasFocusAndSelection, selectionToDOM, selectionFromDOM} from "./selection"
 import {EditorView} from "./index"
 
@@ -159,7 +159,7 @@ export class DOMObserver {
     let desc = container && this.view.docView.nearestDesc(container)
     if (desc && desc.ignoreMutation({
       type: "selection",
-      target: container!.nodeType == 3 ? container!.parentNode! : container!
+      target: isText(container!) ? container!.parentNode! : container!
     })) {
       this.setCurSelection()
       return true
@@ -200,8 +200,8 @@ export class DOMObserver {
       // backspace out the last bit of text before an inline-flex node (#1552)
       for (let node of added) if (node.nodeName == "BR" && node.parentNode) {
         let after = node.nextSibling
-        while (after && after.nodeType == 1) {
-          if ((after as HTMLElement).contentEditable == "false") {
+        while (after && isElt(after)) {
+          if (after.contentEditable == "false") {
             node.parentNode.removeChild(node)
             break
           }
@@ -267,7 +267,7 @@ export class DOMObserver {
       for (let i = 0; i < mut.addedNodes.length; i++) {
         let node = mut.addedNodes[i]
         added.push(node)
-        if (node.nodeType == 3) this.lastChangedTextNode = node as Text
+        if (isText(node)) this.lastChangedTextNode = node
       }
       if (desc.contentDOM && desc.contentDOM != desc.dom && !desc.contentDOM.contains(mut.target))
         return {from: desc.posBefore, to: desc.posAfter}
@@ -381,8 +381,7 @@ function fixUpBadSafariComposition(view: EditorView, addedNodes: readonly DOMNod
         let parent = nextCell
         for (;;) {
           let first = parent.firstChild
-          if (!first || first.nodeType != 1 || (first as HTMLElement).contentEditable == "false" ||
-              /^(BR|IMG)$/.test(first.nodeName)) break
+          if (!first || !isElt(first) || first.contentEditable == "false" || /^(BR|IMG)$/.test(first.nodeName)) break
           parent = first
         }
         parent.insertBefore(node, parent.firstChild)