prosemirror-view 1.23.13 → 1.24.0-beta.3

package/src/{domcoords.js → domcoords.ts}

@@ -1,16 +1,21 @@
+import {EditorState} from "prosemirror-state"
 import {nodeSize, textRange, parentNode} from "./dom"
-import browser from "./browser"
+import * as browser from "./browser"
+import {EditorView} from "./index"
+import {NodeViewDesc} from "./viewdesc"
 
-function windowRect(doc) {
+export type Rect = {left: number, right: number, top: number, bottom: number}
+
+function windowRect(doc: Document): Rect {
   return {left: 0, right: doc.documentElement.clientWidth,
           top: 0, bottom: doc.documentElement.clientHeight}
 }
 
-function getSide(value, side) {
+function getSide(value: number | Rect, side: keyof Rect): number {
   return typeof value == "number" ? value : value[side]
 }
 
-function clientRect(node) {
+function clientRect(node: HTMLElement): Rect {
   let rect = node.getBoundingClientRect()
   // Adjust for elements with style "transform: scale()"
   let scaleX = (rect.width / node.offsetWidth) || 1
@@ -20,14 +25,15 @@ function clientRect(node) {
           top: rect.top, bottom: rect.top + node.clientHeight * scaleY}
 }
 
-export function scrollRectIntoView(view, rect, startDOM) {
+export function scrollRectIntoView(view: EditorView, rect: Rect, startDOM: Node) {
   let scrollThreshold = view.someProp("scrollThreshold") || 0, scrollMargin = view.someProp("scrollMargin") || 5
   let doc = view.dom.ownerDocument
-  for (let parent = startDOM || view.dom;; parent = parentNode(parent)) {
+  for (let parent: Node | null = startDOM || view.dom;; parent = parentNode(parent)) {
     if (!parent) break
     if (parent.nodeType != 1) continue
-    let atTop = parent == doc.body || parent.nodeType != 1
-    let bounding = atTop ? windowRect(doc) : clientRect(parent)
+    let elt = parent as HTMLElement
+    let atTop = elt == doc.body
+    let bounding = atTop ? windowRect(doc) : clientRect(elt as HTMLElement)
     let moveX = 0, moveY = 0
     if (rect.top < bounding.top + getSide(scrollThreshold, "top"))
       moveY = -(bounding.top - rect.top + getSide(scrollMargin, "top"))
@@ -39,12 +45,12 @@ export function scrollRectIntoView(view, rect, startDOM) {
       moveX = rect.right - bounding.right + getSide(scrollMargin, "right")
     if (moveX || moveY) {
       if (atTop) {
-        doc.defaultView.scrollBy(moveX, moveY)
+        doc.defaultView!.scrollBy(moveX, moveY)
       } else {
-        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
+        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
         rect = {left: rect.left - dX, top: rect.top - dY, right: rect.right - dX, bottom: rect.bottom - dY}
       }
     }
@@ -56,27 +62,31 @@ export function scrollRectIntoView(view, rect, startDOM) {
 // the top position of an element near the top of the editor, which
 // will be used to make sure the visible viewport remains stable even
 // when the size of the content above changes.
-export function storeScrollPos(view) {
+export function storeScrollPos(view: EditorView): {
+  refDOM: HTMLElement,
+  refTop: number,
+  stack: {dom: HTMLElement, top: number, left: number}[]
+} {
   let rect = view.dom.getBoundingClientRect(), startY = Math.max(0, rect.top)
-  let refDOM, refTop
+  let refDOM: HTMLElement, refTop: number
   for (let x = (rect.left + rect.right) / 2, y = startY + 1;
        y < Math.min(innerHeight, rect.bottom); y += 5) {
     let dom = view.root.elementFromPoint(x, y)
-    if (dom == view.dom || !view.dom.contains(dom)) continue
-    let localRect = dom.getBoundingClientRect()
+    if (!dom || dom == view.dom || !view.dom.contains(dom)) continue
+    let localRect = (dom as HTMLElement).getBoundingClientRect()
     if (localRect.top >= startY - 20) {
-      refDOM = dom
+      refDOM = dom as HTMLElement
       refTop = localRect.top
       break
     }
   }
-  return {refDOM, refTop, stack: scrollStack(view.dom)}
+  return {refDOM: refDOM!, refTop: refTop!, stack: scrollStack(view.dom)}
 }
 
-function scrollStack(dom) {
+function scrollStack(dom: Node): {dom: HTMLElement, top: number, left: number}[] {
   let stack = [], doc = dom.ownerDocument
-  for (; dom; dom = parentNode(dom)) {
-    stack.push({dom, top: dom.scrollTop, left: dom.scrollLeft})
+  for (let cur: Node | null = dom; cur; cur = parentNode(cur)) {
+    stack.push({dom: cur as HTMLElement, top: (cur as HTMLElement).scrollTop, left: (cur as HTMLElement).scrollLeft})
     if (dom == doc) break
   }
   return stack
@@ -84,12 +94,16 @@ function scrollStack(dom) {
 
 // Reset the scroll position of the editor's parent nodes to that what
 // it was before, when storeScrollPos was called.
-export function resetScrollPos({refDOM, refTop, stack}) {
+export function resetScrollPos({refDOM, refTop, stack}: {
+  refDOM: HTMLElement,
+  refTop: number,
+  stack: {dom: HTMLElement, top: number, left: number}[]
+}) {
   let newRefTop = refDOM ? refDOM.getBoundingClientRect().top : 0
   restoreScrollStack(stack, newRefTop == 0 ? 0 : newRefTop - refTop)
 }
 
-function restoreScrollStack(stack, dTop) {
+function restoreScrollStack(stack: {dom: HTMLElement, top: number, left: number}[], dTop: number) {
   for (let i = 0; i < stack.length; i++) {
     let {dom, top, left} = stack[i]
     if (dom.scrollTop != top + dTop) dom.scrollTop = top + dTop
@@ -97,11 +111,11 @@ function restoreScrollStack(stack, dTop) {
   }
 }
 
-let preventScrollSupported = null
+let preventScrollSupported: false | null | {preventScroll: boolean} = null
 // Feature-detects support for .focus({preventScroll: true}), and uses
 // a fallback kludge when not supported.
-export function focusPreventScroll(dom) {
-  if (dom.setActive) return dom.setActive() // in IE
+export function focusPreventScroll(dom: HTMLElement) {
+  if ((dom as any).setActive) return (dom as any).setActive() // in IE
   if (preventScrollSupported) return dom.focus(preventScrollSupported)
 
   let stored = scrollStack(dom)
@@ -117,13 +131,13 @@ export function focusPreventScroll(dom) {
   }
 }
 
-function findOffsetInNode(node, coords) {
-  let closest, dxClosest = 2e8, coordsClosest, offset = 0
+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 rowBot = coords.top, rowTop = coords.top
   for (let child = node.firstChild, childIndex = 0; child; child = child.nextSibling, childIndex++) {
     let rects
-    if (child.nodeType == 1) rects = child.getClientRects()
-    else if (child.nodeType == 3) rects = textRange(child).getClientRects()
+    if (child.nodeType == 1) rects = (child as HTMLElement).getClientRects()
+    else if (child.nodeType == 3) rects = textRange(child as Text).getClientRects()
     else continue
 
     for (let i = 0; i < rects.length; i++) {
@@ -136,7 +150,10 @@ function findOffsetInNode(node, coords) {
         if (dx < dxClosest) {
           closest = child
           dxClosest = dx
-          coordsClosest = dx && closest.nodeType == 3 ? {left: rect.right < coords.left ? rect.right : rect.left, top: coords.top} : coords
+          coordsClosest = dx && closest.nodeType == 3 ? {
+            left: rect.right < coords.left ? rect.right : rect.left,
+            top: coords.top
+          } : coords
           if (child.nodeType == 1 && dx)
             offset = childIndex + (coords.left >= (rect.left + rect.right) / 2 ? 1 : 0)
           continue
@@ -147,13 +164,13 @@ function findOffsetInNode(node, coords) {
         offset = childIndex + 1
     }
   }
-  if (closest && closest.nodeType == 3) return findOffsetInText(closest, coordsClosest)
+  if (closest && closest.nodeType == 3) return findOffsetInText(closest as Text, coordsClosest!)
   if (!closest || (dxClosest && closest.nodeType == 1)) return {node, offset}
-  return findOffsetInNode(closest, coordsClosest)
+  return findOffsetInNode(closest as HTMLElement, coordsClosest!)
 }
 
-function findOffsetInText(node, coords) {
-  let len = node.nodeValue.length
+function findOffsetInText(node: Text, coords: {top: number, left: number}) {
+  let len = node.nodeValue!.length
   let range = document.createRange()
   for (let i = 0; i < len; i++) {
     range.setEnd(node, i + 1)
@@ -166,28 +183,28 @@ function findOffsetInText(node, coords) {
   return {node, offset: 0}
 }
 
-function inRect(coords, rect) {
+function inRect(coords: {top: number, left: number}, rect: Rect) {
   return coords.left >= rect.left - 1 && coords.left <= rect.right + 1&&
     coords.top >= rect.top - 1 && coords.top <= rect.bottom + 1
 }
 
-function targetKludge(dom, coords) {
+function targetKludge(dom: HTMLElement, coords: {top: number, left: number}) {
   let parent = dom.parentNode
   if (parent && /^li$/i.test(parent.nodeName) && coords.left < dom.getBoundingClientRect().left)
-    return parent
+    return parent as HTMLElement
   return dom
 }
 
-function posFromElement(view, elt, coords) {
+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.getBoundingClientRect()
+    let rect = (node as HTMLElement).getBoundingClientRect()
     bias = rect.left != rect.right && coords.left > (rect.left + rect.right) / 2 ? 1 : -1
   }
   return view.docView.posFromDOM(node, offset, bias)
 }
 
-function posFromCaret(view, node, offset, coords) {
+function posFromCaret(view: EditorView, node: Node, offset: number, coords: {top: number, left: number}) {
   // Browser (in caretPosition/RangeFromPoint) will agressively
   // normalize towards nearby inline nodes. Since we are interested in
   // positions between block nodes too, we first walk up the hierarchy
@@ -199,27 +216,27 @@ function posFromCaret(view, node, offset, coords) {
     if (cur == view.dom) break
     let desc = view.docView.nearestDesc(cur, true)
     if (!desc) return null
-    if (desc.node.isBlock && desc.parent) {
-      let rect = desc.dom.getBoundingClientRect()
+    if ((desc as NodeViewDesc).node.isBlock && desc.parent) {
+      let rect = (desc.dom as HTMLElement).getBoundingClientRect()
       if (rect.left > coords.left || rect.top > coords.top) outside = desc.posBefore
       else if (rect.right < coords.left || rect.bottom < coords.top) outside = desc.posAfter
       else break
     }
-    cur = desc.dom.parentNode
+    cur = desc.dom.parentNode!
   }
-  return outside > -1 ? outside : view.docView.posFromDOM(node, offset)
+  return outside > -1 ? outside : view.docView.posFromDOM(node, offset, 1)
 }
 
-function elementFromPoint(element, coords, box) {
+function elementFromPoint(element: HTMLElement, coords: {top: number, left: number}, box: Rect): HTMLElement {
   let len = element.childNodes.length
   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.getClientRects()
+        let rects = (child as HTMLElement).getClientRects()
         for (let j = 0; j < rects.length; j++) {
           let rect = rects[j]
-          if (inRect(coords, rect)) return elementFromPoint(child, coords, rect)
+          if (inRect(coords, rect)) return elementFromPoint(child as HTMLElement, coords, rect)
         }
       }
       if ((i = (i + 1) % len) == startI) break
@@ -229,11 +246,11 @@ function elementFromPoint(element, coords, box) {
 }
 
 // Given an x,y position on the editor, get the position in the document.
-export function posAtCoords(view, coords) {
-  let doc = view.dom.ownerDocument, node, offset
-  if (doc.caretPositionFromPoint) {
+export function posAtCoords(view: EditorView, coords: {top: number, left: number}) {
+  let doc = view.dom.ownerDocument, node: Node | undefined, offset = 0
+  if ((doc as any).caretPositionFromPoint) {
     try { // Firefox throws for this call in hard-to-predict circumstances (#994)
-      let pos = doc.caretPositionFromPoint(coords.left, coords.top)
+      let pos = (doc as any).caretPositionFromPoint(coords.left, coords.top)
       if (pos) ({offsetNode: node, offset} = pos)
     } catch (_) {}
   }
@@ -242,7 +259,9 @@ export function posAtCoords(view, coords) {
     if (range) ({startContainer: node, startOffset: offset} = range)
   }
 
-  let elt = (view.root.elementFromPoint ? view.root : doc).elementFromPoint(coords.left, coords.top + 1), pos
+  let elt = ((view.root as any).elementFromPoint ? view.root : doc)
+              .elementFromPoint(coords.left, coords.top + 1) as HTMLElement
+  let pos
   if (!elt || !view.dom.contains(elt.nodeType != 1 ? elt.parentNode : elt)) {
     let box = view.dom.getBoundingClientRect()
     if (!inRect(coords, box)) return null
@@ -251,8 +270,8 @@ export function posAtCoords(view, coords) {
   }
   // Safari's caretRangeFromPoint returns nonsense when on a draggable element
   if (browser.safari) {
-    for (let p = elt; node && p; p = parentNode(p))
-      if (p.draggable) node = offset = null
+    for (let p: Node | null = elt; node && p; p = parentNode(p))
+      if ((p as HTMLElement).draggable) node = undefined
   }
   elt = targetKludge(elt, coords)
   if (node) {
@@ -264,15 +283,15 @@ export function posAtCoords(view, coords) {
       // even if those are behind it.
       if (offset < node.childNodes.length) {
         let next = node.childNodes[offset], box
-        if (next.nodeName == "IMG" && (box = next.getBoundingClientRect()).right <= coords.left &&
+        if (next.nodeName == "IMG" && (box = (next as HTMLElement).getBoundingClientRect()).right <= coords.left &&
             box.bottom > 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.getBoundingClientRect().bottom)
+    if (node == view.dom && offset == node.childNodes.length - 1 && node.lastChild!.nodeType == 1 &&
+        coords.top > (node.lastChild as HTMLElement).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
@@ -286,32 +305,31 @@ export function posAtCoords(view, coords) {
   return {pos, inside: desc ? desc.posAtStart - desc.border : -1}
 }
 
-function singleRect(object, bias) {
-  let rects = object.getClientRects()
-  return !rects.length ? object.getBoundingClientRect() : rects[bias < 0 ? 0 : rects.length - 1]
+function singleRect(target: HTMLElement | Range, bias: number): DOMRect {
+  let rects = target.getClientRects()
+  return !rects.length ? target.getBoundingClientRect() : rects[bias < 0 ? 0 : rects.length - 1]
 }
 
 const BIDI = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/
 
-// : (EditorView, number, number) → {left: number, top: number, right: number, bottom: number}
 // Given a position in the document model, get a bounding box of the
 // character at that position, relative to the window.
-export function coordsAtPos(view, pos, side) {
+export function coordsAtPos(view: EditorView, pos: number, side: number): Rect {
   let {node, offset} = view.docView.domFromPos(pos, side < 0 ? -1 : 1)
 
   let supportEmptyRange = browser.webkit || browser.gecko
   if (node.nodeType == 3) {
     // 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, offset, offset), side)
+    if (supportEmptyRange && (BIDI.test(node.nodeValue!) || (side < 0 ? !offset : offset == node.nodeValue!.length))) {
+      let rect = singleRect(textRange(node as Text, 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, offset - 1, offset - 1), -1)
+      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)
         if (rectBefore.top == rect.top) {
-          let rectAfter = singleRect(textRange(node, offset, offset + 1), -1)
+          let rectAfter = singleRect(textRange(node as Text, offset, offset + 1), -1)
           if (rectAfter.top != rect.top)
             return flattenV(rectAfter, rectAfter.left < rectBefore.left)
         }
@@ -320,10 +338,10 @@ export function coordsAtPos(view, pos, side) {
     } else {
       let from = offset, to = offset, takeSide = side < 0 ? 1 : -1
       if (side < 0 && !offset) { to++; takeSide = -1 }
-      else if (side >= 0 && offset == node.nodeValue.length) { from--; takeSide = 1 }
+      else if (side >= 0 && offset == node.nodeValue!.length) { from--; takeSide = 1 }
       else if (side < 0) { from-- }
       else { to ++ }
-      return flattenV(singleRect(textRange(node, from, to), takeSide), takeSide < 0)
+      return flattenV(singleRect(textRange(node as Text, from, to), takeSide), takeSide < 0)
     }
   }
 
@@ -331,49 +349,49 @@ export function coordsAtPos(view, pos, side) {
   if (!view.state.doc.resolve(pos).parent.inlineContent) {
     if (offset && (side < 0 || offset == nodeSize(node))) {
       let before = node.childNodes[offset - 1]
-      if (before.nodeType == 1) return flattenH(before.getBoundingClientRect(), false)
+      if (before.nodeType == 1) return flattenH((before as HTMLElement).getBoundingClientRect(), false)
     }
     if (offset < nodeSize(node)) {
       let after = node.childNodes[offset]
-      if (after.nodeType == 1) return flattenH(after.getBoundingClientRect(), true)
+      if (after.nodeType == 1) return flattenH((after as HTMLElement).getBoundingClientRect(), true)
     }
-    return flattenH(node.getBoundingClientRect(), side >= 0)
+    return flattenH((node as HTMLElement).getBoundingClientRect(), side >= 0)
   }
 
   // Inline, not in text node (this is not Bidi-safe)
   if (offset && (side < 0 || offset == nodeSize(node))) {
     let before = node.childNodes[offset - 1]
-    let target = before.nodeType == 3 ? textRange(before, nodeSize(before) - (supportEmptyRange ? 0 : 1))
+    let target = before.nodeType == 3 ? textRange(before as Text, 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, 1), false)
+    if (target) return flattenV(singleRect(target as Range | HTMLElement, 1), false)
   }
   if (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, 0, (supportEmptyRange ? 0 : 1))
+    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, -1), true)
+    if (target) return flattenV(singleRect(target as Range | HTMLElement, -1), true)
   }
   // All else failed, just try to get a rectangle for the target node
-  return flattenV(singleRect(node.nodeType == 3 ? textRange(node) : node, -side), side >= 0)
+  return flattenV(singleRect(node.nodeType == 3 ? textRange(node as Text) : node as HTMLElement, -side), side >= 0)
 }
 
-function flattenV(rect, left) {
+function flattenV(rect: DOMRect, left: boolean) {
   if (rect.width == 0) return rect
   let x = left ? rect.left : rect.right
   return {top: rect.top, bottom: rect.bottom, left: x, right: x}
 }
 
-function flattenH(rect, top) {
+function flattenH(rect: DOMRect, top: boolean) {
   if (rect.height == 0) return rect
   let y = top ? rect.top : rect.bottom
   return {top: y, bottom: y, left: rect.left, right: rect.right}
 }
 
-function withFlushedState(view, state, f) {
-  let viewState = view.state, active = view.root.activeElement
+function withFlushedState<T>(view: EditorView, state: EditorState, f: () => T): T {
+  let viewState = view.state, active = view.root.activeElement as HTMLElement
   if (viewState != state) view.updateState(state)
   if (active != view.dom) view.focus()
   try {
@@ -384,10 +402,9 @@ function withFlushedState(view, state, f) {
   }
 }
 
-// : (EditorView, number, number)
 // Whether vertical position motion in a given direction
 // from a position would leave a text block.
-function endOfTextblockVertical(view, state, dir) {
+function endOfTextblockVertical(view: EditorView, state: EditorState, dir: "up" | "down") {
   let sel = state.selection
   let $pos = dir == "up" ? sel.$from : sel.$to
   return withFlushedState(view, state, () => {
@@ -395,14 +412,14 @@ function endOfTextblockVertical(view, state, dir) {
     for (;;) {
       let nearest = view.docView.nearestDesc(dom, true)
       if (!nearest) break
-      if (nearest.node.isBlock) { dom = nearest.dom; break }
-      dom = nearest.dom.parentNode
+      if (nearest.node!.isBlock) { dom = nearest.dom; break }
+      dom = nearest.dom.parentNode!
     }
     let coords = coordsAtPos(view, $pos.pos, 1)
     for (let child = dom.firstChild; child; child = child.nextSibling) {
       let boxes
-      if (child.nodeType == 1) boxes = child.getClientRects()
-      else if (child.nodeType == 3) boxes = textRange(child, 0, child.nodeValue.length).getClientRects()
+      if (child.nodeType == 1) boxes = (child as HTMLElement).getClientRects()
+      else if (child.nodeType == 3) boxes = textRange(child as Text, 0, child.nodeValue!.length).getClientRects()
       else continue
       for (let i = 0; i < boxes.length; i++) {
         let box = boxes[i]
@@ -418,14 +435,14 @@ function endOfTextblockVertical(view, state, dir) {
 
 const maybeRTL = /[\u0590-\u08ac]/
 
-function endOfTextblockHorizontal(view, state, dir) {
+function endOfTextblockHorizontal(view: EditorView, state: EditorState, dir: "left" | "right" | "forward" | "backward") {
   let {$head} = state.selection
   if (!$head.parent.isTextblock) return false
   let offset = $head.parentOffset, atStart = !offset, atEnd = offset == $head.parent.content.size
-  let sel = view.root.getSelection()
+  let sel = view.domSelection()
   // If the textblock is all LTR, or the browser doesn't support
   // Selection.modify (Edge), fall back to a primitive approach
-  if (!maybeRTL.test($head.parent.textContent) || !sel.modify)
+  if (!maybeRTL.test($head.parent.textContent) || !(sel as any).modify)
     return dir == "left" || dir == "backward" ? atStart : atEnd
 
   return withFlushedState(view, state, () => {
@@ -435,21 +452,25 @@ function endOfTextblockHorizontal(view, state, dir) {
     // textblock (or doesn't move it at all, when at the start/end of
     // the document).
     let oldRange = sel.getRangeAt(0), oldNode = sel.focusNode, oldOff = sel.focusOffset
-    let oldBidiLevel = sel.caretBidiLevel // Only for Firefox
-    sel.modify("move", dir, "character")
+    let oldBidiLevel = (sel as any).caretBidiLevel // Only for Firefox
+    ;(sel as any).modify("move", dir, "character")
     let parentDOM = $head.depth ? view.docView.domAfterPos($head.before()) : view.dom
-    let result = !parentDOM.contains(sel.focusNode.nodeType == 1 ? sel.focusNode : sel.focusNode.parentNode) ||
+    let result = !parentDOM.contains(sel.focusNode!.nodeType == 1 ? sel.focusNode : sel.focusNode!.parentNode) ||
         (oldNode == sel.focusNode && oldOff == sel.focusOffset)
     // Restore the previous selection
     sel.removeAllRanges()
     sel.addRange(oldRange)
-    if (oldBidiLevel != null) sel.caretBidiLevel = oldBidiLevel
+    if (oldBidiLevel != null) (sel as any).caretBidiLevel = oldBidiLevel
     return result
   })
 }
 
-let cachedState = null, cachedDir = null, cachedResult = false
-export function endOfTextblock(view, state, dir) {
+export type TextblockDir = "up" | "down" | "left" | "right" | "forward" | "backward"
+
+let cachedState: EditorState | null = null
+let cachedDir: TextblockDir | null = null
+let cachedResult: boolean = false
+export function endOfTextblock(view: EditorView, state: EditorState, dir: TextblockDir) {
   if (cachedState == state && cachedDir == dir) return cachedResult
   cachedState = state; cachedDir = dir
   return cachedResult = dir == "up" || dir == "down"