datafolder 1.0.14 → 1.0.16

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

@@ -6596,6 +6596,7 @@
               this.cache.reused.set(oldTile, 2 /* Reused.DOM */);
           let text = new TextTile(composition.text, composition.text.nodeValue);
           text.flags |= 8 /* TileFlag.Composition */;
+          this.pos = composition.range.toB;
           head.append(text);
       }
       addInlineWidget(widget, marks, openStart) {
@@ -8120,7 +8121,7 @@
       // (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) {
+      scan(positions, getRects, recursed = false) {
           let lo = 0, hi = positions.length - 1, seen = new Set();
           let bidi = this.bidiIn(positions[0], positions[hi]);
           let above, below;
@@ -8193,18 +8194,19 @@
           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);
+              return this.scan(positions, getRects, true);
           }
           // Handle the case where closest matched a higher element on the
           // same line as an element below/above the coords
-          if (closestDx) {
-              if (above && above.bottom > closestRect.top) {
+          if (closestDx && !recursed) {
+              let { top, bottom } = closestRect;
+              if (above && above.bottom > (top + top + bottom) / 3) {
                   this.y = above.bottom - 1;
-                  return this.scan(positions, getRects);
+                  return this.scan(positions, getRects, true);
               }
-              if (below && below.top < closestRect.bottom) {
+              if (below && below.top < (top + bottom + bottom) / 3) {
                   this.y = below.top + 1;
-                  return this.scan(positions, getRects);
+                  return this.scan(positions, getRects, true);
               }
           }
           let ltr = (bidi ? this.dirAt(positions[closestI], 1) : this.baseDir) == Direction.LTR;
@@ -9498,7 +9500,7 @@
       view.inputState.compositionFirstChange = null;
       if (browser.chrome && browser.android) {
           // Delay flushing for a bit on Android because it'll often fire a
-          // bunch of contradictory changes in a row at end of compositon
+          // bunch of contradictory changes in a row at end of composition
           view.observer.flushSoon();
       }
       else if (view.inputState.compositionPendingChange) {
@@ -9573,8 +9575,8 @@
   const appliedFirefoxHack = /*@__PURE__*/new Set;
   // In Firefox, when cut/copy handlers are added to the document, that
   // somehow avoids a bug where those events aren't fired when the
-  // selection is empty. See https://github.com/codemirror/dev/issues/1082
-  // and https://bugzilla.mozilla.org/show_bug.cgi?id=995961
+  // selection is empty. See issue #1082 and
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=995961
   function firefoxCopyCutHack(doc) {
       if (!appliedFirefoxHack.has(doc)) {
           appliedFirefoxHack.add(doc);
@@ -9629,8 +9631,7 @@
       }
       refresh(whiteSpace, lineHeight, charWidth, textHeight, lineLength, knownHeights) {
           let lineWrapping = wrappingWhiteSpace.indexOf(whiteSpace) > -1;
-          let changed = Math.abs(lineHeight - this.lineHeight) > 0.3 || this.lineWrapping != lineWrapping ||
-              Math.abs(charWidth - this.charWidth) > 0.1;
+          let changed = Math.abs(lineHeight - this.lineHeight) > 0.3 || this.lineWrapping != lineWrapping;
           this.lineWrapping = lineWrapping;
           this.lineHeight = lineHeight;
           this.charWidth = charWidth;
@@ -11060,7 +11061,7 @@
           flexShrink: 0,
           display: "block",
           whiteSpace: "pre",
-          wordWrap: "normal", // https://github.com/codemirror/dev/issues/456
+          wordWrap: "normal", // Issue #456
           boxSizing: "border-box",
           minHeight: "100%",
           padding: "4px 0",
@@ -11479,7 +11480,7 @@
       readSelectionRange() {
           let { view } = this;
           // The Selection object is broken in shadow roots in Safari. See
-          // https://github.com/codemirror/dev/issues/414
+          // issue #414
           let selection = getSelection(view.root);
           if (!selection)
               return false;
@@ -12948,7 +12949,7 @@
       }
       /**
       Create a theme extension. The first argument can be a
-      [`style-mod`](https://github.com/marijnh/style-mod#documentation)
+      [`style-mod`](https://code.haverbeke.berlin/marijn/style-mod#documentation)
       style spec providing the styles for the theme. These will be
       prefixed with a generated class for the style.
       
@@ -12994,7 +12995,7 @@
   }
   /**
   Facet to add a [style
-  module](https://github.com/marijnh/style-mod#documentation) to
+  module](https://code.haverbeke.berlin/marijn/style-mod#documentation) to
   an editor view. The view will ensure that the module is
   mounted in its [document
   root](https://codemirror.net/6/docs/ref/#view.EditorView.constructor^config.root).
@@ -14832,11 +14833,13 @@
           arrow: tooltips.some(t => t.arrow),
       };
   });
+  const hoverPlugin = /*@__PURE__*/Facet.define();
   class HoverPlugin {
-      constructor(view, source, field, setHover, hoverTime) {
+      constructor(view, source, field, locked, setHover, hoverTime) {
           this.view = view;
           this.source = source;
           this.field = field;
+          this.locked = locked;
           this.setHover = setHover;
           this.hoverTime = hoverTime;
           this.hoverTimeout = -1;
@@ -14847,7 +14850,7 @@
           view.dom.addEventListener("mouseleave", this.mouseleave = this.mouseleave.bind(this));
           view.dom.addEventListener("mousemove", this.mousemove = this.mousemove.bind(this));
       }
-      update() {
+      update(update) {
           if (this.pending) {
               this.pending = null;
               clearTimeout(this.restartTimeout);
@@ -14891,19 +14894,29 @@
               let rtl = bidi && bidi.dir == Direction.RTL ? -1 : 1;
               side = (lastMove.x < posCoords.left ? -rtl : rtl);
           }
+          this.activateHover(view, pos, side);
+      }
+      activateHover(view, pos, side, locked) {
           let open = this.source(view, pos, side);
-          if (open === null || open === void 0 ? void 0 : open.then) {
+          let done = (value) => {
+              if (value && !(Array.isArray(value) && !value.length)) {
+                  let tooltips = Array.isArray(value) ? value : [value];
+                  if (locked)
+                      this.locked.set(tooltips, locked);
+                  view.dispatch({ effects: this.setHover.of(tooltips) });
+              }
+          };
+          if (open && "then" in open) {
               let pending = this.pending = { pos };
               open.then(result => {
                   if (this.pending == pending) {
                       this.pending = null;
-                      if (result && !(Array.isArray(result) && !result.length))
-                          view.dispatch({ effects: this.setHover.of(Array.isArray(result) ? result : [result]) });
+                      done(result);
                   }
               }, e => logException(view.state, e, "hover tooltip"));
           }
-          else if (open && !(Array.isArray(open) && !open.length)) {
-              view.dispatch({ effects: this.setHover.of(Array.isArray(open) ? open : [open]) });
+          else {
+              done(open);
           }
       }
       get tooltip() {
@@ -14917,7 +14930,7 @@
           if (this.hoverTimeout < 0)
               this.hoverTimeout = setTimeout(this.checkHover, this.hoverTime);
           let { active, tooltip } = this;
-          if (active.length && tooltip && !isInTooltip(tooltip.dom, event) || this.pending) {
+          if (active.length && !this.locked.has(active) && tooltip && !isInTooltip(tooltip.dom, event) || this.pending) {
               let { pos } = active[0] || this.pending, end = (_b = (_a = active[0]) === null || _a === void 0 ? void 0 : _a.end) !== null && _b !== void 0 ? _b : pos;
               if ((pos == end ? this.view.posAtCoords(this.lastMove) != pos
                   : !isOverRange(this.view, pos, end, event.clientX, event.clientY))) {
@@ -14930,7 +14943,7 @@
           clearTimeout(this.hoverTimeout);
           this.hoverTimeout = -1;
           let { active } = this;
-          if (active.length) {
+          if (active.length && !this.locked.has(active)) {
               let { tooltip } = this;
               let inTooltip = tooltip && tooltip.dom.contains(event.relatedTarget);
               if (!inTooltip)
@@ -14942,7 +14955,8 @@
       watchTooltipLeave(tooltip) {
           let watch = (event) => {
               tooltip.removeEventListener("mouseleave", watch);
-              if (this.active.length && !this.view.dom.contains(event.relatedTarget))
+              let { active } = this;
+              if (active.length && !this.locked.has(active) && !this.view.dom.contains(event.relatedTarget))
                   this.view.dispatch({ effects: this.setHover.of([]) });
           };
           tooltip.addEventListener("mouseleave", watch);
@@ -14993,49 +15007,85 @@
   */
   function hoverTooltip(source, options = {}) {
       let setHover = StateEffect.define();
+      // This would be better stored in the state field, but we've set
+      // down the type of the field in our interface, so it's indirectly
+      // stored by array identity.
+      let locked = new WeakMap();
       let hoverState = StateField.define({
           create() { return []; },
           update(value, tr) {
+              let lock = locked.get(value);
               if (value.length) {
                   if (options.hideOnChange && (tr.docChanged || tr.selection))
                       value = [];
+                  else if (lock && lock(tr))
+                      value = [];
                   else if (options.hideOn)
                       value = value.filter(v => !options.hideOn(tr, v));
-                  if (tr.docChanged) {
-                      let mapped = [];
-                      for (let tooltip of value) {
-                          let newPos = tr.changes.mapPos(tooltip.pos, -1, MapMode.TrackDel);
-                          if (newPos != null) {
-                              let copy = Object.assign(Object.create(null), tooltip);
-                              copy.pos = newPos;
-                              if (copy.end != null)
-                                  copy.end = tr.changes.mapPos(copy.end);
-                              mapped.push(copy);
-                          }
+              }
+              if (tr.docChanged && value.length) {
+                  let mapped = [];
+                  for (let tooltip of value) {
+                      let newPos = tr.changes.mapPos(tooltip.pos, -1, MapMode.TrackDel);
+                      if (newPos != null) {
+                          let copy = Object.assign(Object.create(null), tooltip);
+                          copy.pos = newPos;
+                          if (copy.end != null)
+                              copy.end = tr.changes.mapPos(copy.end);
+                          mapped.push(copy);
                       }
-                      value = mapped;
                   }
+                  value = mapped;
               }
               for (let effect of tr.effects) {
-                  if (effect.is(setHover))
+                  if (effect.is(setHover)) {
                       value = effect.value;
-                  if (effect.is(closeHoverTooltipEffect))
+                      lock = undefined;
+                  }
+                  if (effect.is(closeHoverTooltipEffect) && !effect.value || effect.value == hoverState)
                       value = [];
               }
+              if (value.length && lock)
+                  locked.set(value, lock);
               return value;
           },
           provide: f => showHoverTooltip.from(f)
       });
+      const plugin = ViewPlugin.define(view => new HoverPlugin(view, source, hoverState, locked, setHover, options.hoverTime || 300 /* Hover.Time */));
       return {
           active: hoverState,
           extension: [
               hoverState,
-              ViewPlugin.define(view => new HoverPlugin(view, source, hoverState, setHover, options.hoverTime || 300 /* Hover.Time */)),
+              plugin,
+              hoverPlugin.of(plugin),
               showHoverTooltipHost
           ]
       };
   }
   /**
+  Activate hover tooltips for the given position and side. If you
+  provide a specific hover tooltip (the value returned from
+  [`hoverTooltip`](https://codemirror.net/6/docs/ref/#view.hoverTooltip)), only that one will be
+  activated. If not given, all hover tooltips at the given position
+  are triggered.
+
+  Note that tooltips opened this way don't close automatically, and
+  you'll want to pass an `until` callback or use
+  [`closeHoverTooltip`](https://codemirror.net/6/docs/ref/#view.closeHoverTooltip)/[`closeHoverTooltips`](https://codemirror.net/6/docs/ref/#view.closeHoverTooltips)
+  to deactivate them.
+  */
+  function activateHover(view, pos, side, options = {}) {
+      var _a;
+      let plugins = view.state.facet(hoverPlugin).map(p => view.plugin(p)).filter((p) => !!p);
+      if (options.tooltip && options.tooltip.active) {
+          let found = plugins.find(p => p.field == options.tooltip.active);
+          if (found)
+              plugins = [found];
+      }
+      for (let plugin of plugins)
+          plugin.activateHover(view, pos, side, (_a = options.until) !== null && _a !== void 0 ? _a : (() => false));
+  }
+  /**
   Get the active tooltip view for a given tooltip, if available.
   */
   function getTooltip(view, tooltip) {
@@ -21869,8 +21919,13 @@
           The current match (only holds a meaningful value after
           [`next`](https://codemirror.net/6/docs/ref/#search.SearchCursor.next) has been called and when
           `done` is false).
+          
+          The `precise` flag will be set to false if the match starts or
+          ends _inside_ a character that, when normalized, expands to
+          multiple characters. It indicates that the `from`-`to` range
+          covers content that isn't part of the actual match.
           */
-          this.value = { from: 0, to: 0 };
+          this.value = { from: 0, to: 0, precise: false };
           /**
           Whether the end of the iterated region has been reached.
           */
@@ -21921,44 +21976,45 @@
               this.bufferPos += codePointSize(next);
               let norm = this.normalize(str);
               if (norm.length)
-                  for (let i = 0, pos = start;; i++) {
+                  for (let i = 0, pos = start, posPrecise = true;; i++) {
                       let code = norm.charCodeAt(i);
-                      let match = this.match(code, pos, this.bufferPos + this.bufferStart);
-                      if (i == norm.length - 1) {
-                          if (match) {
-                              this.value = match;
-                              return this;
-                          }
-                          break;
+                      let match = this.match(code, pos, posPrecise, this.bufferPos + this.bufferStart, i == norm.length - 1);
+                      if (match) {
+                          this.value = match;
+                          return this;
                       }
-                      if (pos == start && i < str.length && str.charCodeAt(i) == code)
+                      if (i == norm.length - 1)
+                          break;
+                      if (posPrecise && i < str.length && str.charCodeAt(i) == code)
                           pos++;
+                      else
+                          posPrecise = false;
                   }
           }
       }
-      match(code, pos, end) {
+      match(code, pos, posPrecise, end, endPrecise) {
           let match = null;
-          for (let i = 0; i < this.matches.length; i += 2) {
-              let index = this.matches[i], keep = false;
-              if (this.query.charCodeAt(index) == code) {
-                  if (index == this.query.length - 1) {
-                      match = { from: this.matches[i + 1], to: end };
+          for (let i = 0; i < this.matches.length;) {
+              let partial = this.matches[i], keep = false;
+              if (this.query.charCodeAt(partial.index) == code) {
+                  if (partial.index == this.query.length - 1) {
+                      match = { from: partial.from, to: end, precise: endPrecise && partial.precise };
                   }
                   else {
-                      this.matches[i]++;
+                      partial.index++;
                       keep = true;
                   }
               }
-              if (!keep) {
-                  this.matches.splice(i, 2);
-                  i -= 2;
-              }
+              if (keep)
+                  i++;
+              else
+                  this.matches.splice(i, 1);
           }
           if (this.query.charCodeAt(0) == code) {
               if (this.query.length == 1)
-                  match = { from: pos, to: end };
+                  match = { from: pos, to: end, precise: posPrecise && endPrecise };
               else
-                  this.matches.push(1, pos);
+                  this.matches.push({ from: pos, index: 1, precise: posPrecise });
           }
           if (match && this.test && !this.test(match.from, match.to, this.buffer, this.bufferStart))
               match = null;
@@ -21968,7 +22024,7 @@
   if (typeof Symbol != "undefined")
       SearchCursor.prototype[Symbol.iterator] = function () { return this; };
 
-  const empty = { from: -1, to: -1, match: /*@__PURE__*//.*/.exec("") };
+  const empty = { from: -1, to: -1, match: /*@__PURE__*//.*/.exec(""), precise: true };
   const baseFlags = "gm" + (/x/.unicode == null ? "" : "u");
   /**
   This class is similar to [`SearchCursor`](https://codemirror.net/6/docs/ref/#search.SearchCursor)
@@ -21993,7 +22049,9 @@
           /**
           Will contain an object with the extent of the match and the
           match object when [`next`](https://codemirror.net/6/docs/ref/#search.RegExpCursor.next)
-          sucessfully finds a match.
+          sucessfully finds a match. The `precise` flag is always true for
+          this type of cursor, and only there to make sure this cursor is
+          a subtype of `SearchCursor`.
           */
           this.value = empty;
           if (/\\[sWDnr]|\n|\r|\[\^/.test(query))
@@ -22038,7 +22096,7 @@
                   if (from == this.curLineStart + this.curLine.length)
                       this.nextLine();
                   if ((from < to || from > this.value.to) && (!this.test || this.test(from, to, match))) {
-                      this.value = { from, to, match };
+                      this.value = { from, to, precise: true, match };
                       return this;
                   }
                   off = this.matchPos - this.curLineStart;
@@ -22111,7 +22169,7 @@
                   // again, since it'll likely be able to match more
                   if ((this.flat.to >= this.to || match.index + match[0].length <= this.flat.text.length - 10) &&
                       (!this.test || this.test(from, to, match))) {
-                      this.value = { from, to, match };
+                      this.value = { from, to, precise: true, match };
                       this.matchPos = toCharEnd(this.text, to + (from == to ? 1 : 0));
                       return this;
                   }
@@ -22730,10 +22788,12 @@
       let next = match;
       let changes = [], selection, replacement;
       let effects = [];
-      if (next.from == from && next.to == to) {
+      if (!next.precise) {
+          next = query.nextMatch(state, next.from, next.to);
+      }
+      else if (next.from == from && next.to == to) {
           replacement = state.toText(query.getReplacement(next));
           changes.push({ from: next.from, to: next.to, insert: replacement });
-          next = query.nextMatch(state, next.from, next.to);
           effects.push(EditorView.announce.of(state.phrase("replaced match on line $", state.doc.lineAt(from).number) + "."));
       }
       let changeSet = view.state.changes(changes);
@@ -22757,10 +22817,12 @@
   const replaceAll = /*@__PURE__*/searchCommand((view, { query }) => {
       if (view.state.readOnly)
           return false;
-      let changes = query.matchAll(view.state, 1e9).map(match => {
-          let { from, to } = match;
-          return { from, to, insert: query.getReplacement(match) };
-      });
+      let changes = [];
+      for (let match of query.matchAll(view.state, 1e9)) {
+          let { from, to, precise } = match;
+          if (precise)
+              changes.push({ from, to, insert: query.getReplacement(match) });
+      }
       if (!changes.length)
           return false;
       let announceText = view.state.phrase("replaced $ matches", changes.length) + ".";
@@ -23508,8 +23570,8 @@
           let off = Math.floor(selected / max);
           return { from: off * max, to: (off + 1) * max };
       }
-      let off = Math.floor((total - selected) / max);
-      return { from: total - (off + 1) * max, to: total - off * max };
+      let off = Math.ceil((total - selected) / max);
+      return { from: total - off * max, to: total - (off - 1) * max };
   }
   class CompletionTooltip {
       constructor(view, stateField, applyCompletion) {
@@ -24368,7 +24430,8 @@
           content: '"···"',
           opacity: 0.5,
           display: "block",
-          textAlign: "center"
+          textAlign: "center",
+          cursor: "pointer",
       },
       ".cm-tooltip.cm-completionInfo": {
           position: "absolute",
@@ -25216,6 +25279,10 @@
               return false;
       }
       view.dispatch({ selection: { anchor: next.from, head: next.to }, scrollIntoView: true });
+      activateHover(view, next.from, 1, {
+          tooltip: lintHover,
+          until: tr => tr.docChanged || tr.newSelection.main.head < next.from || tr.newSelection.main.head > next.to
+      });
       return true;
   };
   /**
@@ -25525,7 +25592,7 @@
           backgroundRepeat: "repeat-x",
           paddingBottom: "0.7px",
       },
-      ".cm-lintRange-error": { backgroundImage: /*@__PURE__*/underline("#d11") },
+      ".cm-lintRange-error": { backgroundImage: /*@__PURE__*/underline("#f11") },
       ".cm-lintRange-warning": { backgroundImage: /*@__PURE__*/underline("orange") },
       ".cm-lintRange-info": { backgroundImage: /*@__PURE__*/underline("#999") },
       ".cm-lintRange-hint": { backgroundImage: /*@__PURE__*/underline("#66d") },
@@ -25606,6 +25673,7 @@
       }
       return sev;
   }
+  const lintHover = /*@__PURE__*/hoverTooltip(lintTooltip, { hideOn: hideTooltip });
   const lintExtensions = [
       lintState,
       /*@__PURE__*/EditorView.decorations.compute([lintState], state => {
@@ -25614,7 +25682,7 @@
               activeMark.range(selected.from, selected.to)
           ]);
       }),
-      /*@__PURE__*/hoverTooltip(lintTooltip, { hideOn: hideTooltip }),
+      lintHover,
       baseTheme
   ];
 
@@ -25874,16 +25942,12 @@
           if (term == 0 /* Term.Err */ &&
               (!this.stack.length || this.stack[this.stack.length - 1] < this.buffer.length + this.bufferBase)) {
               // Try to omit/merge adjacent error nodes
-              let cur = this, top = this.buffer.length;
-              if (top == 0 && cur.parent) {
-                  top = cur.bufferBase - cur.parent.bufferBase;
-                  cur = cur.parent;
-              }
-              if (top > 0 && cur.buffer[top - 4] == 0 /* Term.Err */ && cur.buffer[top - 1] > -1) {
+              let top = this.buffer.length;
+              if (top > 0 && this.buffer[top - 4] == 0 /* Term.Err */ && this.buffer[top - 1] > -1) {
                   if (start == end)
                       return;
-                  if (cur.buffer[top - 2] >= start) {
-                      cur.buffer[top - 2] = end;
+                  if (this.buffer[top - 2] >= start) {
+                      this.buffer[top - 2] = end;
                       return;
                   }
               }
@@ -25982,6 +26046,10 @@
       split() {
           let parent = this;
           let off = parent.buffer.length;
+          // Leave off top error node, if there, because that might be
+          // merged with other nodes.
+          if (off && parent.buffer[off - 4] == 0 /* Term.Err */)
+              off -= 4;
           // Because the top of the buffer (after this.pos) may be mutated
           // to reorder reductions and skipped tokens, and shared buffers
           // should be immutable, this copies any outstanding skipped tokens