datafolder 1.0.6 → 1.0.8

package/static/codemirror.bundle/editor.bundle.js

@@ -4907,16 +4907,16 @@
           }
       }
   }
-  function scrollableParents(dom) {
-      let doc = dom.ownerDocument, x, y;
+  function scrollableParents(dom, getX = true) {
+      let doc = dom.ownerDocument, x = null, y = null;
       for (let cur = dom.parentNode; cur;) {
-          if (cur == doc.body || (x && y)) {
+          if (cur == doc.body || ((!getX || x) && y)) {
               break;
           }
           else if (cur.nodeType == 1) {
               if (!y && cur.scrollHeight > cur.clientHeight)
                   y = cur;
-              if (!x && cur.scrollWidth > cur.clientWidth)
+              if (getX && !x && cur.scrollWidth > cur.clientWidth)
                   x = cur;
               cur = cur.assignedSlot || cur.parentNode;
           }
@@ -5041,6 +5041,8 @@
       }
   }
   function isScrolledToBottom(elt) {
+      if (elt instanceof Window)
+          return elt.pageYOffset > Math.max(0, elt.document.documentElement.scrollHeight - elt.innerHeight - 4);
       return elt.scrollTop > Math.max(1, elt.scrollHeight - elt.clientHeight - 4);
   }
   function textNodeBefore(startNode, startOffset) {
@@ -6938,7 +6940,7 @@
                   }
                   else if (tile.isText()) {
                       this.builder.ensureLine(null);
-                      if (!from && to == tile.length) {
+                      if (!from && to == tile.length && !this.cache.reused.has(tile)) {
                           this.builder.addText(tile.text, activeMarks, openMarks, this.cache.reuse(tile));
                       }
                       else {
@@ -7073,9 +7075,10 @@
                   marks.push(tile);
               else if (tile === null || tile === void 0 ? void 0 : tile.isLine())
                   line = tile;
+              else if (tile instanceof BlockWrapperTile) ; // Ignore
               else if (parent.nodeName == "DIV" && !line && parent != this.view.contentDOM)
                   line = new LineTile(parent, lineBaseAttrs);
-              else
+              else if (!line)
                   marks.push(MarkTile.of(new MarkDecoration({ tagName: parent.nodeName.toLowerCase(), attributes: getAttrs(parent) }), parent));
           }
           return { line: line, marks };
@@ -7241,6 +7244,8 @@
               if (composition || changes.length) {
                   let oldTile = this.tile;
                   let builder = new TileUpdate(this.view, oldTile, this.blockWrappers, this.decorations, this.dynamicDecorationMap);
+                  if (composition && Tile.get(composition.text))
+                      builder.cache.reused.set(Tile.get(composition.text), 2 /* Reused.DOM */);
                   this.tile = builder.run(changes, composition);
                   destroyDropped(oldTile, builder.cache.reused);
               }
@@ -7701,6 +7706,19 @@
           };
           let { offsetWidth, offsetHeight } = this.view.scrollDOM;
           scrollRectIntoView(this.view.scrollDOM, targetRect, range.head < range.anchor ? -1 : 1, target.x, target.y, Math.max(Math.min(target.xMargin, offsetWidth), -offsetWidth), Math.max(Math.min(target.yMargin, offsetHeight), -offsetHeight), this.view.textDirection == Direction.LTR);
+          // On mobile browsers, the visual viewport may be smaller than the
+          // actual reported viewport, causing scrollRectIntoView to fail to
+          // scroll properly. Unfortunately, this visual viewport cannot be
+          // updated directly, and scrollIntoView is the only way a script
+          // can affect it. So this tries to kludge around the problem by
+          // calling scrollIntoView on the scroll target's line.
+          if (window.visualViewport && window.innerHeight - window.visualViewport.height > 1 &&
+              (rect.top > window.pageYOffset + window.visualViewport.offsetTop + window.visualViewport.height ||
+                  rect.bottom < window.pageYOffset + window.visualViewport.offsetTop)) {
+              let line = this.view.docView.lineAt(range.head, 1);
+              if (line)
+                  line.dom.scrollIntoView({ block: "nearest" });
+          }
       }
       lineHasWidget(pos) {
           let scan = (child) => child.isWidget() || child.children.some(scan);
@@ -8049,86 +8067,167 @@
       let line = view.docView.lineAt(block.from, 2);
       if (!line || line.length != block.length)
           line = view.docView.lineAt(block.from, -2);
-      return posAtCoordsInline(view, line, block.from, x, y);
+      return new InlineCoordsScan(view, x, y, view.textDirectionAt(block.from)).scanTile(line, block.from);
   }
-  // Scan through the rectangles for the content of a tile, finding the
-  // one closest to the given coordinates, prefering closeness in Y over
-  // closeness in X.
-  //
-  // If this is a text tile, go character-by-character. For line or mark
-  // tiles, check each non-point-widget child, and descend text or mark
-  // tiles with a recursive call.
-  //
-  // For non-wrapped, purely left-to-right text, this could use a binary
-  // search. But because this seems to be fast enough, for how often it
-  // is called, there's not currently a specialized implementation for
-  // that.
-  function posAtCoordsInline(view, tile, offset, x, y) {
-      let closest = -1, closestRect = null;
-      let dxClosest = 1e9, dyClosest = 1e9;
-      let rowTop = y, rowBot = y;
-      let checkRects = (rects, index) => {
-          for (let i = 0; i < rects.length; i++) {
-              let rect = rects[i];
-              if (rect.top == rect.bottom)
-                  continue;
-              let dx = rect.left > x ? rect.left - x : rect.right < x ? x - rect.right : 0;
-              let dy = rect.top > y ? rect.top - y : rect.bottom < y ? y - rect.bottom : 0;
-              if (rect.top <= rowBot && rect.bottom >= rowTop) {
-                  // Rectangle is in the current row
-                  rowTop = Math.min(rect.top, rowTop);
-                  rowBot = Math.max(rect.bottom, rowBot);
-                  dy = 0;
-              }
-              if (closest < 0 || (dy - dyClosest || dx - dxClosest) < 0) {
-                  if (closest >= 0 && dyClosest && dxClosest < dx &&
-                      closestRect.top <= rowBot - 2 && closestRect.bottom >= rowTop + 2) {
-                      // Retroactively set dy to 0 if the current match is in this row.
-                      dyClosest = 0;
-                  }
-                  else {
-                      closest = index;
-                      dxClosest = dx;
-                      dyClosest = dy;
-                      closestRect = rect;
+  class InlineCoordsScan {
+      constructor(view, x, y, baseDir) {
+          this.view = view;
+          this.x = x;
+          this.y = y;
+          this.baseDir = baseDir;
+          // Cached bidi info
+          this.line = null;
+          this.spans = null;
+      }
+      bidiSpansAt(pos) {
+          if (!this.line || this.line.from > pos || this.line.to < pos) {
+              this.line = this.view.state.doc.lineAt(pos);
+              this.spans = this.view.bidiSpans(this.line);
+          }
+          return this;
+      }
+      baseDirAt(pos, side) {
+          let { line, spans } = this.bidiSpansAt(pos);
+          let level = spans[BidiSpan.find(spans, pos - line.from, -1, side)].level;
+          return level == this.baseDir;
+      }
+      dirAt(pos, side) {
+          let { line, spans } = this.bidiSpansAt(pos);
+          return spans[BidiSpan.find(spans, pos - line.from, -1, side)].dir;
+      }
+      // Used to short-circuit bidi tests for content with a uniform direction
+      bidiIn(from, to) {
+          let { spans, line } = this.bidiSpansAt(from);
+          return spans.length > 1 || spans.length && (spans[0].level != this.baseDir || spans[0].to + line.from < to);
+      }
+      // Scan through the rectangles for the content of a tile with inline
+      // content, looking for one that overlaps the queried position
+      // vertically andis
+      // closest horizontally. The caller is responsible for dividing its
+      // content into N pieces, and pass an array with N+1 positions
+      // (including the position after the last piece). For a text tile,
+      // these will be character clusters, for a composite tile, these
+      // will be child tiles.
+      scan(positions, getRects) {
+          let lo = 0, hi = positions.length - 1, seen = new Set();
+          let bidi = this.bidiIn(positions[0], positions[hi]);
+          let above, below;
+          let closestI = -1, closestDx = 1e9, closestRect;
+          // Because, when the content is bidirectional, a regular binary
+          // search is hard to perform (the content order does not
+          // correspond to visual order), this loop does something between a
+          // regular binary search and a full scan, depending on what it can
+          // get away with. The outer hi/lo bounds are only adjusted for
+          // elements that are part of the base order.
+          //
+          // To make sure all elements inside those bounds are visited,
+          // eventually, we keep a set of seen indices, and if the midpoint
+          // has already been handled, we start in a random index within the
+          // current bounds and scan forward until we find an index that
+          // hasn't been seen yet.
+          search: while (lo < hi) {
+              let dist = hi - lo, mid = (lo + hi) >> 1;
+              adjust: if (seen.has(mid)) {
+                  let scan = lo + Math.floor(Math.random() * dist);
+                  for (let i = 0; i < dist; i++) {
+                      if (!seen.has(scan)) {
+                          mid = scan;
+                          break adjust;
+                      }
+                      scan++;
+                      if (scan == hi)
+                          scan = lo; // Wrap around
                   }
+                  break search; // No index found, we're done
               }
+              seen.add(mid);
+              let rects = getRects(mid);
+              if (rects)
+                  for (let i = 0; i < rects.length; i++) {
+                      let rect = rects[i], side = 0;
+                      // Ignore empty rectangles when there are other rectangles
+                      if (rect.width == 0 && rects.length > 1)
+                          continue;
+                      if (rect.bottom < this.y) {
+                          if (!above || above.bottom < rect.bottom)
+                              above = rect;
+                          side = 1;
+                      }
+                      else if (rect.top > this.y) {
+                          if (!below || below.top > rect.top)
+                              below = rect;
+                          side = -1;
+                      }
+                      else {
+                          let off = rect.left > this.x ? this.x - rect.left : rect.right < this.x ? this.x - rect.right : 0;
+                          let dx = Math.abs(off);
+                          if (dx < closestDx) {
+                              closestI = mid;
+                              closestDx = dx;
+                              closestRect = rect;
+                          }
+                          if (off)
+                              side = (off < 0) == (this.baseDir == Direction.LTR) ? -1 : 1;
+                      }
+                      // Narrow binary search when it is safe to do so
+                      if (side == -1 && (!bidi || this.baseDirAt(positions[mid], 1)))
+                          hi = mid;
+                      else if (side == 1 && (!bidi || this.baseDirAt(positions[mid + 1], -1)))
+                          lo = mid + 1;
+                  }
           }
-      };
-      if (tile.isText()) {
-          for (let i = 0; i < tile.length;) {
-              let next = findClusterBreak(tile.text, i);
-              checkRects(textRange(tile.dom, i, next).getClientRects(), i);
-              if (!dxClosest && !dyClosest)
-                  break;
-              i = next;
+          // If no element with y overlap is found, find the nearest element
+          // on the y axis, move this.y into it, and retry the scan.
+          if (!closestRect) {
+              let side = above && (!below || (this.y - above.bottom < below.top - this.y)) ? above : below;
+              this.y = (side.top + side.bottom) / 2;
+              return this.scan(positions, getRects);
           }
-          let after = (x > (closestRect.left + closestRect.right) / 2) == (dirAt(view, closest + offset) == Direction.LTR);
-          return after ? new PosAssoc(offset + findClusterBreak(tile.text, closest), -1) : new PosAssoc(offset + closest, 1);
+          let ltr = (bidi ? this.dirAt(positions[closestI], 1) : this.baseDir) == Direction.LTR;
+          return {
+              i: closestI,
+              // Test whether x is closes to the start or end of this element
+              after: (this.x > (closestRect.left + closestRect.right) / 2) == ltr
+          };
       }
-      else {
+      scanText(tile, offset) {
+          let positions = [];
+          for (let i = 0; i < tile.length; i = findClusterBreak(tile.text, i))
+              positions.push(offset + i);
+          positions.push(offset + tile.length);
+          let scan = this.scan(positions, i => {
+              let off = positions[i] - offset, end = positions[i + 1] - offset;
+              return textRange(tile.dom, off, end).getClientRects();
+          });
+          return scan.after ? new PosAssoc(positions[scan.i + 1], -1) : new PosAssoc(positions[scan.i], 1);
+      }
+      scanTile(tile, offset) {
           if (!tile.length)
               return new PosAssoc(offset, 1);
-          for (let i = 0; i < tile.children.length; i++) {
+          if (tile.children.length == 1) { // Short-circuit single-child tiles
+              let child = tile.children[0];
+              if (child.isText())
+                  return this.scanText(child, offset);
+              else if (child.isComposite())
+                  return this.scanTile(child, offset);
+          }
+          let positions = [offset];
+          for (let i = 0, pos = offset; i < tile.children.length; i++)
+              positions.push(pos += tile.children[i].length);
+          let scan = this.scan(positions, i => {
               let child = tile.children[i];
               if (child.flags & 48 /* TileFlag.PointWidget */)
-                  continue;
-              let rects = (child.dom.nodeType == 1 ? child.dom : textRange(child.dom, 0, child.length)).getClientRects();
-              checkRects(rects, i);
-              if (!dxClosest && !dyClosest)
-                  break;
-          }
-          let inner = tile.children[closest], innerOff = tile.posBefore(inner, offset);
-          if (inner.isComposite() || inner.isText())
-              return posAtCoordsInline(view, inner, innerOff, Math.max(closestRect.left, Math.min(closestRect.right, x)), y);
-          let after = (x > (closestRect.left + closestRect.right) / 2) == (dirAt(view, closest + offset) == Direction.LTR);
-          return after ? new PosAssoc(innerOff + inner.length, -1) : new PosAssoc(innerOff, 1);
+                  return null;
+              return (child.dom.nodeType == 1 ? child.dom : textRange(child.dom, 0, child.length)).getClientRects();
+          });
+          let child = tile.children[scan.i], pos = positions[scan.i];
+          if (child.isText())
+              return this.scanText(child, pos);
+          if (child.isComposite())
+              return this.scanTile(child, pos);
+          return scan.after ? new PosAssoc(positions[scan.i + 1], -1) : new PosAssoc(pos, 1);
       }
   }
-  function dirAt(view, pos) {
-      let line = view.state.doc.lineAt(pos), spans = view.bidiSpans(line);
-      return spans[BidiSpan.find(view.bidiSpans(line), pos - line.from, -1, 1)].dir;
-  }
 
   const LineBreakPlaceholder = "\uffff";
   class DOMReader {
@@ -8272,7 +8371,7 @@
           this.bounds = null;
           this.text = "";
           this.domChanged = start > -1;
-          let { impreciseHead: iHead, impreciseAnchor: iAnchor } = view.docView;
+          let { impreciseHead: iHead, impreciseAnchor: iAnchor } = view.docView, curSel = view.state.selection;
           if (view.state.readOnly && start > -1) {
               // Ignore changes when the editor is read-only
               this.newSel = null;
@@ -8288,18 +8387,18 @@
               let domSel = view.observer.selectionRange;
               let head = iHead && iHead.node == domSel.focusNode && iHead.offset == domSel.focusOffset ||
                   !contains(view.contentDOM, domSel.focusNode)
-                  ? view.state.selection.main.head
+                  ? curSel.main.head
                   : view.docView.posFromDOM(domSel.focusNode, domSel.focusOffset);
               let anchor = iAnchor && iAnchor.node == domSel.anchorNode && iAnchor.offset == domSel.anchorOffset ||
                   !contains(view.contentDOM, domSel.anchorNode)
-                  ? view.state.selection.main.anchor
+                  ? curSel.main.anchor
                   : view.docView.posFromDOM(domSel.anchorNode, domSel.anchorOffset);
               // iOS will refuse to select the block gaps when doing
               // select-all.
               // Chrome will put the selection *inside* them, confusing
               // posFromDOM
               let vp = view.viewport;
-              if ((browser.ios || browser.chrome) && view.state.selection.main.empty && head != anchor &&
+              if ((browser.ios || browser.chrome) && curSel.main.empty && head != anchor &&
                   (vp.from > 0 || vp.to < view.state.doc.length)) {
                   let from = Math.min(head, anchor), to = Math.max(head, anchor);
                   let offFrom = vp.from - from, offTo = vp.to - to;
@@ -8308,10 +8407,22 @@
                       anchor = view.state.doc.length;
                   }
               }
-              if (view.inputState.composing > -1 && view.state.selection.ranges.length > 1)
-                  this.newSel = view.state.selection.replaceRange(EditorSelection.range(anchor, head));
-              else
+              if (view.inputState.composing > -1 && curSel.ranges.length > 1) {
+                  this.newSel = curSel.replaceRange(EditorSelection.range(anchor, head));
+              }
+              else if (view.lineWrapping && anchor == head && !(curSel.main.empty && curSel.main.head == head) &&
+                  view.inputState.lastTouchTime > Date.now() - 100) {
+                  // If this is a cursor selection change in a line-wrapping
+                  // editor that may have been a touch, use the last touch
+                  // position to assign a side to the cursor.
+                  let before = view.coordsAtPos(head, -1), assoc = 0;
+                  if (before)
+                      assoc = view.inputState.lastTouchY <= before.bottom ? -1 : 1;
+                  this.newSel = EditorSelection.create([EditorSelection.cursor(head, assoc)]);
+              }
+              else {
                   this.newSel = EditorSelection.single(anchor, head);
+              }
           }
       }
   }
@@ -8347,7 +8458,7 @@
   }
   function applyDOMChange(view, domChange) {
       let change;
-      let { newSel } = domChange, sel = view.state.selection.main;
+      let { newSel } = domChange, { state } = view, sel = state.selection.main;
       let lastKey = view.inputState.lastKeyTime > Date.now() - 100 ? view.inputState.lastKeyCode : -1;
       if (domChange.bounds) {
           let { from, to } = domChange.bounds;
@@ -8358,8 +8469,15 @@
               preferredPos = sel.to;
               preferredSide = "end";
           }
-          let diff = findDiff(view.state.doc.sliceString(from, to, LineBreakPlaceholder), domChange.text, preferredPos - from, preferredSide);
-          if (diff) {
+          let cmp = state.doc.sliceString(from, to, LineBreakPlaceholder), selEnd, diff;
+          if (!sel.empty && sel.from >= from && sel.to <= to && (domChange.typeOver || cmp != domChange.text) &&
+              cmp.slice(0, sel.from - from) == domChange.text.slice(0, sel.from - from) &&
+              cmp.slice(sel.to - from) == domChange.text.slice(selEnd = domChange.text.length - (cmp.length - (sel.to - from)))) {
+              // This looks like a selection replacement
+              change = { from: sel.from, to: sel.to,
+                  insert: Text.of(domChange.text.slice(sel.from - from, selEnd).split(LineBreakPlaceholder)) };
+          }
+          else if (diff = findDiff(cmp, domChange.text, preferredPos - from, preferredSide)) {
               // Chrome inserts two newlines when pressing shift-enter at the
               // end of a line. DomChange drops one of those.
               if (browser.chrome && lastKey == 13 &&
@@ -8369,16 +8487,12 @@
                   insert: Text.of(domChange.text.slice(diff.from, diff.toB).split(LineBreakPlaceholder)) };
           }
       }
-      else if (newSel && (!view.hasFocus && view.state.facet(editable) || sameSelPos(newSel, sel))) {
+      else if (newSel && (!view.hasFocus && state.facet(editable) || sameSelPos(newSel, sel))) {
           newSel = null;
       }
       if (!change && !newSel)
           return false;
-      if (!change && domChange.typeOver && !sel.empty && newSel && newSel.main.empty) {
-          // Heuristic to notice typing over a selected character
-          change = { from: sel.from, to: sel.to, insert: view.state.doc.slice(sel.from, sel.to) };
-      }
-      else if ((browser.mac || browser.android) && change && change.from == change.to && change.from == sel.head - 1 &&
+      if ((browser.mac || browser.android) && change && change.from == change.to && change.from == sel.head - 1 &&
           /^\. ?$/.test(change.insert.toString()) && view.contentDOM.getAttribute("autocorrect") == "off") {
           // Detect insert-period-on-double-space Mac and Android behavior,
           // and transform it into a regular space insert.
@@ -8386,18 +8500,7 @@
               newSel = EditorSelection.single(newSel.main.anchor - 1, newSel.main.head - 1);
           change = { from: change.from, to: change.to, insert: Text.of([change.insert.toString().replace(".", " ")]) };
       }
-      else if (change && change.from >= sel.from && change.to <= sel.to &&
-          (change.from != sel.from || change.to != sel.to) &&
-          (sel.to - sel.from) - (change.to - change.from) <= 4) {
-          // If the change is inside the selection and covers most of it,
-          // assume it is a selection replace (with identical characters at
-          // the start/end not included in the diff)
-          change = {
-              from: sel.from, to: sel.to,
-              insert: view.state.doc.slice(sel.from, change.from).append(change.insert).append(view.state.doc.slice(change.to, sel.to))
-          };
-      }
-      else if (view.state.doc.lineAt(sel.from).to < sel.to && view.docView.lineHasWidget(sel.to) &&
+      else if (state.doc.lineAt(sel.from).to < sel.to && view.docView.lineHasWidget(sel.to) &&
           view.inputState.insertingTextAt > Date.now() - 50) {
           // For a cross-line insertion, Chrome and Safari will crudely take
           // the text of the line after the selection, flattening any
@@ -8406,7 +8509,7 @@
           // replace of the text provided by the beforeinput event.
           change = {
               from: sel.from, to: sel.to,
-              insert: view.state.toText(view.inputState.insertingText)
+              insert: state.toText(view.inputState.insertingText)
           };
       }
       else if (browser.chrome && change && change.from == change.to && change.from == sel.head &&
@@ -8428,7 +8531,7 @@
                   scrollIntoView = true;
               userEvent = view.inputState.lastSelectionOrigin;
               if (userEvent == "select.pointer")
-                  newSel = skipAtomsForSelection(view.state.facet(atomicRanges).map(f => f(view)), newSel);
+                  newSel = skipAtomsForSelection(state.facet(atomicRanges).map(f => f(view)), newSel);
           }
           view.dispatch({ selection: newSel, scrollIntoView, userEvent });
           return true;
@@ -8606,9 +8709,12 @@
           this.lastKeyCode = 0;
           this.lastKeyTime = 0;
           this.lastTouchTime = 0;
+          this.lastTouchX = 0;
+          this.lastTouchY = 0;
           this.lastFocusTime = 0;
           this.lastScrollTop = 0;
           this.lastScrollLeft = 0;
+          this.lastWheelEvent = 0;
           // On iOS, some keys need to have their default behavior happen
           // (after which we retroactively handle them and reset the DOM) to
           // avoid messing up the virtual keyboard state.
@@ -9038,6 +9144,9 @@
       view.inputState.lastScrollTop = view.scrollDOM.scrollTop;
       view.inputState.lastScrollLeft = view.scrollDOM.scrollLeft;
   };
+  observers.wheel = observers.mousewheel = view => {
+      view.inputState.lastWheelEvent = Date.now();
+  };
   handlers.keydown = (view, event) => {
       view.inputState.setSelectionOrigin("select");
       if (event.keyCode == 27 && view.inputState.tabFocusMode != 0)
@@ -9045,8 +9154,13 @@
       return false;
   };
   observers.touchstart = (view, e) => {
-      view.inputState.lastTouchTime = Date.now();
-      view.inputState.setSelectionOrigin("select.pointer");
+      let iState = view.inputState, touch = e.targetTouches[0];
+      iState.lastTouchTime = Date.now();
+      if (touch) {
+          iState.lastTouchX = touch.clientX;
+          iState.lastTouchY = touch.clientY;
+      }
+      iState.setSelectionOrigin("select.pointer");
   };
   observers.touchmove = view => {
       view.inputState.setSelectionOrigin("select.pointer");
@@ -9282,8 +9396,7 @@
       // spans multiple elements including this CodeMirror. The copy event may
       // bubble through CodeMirror (e.g. when CodeMirror is the first or the last
       // element in the selection), but we should let the parent handle it.
-      let domSel = getSelection(view.root);
-      if (domSel && !hasSelection(view.contentDOM, domSel))
+      if (!hasSelection(view.contentDOM, view.observer.selectionRange))
           return false;
       let { text, ranges, linewise } = copiedRange(view.state);
       if (!text && !linewise)
@@ -10282,7 +10395,8 @@
       get estimatedHeight() { return this.vertical ? this.size : -1; }
   }
   class ViewState {
-      constructor(state) {
+      constructor(view, state) {
+          this.view = view;
           this.state = state;
           // These are contentDOM-local coordinates
           this.pixelViewport = { left: 0, right: window.innerWidth, top: 0, bottom: 0 };
@@ -10293,12 +10407,14 @@
           this.contentDOMHeight = 0; // contentDOM.getBoundingClientRect().height
           this.editorHeight = 0; // scrollDOM.clientHeight, unscaled
           this.editorWidth = 0; // scrollDOM.clientWidth, unscaled
-          this.scrollTop = 0; // Last seen scrollDOM.scrollTop, scaled
-          this.scrolledToBottom = false;
           // The CSS-transformation scale of the editor (transformed size /
           // concrete size)
           this.scaleX = 1;
           this.scaleY = 1;
+          // Last seen vertical offset of the element at the top of the scroll
+          // container, or top of the window if there's no wrapping scroller
+          this.scrollOffset = 0;
+          this.scrolledToBottom = false;
           // The vertical position (document-relative) to which to anchor the
           // scroll position. -1 means anchor to the end of the document.
           this.scrollAnchorPos = 0;
@@ -10336,6 +10452,7 @@
           this.updateViewportLines();
           this.lineGaps = this.ensureLineGaps([]);
           this.lineGapDeco = Decoration.set(this.lineGaps.map(gap => gap.draw(this, false)));
+          this.scrollParent = view.scrollDOM;
           this.computeVisibleRanges();
       }
       updateForViewport() {
@@ -10369,7 +10486,7 @@
           let contentChanges = update.changedRanges;
           let heightChanges = ChangedRange.extendWithRanges(contentChanges, heightRelevantDecoChanges(prevDeco, this.stateDeco, update ? update.changes : ChangeSet.empty(this.state.doc.length)));
           let prevHeight = this.heightMap.height;
-          let scrollAnchor = this.scrolledToBottom ? null : this.scrollAnchorAt(this.scrollTop);
+          let scrollAnchor = this.scrolledToBottom ? null : this.scrollAnchorAt(this.scrollOffset);
           clearHeightChangeFlag();
           this.heightMap = this.heightMap.applyChanges(this.stateDeco, update.startState.doc, this.heightOracle.setDoc(this.state.doc), heightChanges);
           if (this.heightMap.height != prevHeight || heightChangeFlag)
@@ -10401,12 +10518,12 @@
               !update.state.facet(nativeSelectionHidden))
               this.mustEnforceCursorAssoc = true;
       }
-      measure(view) {
-          let dom = view.contentDOM, style = window.getComputedStyle(dom);
+      measure() {
+          let { view } = this, dom = view.contentDOM, style = window.getComputedStyle(dom);
           let oracle = this.heightOracle;
           let whiteSpace = style.whiteSpace;
           this.defaultTextDirection = style.direction == "rtl" ? Direction.RTL : Direction.LTR;
-          let refresh = this.heightOracle.mustRefreshForWrapping(whiteSpace) || this.mustMeasureContent;
+          let refresh = this.heightOracle.mustRefreshForWrapping(whiteSpace) || this.mustMeasureContent === "refresh";
           let domRect = dom.getBoundingClientRect();
           let measureContent = refresh || this.mustMeasureContent || this.contentDOMHeight != domRect.height;
           this.contentDOMHeight = domRect.height;
@@ -10436,12 +10553,18 @@
               this.editorWidth = view.scrollDOM.clientWidth;
               result |= 16 /* UpdateFlag.Geometry */;
           }
-          let scrollTop = view.scrollDOM.scrollTop * this.scaleY;
-          if (this.scrollTop != scrollTop) {
+          let scrollParent = scrollableParents(this.view.contentDOM, false).y;
+          if (scrollParent != this.scrollParent) {
+              this.scrollParent = scrollParent;
               this.scrollAnchorHeight = -1;
-              this.scrollTop = scrollTop;
+              this.scrollOffset = 0;
           }
-          this.scrolledToBottom = isScrolledToBottom(view.scrollDOM);
+          let scrollOffset = this.getScrollOffset();
+          if (this.scrollOffset != scrollOffset) {
+              this.scrollAnchorHeight = -1;
+              this.scrollOffset = scrollOffset;
+          }
+          this.scrolledToBottom = isScrolledToBottom(this.scrollParent || view.win);
           // Pixel viewport
           let pixelViewport = (this.printing ? fullPixelRange : visiblePixelRange)(dom, this.paddingTop);
           let dTop = pixelViewport.top - this.pixelViewport.top, dBottom = pixelViewport.bottom - this.pixelViewport.bottom;
@@ -10718,9 +10841,14 @@
               this.viewportLines.find(l => l.top <= height && l.bottom >= height)) ||
               scaleBlock(this.heightMap.lineAt(this.scaler.fromDOM(height), QueryType$1.ByHeight, this.heightOracle, 0, 0), this.scaler);
       }
-      scrollAnchorAt(scrollTop) {
-          let block = this.lineBlockAtHeight(scrollTop + 8);
-          return block.from >= this.viewport.from || this.viewportLines[0].top - scrollTop > 200 ? block : this.viewportLines[0];
+      getScrollOffset() {
+          let base = this.scrollParent == this.view.scrollDOM ? this.scrollParent.scrollTop
+              : (this.scrollParent ? this.scrollParent.getBoundingClientRect().top : 0) - this.view.contentDOM.getBoundingClientRect().top;
+          return base * this.scaleY;
+      }
+      scrollAnchorAt(scrollOffset) {
+          let block = this.lineBlockAtHeight(scrollOffset + 8);
+          return block.from >= this.viewport.from || this.viewportLines[0].top - scrollOffset > 200 ? block : this.viewportLines[0];
       }
       elementAtHeight(height) {
           return scaleBlock(this.heightMap.blockAt(this.scaler.fromDOM(height), this.heightOracle, 0, 0), this.scaler);
@@ -10973,6 +11101,21 @@
       "&dark .cm-cursor": {
           borderLeftColor: "#ddd"
       },
+      ".cm-selectionHandle": {
+          backgroundColor: "currentColor",
+          width: "1.5px"
+      },
+      ".cm-selectionHandle-start::before, .cm-selectionHandle-end::before": {
+          content: '""',
+          backgroundColor: "inherit",
+          borderRadius: "50%",
+          width: "8px",
+          height: "8px",
+          position: "absolute",
+          left: "-3.25px"
+      },
+      ".cm-selectionHandle-start::before": { top: "-8px" },
+      ".cm-selectionHandle-end::before": { bottom: "-8px" },
       ".cm-dropCursor": {
           position: "absolute"
       },
@@ -11967,7 +12110,7 @@
               ((trs) => this.update(trs));
           this.dispatch = this.dispatch.bind(this);
           this._root = (config.root || getRoot(config.parent) || document);
-          this.viewState = new ViewState(config.state || EditorState.create(config));
+          this.viewState = new ViewState(this, config.state || EditorState.create(config));
           if (config.scrollTo && config.scrollTo.is(scrollIntoView$1))
               this.viewState.scrollTarget = config.scrollTo.value.clip(this.viewState.state);
           this.plugins = this.state.facet(viewPlugin).map(spec => new PluginInstance(spec));
@@ -11983,7 +12126,7 @@
           this.requestMeasure();
           if ((_a = document.fonts) === null || _a === void 0 ? void 0 : _a.ready)
               document.fonts.ready.then(() => {
-                  this.viewState.mustMeasureContent = true;
+                  this.viewState.mustMeasureContent = "refresh";
                   this.requestMeasure();
               });
       }
@@ -12122,7 +12265,7 @@
           try {
               for (let plugin of this.plugins)
                   plugin.destroy(this);
-              this.viewState = new ViewState(newState);
+              this.viewState = new ViewState(this, newState);
               this.plugins = newState.facet(viewPlugin).map(spec => new PluginInstance(spec));
               this.pluginMap.clear();
               for (let plugin of this.plugins)
@@ -12201,26 +12344,26 @@
           if (flush)
               this.observer.forceFlush();
           let updated = null;
-          let sDOM = this.scrollDOM, scrollTop = sDOM.scrollTop * this.scaleY;
+          let scroll = this.viewState.scrollParent, scrollOffset = this.viewState.getScrollOffset();
           let { scrollAnchorPos, scrollAnchorHeight } = this.viewState;
-          if (Math.abs(scrollTop - this.viewState.scrollTop) > 1)
+          if (Math.abs(scrollOffset - this.viewState.scrollOffset) > 1)
               scrollAnchorHeight = -1;
           this.viewState.scrollAnchorHeight = -1;
           try {
               for (let i = 0;; i++) {
                   if (scrollAnchorHeight < 0) {
-                      if (isScrolledToBottom(sDOM)) {
+                      if (isScrolledToBottom(scroll || this.win)) {
                           scrollAnchorPos = -1;
                           scrollAnchorHeight = this.viewState.heightMap.height;
                       }
                       else {
-                          let block = this.viewState.scrollAnchorAt(scrollTop);
+                          let block = this.viewState.scrollAnchorAt(scrollOffset);
                           scrollAnchorPos = block.from;
                           scrollAnchorHeight = block.top;
                       }
                   }
                   this.updateState = 1 /* UpdateState.Measuring */;
-                  let changed = this.viewState.measure(this);
+                  let changed = this.viewState.measure();
                   if (!changed && !this.measureRequests.length && this.viewState.scrollTarget == null)
                       break;
                   if (i > 5) {
@@ -12281,10 +12424,15 @@
                           else {
                               let newAnchorHeight = scrollAnchorPos < 0 ? this.viewState.heightMap.height :
                                   this.viewState.lineBlockAt(scrollAnchorPos).top;
-                              let diff = newAnchorHeight - scrollAnchorHeight;
-                              if (diff > 1 || diff < -1) {
-                                  scrollTop = scrollTop + diff;
-                                  sDOM.scrollTop = scrollTop / this.scaleY;
+                              let diff = (newAnchorHeight - scrollAnchorHeight) / this.scaleY;
+                              if ((diff > 1 || diff < -1) &&
+                                  (scroll == this.scrollDOM || this.hasFocus ||
+                                      Math.max(this.inputState.lastWheelEvent, this.inputState.lastTouchTime) > Date.now() - 100)) {
+                                  scrollOffset = scrollOffset + diff;
+                                  if (scroll)
+                                      scroll.scrollTop += diff;
+                                  else
+                                      this.win.scrollBy(0, diff);
                                   scrollAnchorHeight = -1;
                                   continue;
                               }
@@ -13532,7 +13680,8 @@
       combine(configs) {
           return combineConfig(configs, {
               cursorBlinkRate: 1200,
-              drawRangeCursor: true
+              drawRangeCursor: true,
+              iosSelectionHandles: true
           }, {
               cursorBlinkRate: (a, b) => Math.min(a, b),
               drawRangeCursor: (a, b) => a || b
@@ -13576,7 +13725,7 @@
           let cursors = [];
           for (let r of state.selection.ranges) {
               let prim = r == state.selection.main;
-              if (r.empty || conf.drawRangeCursor) {
+              if (r.empty || conf.drawRangeCursor && !(prim && browser.ios && conf.iosSelectionHandles)) {
                   let className = prim ? "cm-cursor cm-cursor-primary" : "cm-cursor cm-cursor-secondary";
                   let cursor = r.empty ? r : EditorSelection.cursor(r.head, r.head > r.anchor ? -1 : 1);
                   for (let piece of RectangleMarker.forRange(view, className, cursor))
@@ -13604,8 +13753,19 @@
   const selectionLayer = /*@__PURE__*/layer({
       above: false,
       markers(view) {
-          return view.state.selection.ranges.map(r => r.empty ? [] : RectangleMarker.forRange(view, "cm-selectionBackground", r))
-              .reduce((a, b) => a.concat(b));
+          let markers = [], { main, ranges } = view.state.selection;
+          for (let r of ranges)
+              if (!r.empty) {
+                  for (let marker of RectangleMarker.forRange(view, "cm-selectionBackground", r))
+                      markers.push(marker);
+              }
+          if (browser.ios && !main.empty && view.state.facet(selectionConfig).iosSelectionHandles) {
+              for (let piece of RectangleMarker.forRange(view, "cm-selectionHandle cm-selectionHandle-start", EditorSelection.cursor(main.from, 1)))
+                  markers.push(piece);
+              for (let piece of RectangleMarker.forRange(view, "cm-selectionHandle cm-selectionHandle-end", EditorSelection.cursor(main.to, 1)))
+                  markers.push(piece);
+          }
+          return markers;
       },
       update(update, dom) {
           return update.docChanged || update.selectionSet || update.viewportChanged || configChanged(update);
@@ -19937,30 +20097,44 @@
           decorations.push(mark.range(match.end.from, match.end.to));
       return decorations;
   }
-  const bracketMatchingState = /*@__PURE__*/StateField.define({
-      create() { return Decoration.none; },
-      update(deco, tr) {
-          if (!tr.docChanged && !tr.selection)
-              return deco;
-          let decorations = [];
-          let config = tr.state.facet(bracketMatchingConfig);
-          for (let range of tr.state.selection.ranges) {
-              if (!range.empty)
-                  continue;
-              let match = matchBrackets(tr.state, range.head, -1, config)
-                  || (range.head > 0 && matchBrackets(tr.state, range.head - 1, 1, config))
-                  || (config.afterCursor &&
-                      (matchBrackets(tr.state, range.head, 1, config) ||
-                          (range.head < tr.state.doc.length && matchBrackets(tr.state, range.head + 1, -1, config))));
-              if (match)
-                  decorations = decorations.concat(config.renderMatch(match, tr.state));
-          }
-          return Decoration.set(decorations, true);
-      },
-      provide: f => EditorView.decorations.from(f)
+  function bracketDeco(state) {
+      let decorations = [];
+      let config = state.facet(bracketMatchingConfig);
+      for (let range of state.selection.ranges) {
+          if (!range.empty)
+              continue;
+          let match = matchBrackets(state, range.head, -1, config)
+              || (range.head > 0 && matchBrackets(state, range.head - 1, 1, config))
+              || (config.afterCursor &&
+                  (matchBrackets(state, range.head, 1, config) ||
+                      (range.head < state.doc.length && matchBrackets(state, range.head + 1, -1, config))));
+          if (match)
+              decorations = decorations.concat(config.renderMatch(match, state));
+      }
+      return Decoration.set(decorations, true);
+  }
+  const bracketMatcher = /*@__PURE__*/ViewPlugin.fromClass(class {
+      constructor(view) {
+          this.paused = false;
+          this.decorations = bracketDeco(view.state);
+      }
+      update(update) {
+          if (update.docChanged || update.selectionSet || this.paused) {
+              if (update.view.composing) {
+                  this.decorations = this.decorations.map(update.changes);
+                  this.paused = true;
+              }
+              else {
+                  this.decorations = bracketDeco(update.state);
+                  this.paused = false;
+              }
+          }
+      }
+  }, {
+      decorations: v => v.decorations
   });
   const bracketMatchingUnique = [
-      bracketMatchingState,
+      bracketMatcher,
       baseTheme$3
   ];
   /**
@@ -23231,6 +23405,7 @@
       };
   }
 
+  const setSelectedEffect = /*@__PURE__*/StateEffect.define();
   function optionContent(config) {
       let content = config.addToOptions.slice();
       if (config.icons)
@@ -23322,6 +23497,16 @@
                       return;
                   }
               }
+              if (e.target == this.list) {
+                  let move = this.list.classList.contains("cm-completionListIncompleteTop") &&
+                      e.clientY < this.list.firstChild.getBoundingClientRect().top ? this.range.from - 1 :
+                      this.list.classList.contains("cm-completionListIncompleteBottom") &&
+                          e.clientY > this.list.lastChild.getBoundingClientRect().bottom ? this.range.to : null;
+                  if (move != null) {
+                      view.dispatch({ effects: setSelectedEffect.of(move) });
+                      e.preventDefault();
+                  }
+              }
           });
           this.dom.addEventListener("focusout", (e) => {
               let state = view.state.field(this.stateField, false);
@@ -23823,7 +24008,6 @@
   const setActiveEffect = /*@__PURE__*/StateEffect.define({
       map(sources, mapping) { return sources.map(s => s.map(mapping)); }
   });
-  const setSelectedEffect = /*@__PURE__*/StateEffect.define();
   const completionState = /*@__PURE__*/StateField.define({
       create() { return CompletionState.start(); },
       update(value, tr) { return value.update(tr); },
@@ -24978,10 +25162,10 @@
       let field = view.state.field(lintState, false);
       if (!field)
           return false;
-      let sel = view.state.selection.main, next = field.diagnostics.iter(sel.to + 1);
-      if (!next.value) {
-          next = field.diagnostics.iter(0);
-          if (!next.value || next.from == sel.from && next.to == sel.to)
+      let sel = view.state.selection.main, next = findDiagnostic(field.diagnostics, null, sel.to + 1);
+      if (!next) {
+          next = findDiagnostic(field.diagnostics, null, 0);
+          if (!next || next.from == sel.from && next.to == sel.to)
               return false;
       }
       view.dispatch({ selection: { anchor: next.from, head: next.to }, scrollIntoView: true });
@@ -25353,6 +25537,12 @@
               padding: 0,
               margin: 0
           }
+      },
+      "&dark .cm-lintRange-active": { backgroundColor: "#86714a80" },
+      "&dark .cm-panel.cm-panel-lint ul": {
+          "& [aria-selected]": {
+              backgroundColor: "#2e343e",
+          },
       }
   });
   function severityWeight(sev) {
@@ -27725,7 +27915,21 @@
               }),
               /*@__PURE__*/foldNodeProp.add({
                   "Block ClassBody SwitchBody EnumBody ObjectExpression ArrayExpression ObjectType": foldInside,
-                  BlockComment(tree) { return { from: tree.from + 2, to: tree.to - 2 }; }
+                  BlockComment(tree) { return { from: tree.from + 2, to: tree.to - 2 }; },
+                  JSXElement(tree) {
+                      let open = tree.firstChild;
+                      if (!open || open.name == "JSXSelfClosingTag")
+                          return null;
+                      let close = tree.lastChild;
+                      return { from: open.to, to: close.type.isError ? tree.to : close.from };
+                  },
+                  "JSXSelfClosingTag JSXOpenTag"(tree) {
+                      var _a;
+                      let name = (_a = tree.firstChild) === null || _a === void 0 ? void 0 : _a.nextSibling, close = tree.lastChild;
+                      if (!name || name.type.isError)
+                          return null;
+                      return { from: name.to, to: close.type.isError ? tree.to : close.from };
+                  }
               })
           ]
       }),