@ni/spright-components 4.0.1 → 4.0.2

package/dist/all-components-bundle.js

@@ -15,7 +15,7 @@
   OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
   PERFORMANCE OF THIS SOFTWARE.
   ***************************************************************************** */
-  /* global Reflect, Promise, SuppressedError, Symbol */
+  /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
   function __decorate$1(decorators, target, key, desc) {
@@ -54,7 +54,7 @@
   function __asyncGenerator(thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
     function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
     function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
     function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
@@ -29373,7 +29373,7 @@ so this becomes the fallback color for the slot */ ''}
       */
       parse(dom, options = {}) {
           let context = new ParseContext(this, options, false);
-          context.addAll(dom, options.from, options.to);
+          context.addAll(dom, Mark$1.none, options.from, options.to);
           return context.finish();
       }
       /**
@@ -29386,7 +29386,7 @@ so this becomes the fallback color for the slot */ ''}
       */
       parseSlice(dom, options = {}) {
           let context = new ParseContext(this, options, true);
-          context.addAll(dom, options.from, options.to);
+          context.addAll(dom, Mark$1.none, options.from, options.to);
           return Slice.maxOpen(context.finish());
       }
       /**
@@ -29495,22 +29495,15 @@ so this becomes the fallback color for the slot */ ''}
       return type && type.whitespace == "pre" ? OPT_PRESERVE_WS | OPT_PRESERVE_WS_FULL : base & ~OPT_OPEN_LEFT;
   }
   class NodeContext {
-      constructor(type, attrs, 
-      // Marks applied to this node itself
-      marks, 
-      // Marks that can't apply here, but will be used in children if possible
-      pendingMarks, solid, match, options) {
+      constructor(type, attrs, marks, solid, match, options) {
           this.type = type;
           this.attrs = attrs;
           this.marks = marks;
-          this.pendingMarks = pendingMarks;
           this.solid = solid;
           this.options = options;
           this.content = [];
           // Marks applied to the node's children
           this.activeMarks = Mark$1.none;
-          // Nested Marks with same type
-          this.stashMarks = [];
           this.match = match || (options & OPT_OPEN_LEFT ? null : type.contentMatch);
       }
       findWrapping(node) {
@@ -29550,21 +29543,6 @@ so this becomes the fallback color for the slot */ ''}
               content = content.append(this.match.fillBefore(Fragment.empty, true));
           return this.type ? this.type.create(this.attrs, content, this.marks) : content;
       }
-      popFromStashMark(mark) {
-          for (let i = this.stashMarks.length - 1; i >= 0; i--)
-              if (mark.eq(this.stashMarks[i]))
-                  return this.stashMarks.splice(i, 1)[0];
-      }
-      applyPending(nextType) {
-          for (let i = 0, pending = this.pendingMarks; i < pending.length; i++) {
-              let mark = pending[i];
-              if ((this.type ? this.type.allowsMarkType(mark.type) : markMayApply(mark.type, nextType)) &&
-                  !mark.isInSet(this.activeMarks)) {
-                  this.activeMarks = mark.addToSet(this.activeMarks);
-                  this.pendingMarks = mark.removeFromSet(this.pendingMarks);
-              }
-          }
-      }
       inlineContext(node) {
           if (this.type)
               return this.type.inlineContent;
@@ -29586,11 +29564,11 @@ so this becomes the fallback color for the slot */ ''}
           let topNode = options.topNode, topContext;
           let topOptions = wsOptionsFor(null, options.preserveWhitespace, 0) | (isOpen ? OPT_OPEN_LEFT : 0);
           if (topNode)
-              topContext = new NodeContext(topNode.type, topNode.attrs, Mark$1.none, Mark$1.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
+              topContext = new NodeContext(topNode.type, topNode.attrs, Mark$1.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
           else if (isOpen)
-              topContext = new NodeContext(null, null, Mark$1.none, Mark$1.none, true, null, topOptions);
+              topContext = new NodeContext(null, null, Mark$1.none, true, null, topOptions);
           else
-              topContext = new NodeContext(parser.schema.topNodeType, null, Mark$1.none, Mark$1.none, true, null, topOptions);
+              topContext = new NodeContext(parser.schema.topNodeType, null, Mark$1.none, true, null, topOptions);
           this.nodes = [topContext];
           this.find = options.findPositions;
           this.needsBlock = false;
@@ -29601,31 +29579,13 @@ so this becomes the fallback color for the slot */ ''}
       // Add a DOM node to the content. Text is inserted as text node,
       // otherwise, the node is passed to `addElement` or, if it has a
       // `style` attribute, `addElementWithStyles`.
-      addDOM(dom) {
+      addDOM(dom, marks) {
           if (dom.nodeType == 3)
-              this.addTextNode(dom);
+              this.addTextNode(dom, marks);
           else if (dom.nodeType == 1)
-              this.addElement(dom);
-      }
-      withStyleRules(dom, f) {
-          let style = dom.style;
-          if (!style || !style.length)
-              return f();
-          let marks = this.readStyles(dom.style);
-          if (!marks)
-              return; // A style with ignore: true
-          let [addMarks, removeMarks] = marks, top = this.top;
-          for (let i = 0; i < removeMarks.length; i++)
-              this.removePendingMark(removeMarks[i], top);
-          for (let i = 0; i < addMarks.length; i++)
-              this.addPendingMark(addMarks[i]);
-          f();
-          for (let i = 0; i < addMarks.length; i++)
-              this.removePendingMark(addMarks[i], top);
-          for (let i = 0; i < removeMarks.length; i++)
-              this.addPendingMark(removeMarks[i]);
+              this.addElement(dom, marks);
       }
-      addTextNode(dom) {
+      addTextNode(dom, marks) {
           let value = dom.nodeValue;
           let top = this.top;
           if (top.options & OPT_PRESERVE_WS_FULL ||
@@ -29652,7 +29612,7 @@ so this becomes the fallback color for the slot */ ''}
                   value = value.replace(/\r\n?/g, "\n");
               }
               if (value)
-                  this.insertNode(this.parser.schema.text(value));
+                  this.insertNode(this.parser.schema.text(value), marks);
               this.findInText(dom);
           }
           else {
@@ -29661,7 +29621,7 @@ so this becomes the fallback color for the slot */ ''}
       }
       // Try to find a handler for the given tag and use that to parse. If
       // none is found, the element's content nodes are added directly.
-      addElement(dom, matchAfter) {
+      addElement(dom, marks, matchAfter) {
           let name = dom.nodeName.toLowerCase(), ruleID;
           if (listTags.hasOwnProperty(name) && this.parser.normalizeLists)
               normalizeList(dom);
@@ -29669,7 +29629,7 @@ so this becomes the fallback color for the slot */ ''}
               (ruleID = this.parser.matchTag(dom, this, matchAfter));
           if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
               this.findInside(dom);
-              this.ignoreFallback(dom);
+              this.ignoreFallback(dom, marks);
           }
           else if (!rule || rule.skip || rule.closeParent) {
               if (rule && rule.closeParent)
@@ -29687,45 +29647,44 @@ so this becomes the fallback color for the slot */ ''}
                       this.needsBlock = true;
               }
               else if (!dom.firstChild) {
-                  this.leafFallback(dom);
+                  this.leafFallback(dom, marks);
                   return;
               }
-              if (rule && rule.skip)
-                  this.addAll(dom);
-              else
-                  this.withStyleRules(dom, () => this.addAll(dom));
+              let innerMarks = rule && rule.skip ? marks : this.readStyles(dom, marks);
+              if (innerMarks)
+                  this.addAll(dom, innerMarks);
               if (sync)
                   this.sync(top);
               this.needsBlock = oldNeedsBlock;
           }
           else {
-              this.withStyleRules(dom, () => {
-                  this.addElementByRule(dom, rule, rule.consuming === false ? ruleID : undefined);
-              });
+              let innerMarks = this.readStyles(dom, marks);
+              if (innerMarks)
+                  this.addElementByRule(dom, rule, innerMarks, rule.consuming === false ? ruleID : undefined);
           }
       }
       // Called for leaf DOM nodes that would otherwise be ignored
-      leafFallback(dom) {
+      leafFallback(dom, marks) {
           if (dom.nodeName == "BR" && this.top.type && this.top.type.inlineContent)
-              this.addTextNode(dom.ownerDocument.createTextNode("\n"));
+              this.addTextNode(dom.ownerDocument.createTextNode("\n"), marks);
       }
       // Called for ignored nodes
-      ignoreFallback(dom) {
+      ignoreFallback(dom, marks) {
           // Ignored BR nodes should at least create an inline context
           if (dom.nodeName == "BR" && (!this.top.type || !this.top.type.inlineContent))
-              this.findPlace(this.parser.schema.text("-"));
+              this.findPlace(this.parser.schema.text("-"), marks);
       }
       // Run any style parser associated with the node's styles. Either
-      // return an array of marks, or null to indicate some of the styles
-      // had a rule with `ignore` set.
-      readStyles(styles) {
-          let add = Mark$1.none, remove = Mark$1.none;
+      // return an updated array of marks, or null to indicate some of the
+      // styles had a rule with `ignore` set.
+      readStyles(dom, marks) {
+          let styles = dom.style;
           // Because many properties will only show up in 'normalized' form
           // in `style.item` (i.e. text-decoration becomes
           // text-decoration-line, text-decoration-color, etc), we directly
           // query the styles mentioned in our rules instead of iterating
           // over the items.
-          if (styles.length)
+          if (styles && styles.length)
               for (let i = 0; i < this.parser.matchedStyles.length; i++) {
                   let name = this.parser.matchedStyles[i], value = styles.getPropertyValue(name);
                   if (value)
@@ -29735,52 +29694,50 @@ so this becomes the fallback color for the slot */ ''}
                               break;
                           if (rule.ignore)
                               return null;
-                          if (rule.clearMark) {
-                              this.top.pendingMarks.concat(this.top.activeMarks).forEach(m => {
-                                  if (rule.clearMark(m))
-                                      remove = m.addToSet(remove);
-                              });
-                          }
-                          else {
-                              add = this.parser.schema.marks[rule.mark].create(rule.attrs).addToSet(add);
-                          }
+                          if (rule.clearMark)
+                              marks = marks.filter(m => !rule.clearMark(m));
+                          else
+                              marks = marks.concat(this.parser.schema.marks[rule.mark].create(rule.attrs));
                           if (rule.consuming === false)
                               after = rule;
                           else
                               break;
                       }
               }
-          return [add, remove];
+          return marks;
       }
       // Look up a handler for the given node. If none are found, return
       // false. Otherwise, apply it, use its return value to drive the way
       // the node's content is wrapped, and return true.
-      addElementByRule(dom, rule, continueAfter) {
-          let sync, nodeType, mark;
+      addElementByRule(dom, rule, marks, continueAfter) {
+          let sync, nodeType;
           if (rule.node) {
               nodeType = this.parser.schema.nodes[rule.node];
               if (!nodeType.isLeaf) {
-                  sync = this.enter(nodeType, rule.attrs || null, rule.preserveWhitespace);
+                  let inner = this.enter(nodeType, rule.attrs || null, marks, rule.preserveWhitespace);
+                  if (inner) {
+                      sync = true;
+                      marks = inner;
+                  }
               }
-              else if (!this.insertNode(nodeType.create(rule.attrs))) {
-                  this.leafFallback(dom);
+              else if (!this.insertNode(nodeType.create(rule.attrs), marks)) {
+                  this.leafFallback(dom, marks);
               }
           }
           else {
               let markType = this.parser.schema.marks[rule.mark];
-              mark = markType.create(rule.attrs);
-              this.addPendingMark(mark);
+              marks = marks.concat(markType.create(rule.attrs));
           }
           let startIn = this.top;
           if (nodeType && nodeType.isLeaf) {
               this.findInside(dom);
           }
           else if (continueAfter) {
-              this.addElement(dom, continueAfter);
+              this.addElement(dom, marks, continueAfter);
           }
           else if (rule.getContent) {
               this.findInside(dom);
-              rule.getContent(dom, this.parser.schema).forEach(node => this.insertNode(node));
+              rule.getContent(dom, this.parser.schema).forEach(node => this.insertNode(node, marks));
           }
           else {
               let contentDOM = dom;
@@ -29791,28 +29748,26 @@ so this becomes the fallback color for the slot */ ''}
               else if (rule.contentElement)
                   contentDOM = rule.contentElement;
               this.findAround(dom, contentDOM, true);
-              this.addAll(contentDOM);
+              this.addAll(contentDOM, marks);
           }
           if (sync && this.sync(startIn))
               this.open--;
-          if (mark)
-              this.removePendingMark(mark, startIn);
       }
       // Add all child nodes between `startIndex` and `endIndex` (or the
       // whole node, if not given). If `sync` is passed, use it to
       // synchronize after every block element.
-      addAll(parent, startIndex, endIndex) {
+      addAll(parent, marks, startIndex, endIndex) {
           let index = startIndex || 0;
           for (let dom = startIndex ? parent.childNodes[startIndex] : parent.firstChild, end = endIndex == null ? null : parent.childNodes[endIndex]; dom != end; dom = dom.nextSibling, ++index) {
               this.findAtPoint(parent, index);
-              this.addDOM(dom);
+              this.addDOM(dom, marks);
           }
           this.findAtPoint(parent, index);
       }
       // Try to find a way to fit the given node type into the current
       // context. May add intermediate wrappers and/or leave non-solid
       // nodes that we're in.
-      findPlace(node) {
+      findPlace(node, marks) {
           let route, sync;
           for (let depth = this.open; depth >= 0; depth--) {
               let cx = this.nodes[depth];
@@ -29827,53 +29782,61 @@ so this becomes the fallback color for the slot */ ''}
                   break;
           }
           if (!route)
-              return false;
+              return null;
           this.sync(sync);
           for (let i = 0; i < route.length; i++)
-              this.enterInner(route[i], null, false);
-          return true;
+              marks = this.enterInner(route[i], null, marks, false);
+          return marks;
       }
       // Try to insert the given node, adjusting the context when needed.
-      insertNode(node) {
+      insertNode(node, marks) {
           if (node.isInline && this.needsBlock && !this.top.type) {
               let block = this.textblockFromContext();
               if (block)
-                  this.enterInner(block);
+                  marks = this.enterInner(block, null, marks);
           }
-          if (this.findPlace(node)) {
+          let innerMarks = this.findPlace(node, marks);
+          if (innerMarks) {
               this.closeExtra();
               let top = this.top;
-              top.applyPending(node.type);
               if (top.match)
                   top.match = top.match.matchType(node.type);
-              let marks = top.activeMarks;
-              for (let i = 0; i < node.marks.length; i++)
-                  if (!top.type || top.type.allowsMarkType(node.marks[i].type))
-                      marks = node.marks[i].addToSet(marks);
-              top.content.push(node.mark(marks));
+              let nodeMarks = Mark$1.none;
+              for (let m of innerMarks.concat(node.marks))
+                  if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, node.type))
+                      nodeMarks = m.addToSet(nodeMarks);
+              top.content.push(node.mark(nodeMarks));
               return true;
           }
           return false;
       }
       // Try to start a node of the given type, adjusting the context when
       // necessary.
-      enter(type, attrs, preserveWS) {
-          let ok = this.findPlace(type.create(attrs));
-          if (ok)
-              this.enterInner(type, attrs, true, preserveWS);
-          return ok;
+      enter(type, attrs, marks, preserveWS) {
+          let innerMarks = this.findPlace(type.create(attrs), marks);
+          if (innerMarks)
+              innerMarks = this.enterInner(type, attrs, marks, true, preserveWS);
+          return innerMarks;
       }
       // Open a node of the given type
-      enterInner(type, attrs = null, solid = false, preserveWS) {
+      enterInner(type, attrs, marks, solid = false, preserveWS) {
           this.closeExtra();
           let top = this.top;
-          top.applyPending(type);
           top.match = top.match && top.match.matchType(type);
           let options = wsOptionsFor(type, preserveWS, top.options);
           if ((top.options & OPT_OPEN_LEFT) && top.content.length == 0)
               options |= OPT_OPEN_LEFT;
-          this.nodes.push(new NodeContext(type, attrs, top.activeMarks, top.pendingMarks, solid, null, options));
+          let applyMarks = Mark$1.none;
+          marks = marks.filter(m => {
+              if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, type)) {
+                  applyMarks = m.addToSet(applyMarks);
+                  return false;
+              }
+              return true;
+          });
+          this.nodes.push(new NodeContext(type, attrs, applyMarks, solid, null, options));
           this.open++;
+          return marks;
       }
       // Make sure all nodes above this.open are finished and added to
       // their parents
@@ -29987,29 +29950,6 @@ so this becomes the fallback color for the slot */ ''}
                   return type;
           }
       }
-      addPendingMark(mark) {
-          let found = findSameMarkInSet(mark, this.top.pendingMarks);
-          if (found)
-              this.top.stashMarks.push(found);
-          this.top.pendingMarks = mark.addToSet(this.top.pendingMarks);
-      }
-      removePendingMark(mark, upto) {
-          for (let depth = this.open; depth >= 0; depth--) {
-              let level = this.nodes[depth];
-              let found = level.pendingMarks.lastIndexOf(mark);
-              if (found > -1) {
-                  level.pendingMarks = mark.removeFromSet(level.pendingMarks);
-              }
-              else {
-                  level.activeMarks = mark.removeFromSet(level.activeMarks);
-                  let stashMark = level.popFromStashMark(mark);
-                  if (stashMark && level.type && level.type.allowsMarkType(stashMark.type))
-                      level.activeMarks = stashMark.addToSet(level.activeMarks);
-              }
-              if (level == upto)
-                  break;
-          }
-      }
   }
   // Kludge to work around directly nested list nodes produced by some
   // tools and allowed by browsers to mean that the nested list is
@@ -30062,12 +30002,6 @@ so this becomes the fallback color for the slot */ ''}
               return true;
       }
   }
-  function findSameMarkInSet(mark, set) {
-      for (let i = 0; i < set.length; i++) {
-          if (mark.eq(set[i]))
-              return set[i];
-      }
-  }
 
   /**
   A DOM serializer knows how to convert ProseMirror nodes and
@@ -31370,7 +31304,9 @@ so this becomes the fallback color for the slot */ ''}
           throw new RangeError("Type given to setBlockType should be a textblock");
       let mapFrom = tr.steps.length;
       tr.doc.nodesBetween(from, to, (node, pos) => {
-          if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
+          let attrsHere = typeof attrs == "function" ? attrs(node) : attrs;
+          if (node.isTextblock && !node.hasMarkup(type, attrsHere) &&
+              canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
               let convertNewlines = null;
               if (type.schema.linebreakReplacement) {
                   let pre = type.whitespace == "pre", supportLinebreak = !!type.contentMatch.matchType(type.schema.linebreakReplacement);
@@ -31385,7 +31321,7 @@ so this becomes the fallback color for the slot */ ''}
               clearIncompatible(tr, tr.mapping.slice(mapFrom).map(pos, 1), type, undefined, convertNewlines === null);
               let mapping = tr.mapping.slice(mapFrom);
               let startM = mapping.map(pos, 1), endM = mapping.map(pos + node.nodeSize, 1);
-              tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new Slice(Fragment.from(type.create(attrs, null, node.marks)), 0, 0), 1, true));
+              tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new Slice(Fragment.from(type.create(attrsHere, null, node.marks)), 0, 0), 1, true));
               if (convertNewlines === true)
                   replaceNewlines(tr, node, pos, mapFrom);
               return false;
@@ -33535,15 +33471,18 @@ so this becomes the fallback color for the slot */ ''}
       if (doc.caretPositionFromPoint) {
           try { // Firefox throws for this call in hard-to-predict circumstances (#994)
               let pos = doc.caretPositionFromPoint(x, y);
+              // Clip the offset, because Chrome will return a text offset
+              // into <input> nodes, which can't be treated as a regular DOM
+              // offset
               if (pos)
-                  return { node: pos.offsetNode, offset: pos.offset };
+                  return { node: pos.offsetNode, offset: Math.min(nodeSize(pos.offsetNode), pos.offset) };
           }
           catch (_) { }
       }
       if (doc.caretRangeFromPoint) {
           let range = doc.caretRangeFromPoint(x, y);
           if (range)
-              return { node: range.startContainer, offset: range.startOffset };
+              return { node: range.startContainer, offset: Math.min(nodeSize(range.startContainer), range.startOffset) };
       }
   }
 
@@ -34055,6 +33994,8 @@ so this becomes the fallback color for the slot */ ''}
           return false;
       let offset = $head.parentOffset, atStart = !offset, atEnd = offset == $head.parent.content.size;
       let sel = view.domSelection();
+      if (!sel)
+          return $head.pos == $head.start() || $head.pos == $head.end();
       // 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)
@@ -35677,12 +35618,14 @@ so this becomes the fallback color for the slot */ ''}
   }
   function selectCursorWrapper(view) {
       let domSel = view.domSelection(), range = document.createRange();
+      if (!domSel)
+          return;
       let node = view.cursorWrapper.dom, img = node.nodeName == "IMG";
       if (img)
-          range.setEnd(node.parentNode, domIndex(node) + 1);
+          range.setStart(node.parentNode, domIndex(node) + 1);
       else
-          range.setEnd(node, 0);
-      range.collapse(false);
+          range.setStart(node, 0);
+      range.collapse(true);
       domSel.removeAllRanges();
       domSel.addRange(range);
       // Kludge to kill 'control selection' in IE11 when selecting an
@@ -35970,6 +35913,8 @@ so this becomes the fallback color for the slot */ ''}
           }
       }
       let sel = view.domSelection();
+      if (!sel)
+          return;
       if (selectionCollapsed(sel)) {
           let range = document.createRange();
           range.setEnd(node, offset);
@@ -36324,6 +36269,15 @@ so this becomes the fallback color for the slot */ ''}
   function detachedDoc() {
       return _detachedDoc || (_detachedDoc = document.implementation.createHTMLDocument("title"));
   }
+  function maybeWrapTrusted(html) {
+      let trustedTypes = window.trustedTypes;
+      if (!trustedTypes)
+          return html;
+      // With the require-trusted-types-for CSP, Chrome will block
+      // innerHTML, even on a detached document. This wraps the string in
+      // a way that makes the browser allow us to use its parser again.
+      return trustedTypes.createPolicy("detachedDocument", { createHTML: (s) => s }).createHTML(html);
+  }
   function readHTML(html) {
       let metas = /^(\s*<meta [^>]*>)*/.exec(html);
       if (metas)
@@ -36332,7 +36286,7 @@ so this becomes the fallback color for the slot */ ''}
       let firstTag = /<([a-z][^>\s]+)/i.exec(html), wrap;
       if (wrap = firstTag && wrapMap[firstTag[1].toLowerCase()])
           html = wrap.map(n => "<" + n + ">").join("") + html + wrap.map(n => "</" + n + ">").reverse().join("");
-      elt.innerHTML = html;
+      elt.innerHTML = maybeWrapTrusted(html);
       if (wrap)
           for (let i = 0; i < wrap.length; i++)
               elt = elt.querySelector(wrap[i]) || elt;
@@ -36473,7 +36427,9 @@ so this becomes the fallback color for the slot */ ''}
       // and handling them eagerly tends to corrupt the input.
       if (android && chrome && event.keyCode == 13)
           return;
-      if (event.keyCode != 229)
+      if (view.domObserver.selectionChanged(view.domSelectionRange()))
+          view.domObserver.flush();
+      else if (event.keyCode != 229)
           view.domObserver.forceFlush();
       // On iOS, if we preventDefault enter key presses, the virtual
       // keyboard gets confused. So the hack here is to set a flag that
@@ -36536,6 +36492,8 @@ so this becomes the fallback color for the slot */ ''}
   function updateSelection(view, selection, origin) {
       if (!view.focused)
           view.focus();
+      if (view.state.selection.eq(selection))
+          return;
       let tr = view.state.tr.setSelection(selection);
       tr.setMeta("pointer", true);
       view.dispatch(tr);
@@ -36789,8 +36747,8 @@ so this becomes the fallback color for the slot */ ''}
   editHandlers.compositionstart = editHandlers.compositionupdate = view => {
       if (!view.composing) {
           view.domObserver.flush();
-          let { state } = view, $pos = state.selection.$from;
-          if (state.selection.empty &&
+          let { state } = view, $pos = state.selection.$to;
+          if (state.selection instanceof TextSelection &&
               (state.storedMarks ||
                   (!$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some(m => m.type.spec.inclusive === false)))) {
               // Need to wrap the cursor in mark nodes different from the ones in the DOM context
@@ -36799,7 +36757,7 @@ so this becomes the fallback color for the slot */ ''}
               view.markCursor = null;
           }
           else {
-              endComposition(view);
+              endComposition(view, !state.selection.empty);
               // In firefox, if the cursor is after but outside a marked node,
               // the inserted text won't inherit the marks. So this moves it
               // inside if necessary.
@@ -36810,7 +36768,9 @@ so this becomes the fallback color for the slot */ ''}
                       if (!before)
                           break;
                       if (before.nodeType == 3) {
-                          view.domSelection().collapse(before, before.nodeValue.length);
+                          let sel = view.domSelection();
+                          if (sel)
+                              sel.collapse(before, before.nodeValue.length);
                           break;
                       }
                       else {
@@ -36878,15 +36838,17 @@ so this becomes the fallback color for the slot */ ''}
   /**
   @internal
   */
-  function endComposition(view, forceUpdate = false) {
+  function endComposition(view, restarting = false) {
       if (android && view.domObserver.flushingSoon >= 0)
           return;
       view.domObserver.forceFlush();
       clearComposition(view);
-      if (forceUpdate || view.docView && view.docView.dirty) {
+      if (restarting || view.docView && view.docView.dirty) {
           let sel = selectionFromDOM(view);
           if (sel && !sel.eq(view.state.selection))
               view.dispatch(view.state.tr.setSelection(sel));
+          else if ((view.markCursor || restarting) && !view.state.selection.empty)
+              view.dispatch(view.state.tr.deleteSelection());
           else
               view.updateState(view.state);
           return true;
@@ -37543,6 +37505,7 @@ so this becomes the fallback color for the slot */ ''}
           }
           return result;
       }
+      forEachSet(f) { f(this); }
   }
   /**
   The empty set of decorations.
@@ -37618,6 +37581,10 @@ so this becomes the fallback color for the slot */ ''}
                   members.reduce((r, m) => r.concat(m instanceof DecorationSet ? m : m.members), []));
           }
       }
+      forEachSet(f) {
+          for (let i = 0; i < this.members.length; i++)
+              this.members[i].forEachSet(f);
+      }
   }
   function mapChildren(oldChildren, newLocal, mapping, node, offset, oldOffset, options) {
       let children = oldChildren.slice();
@@ -37984,6 +37951,9 @@ so this becomes the fallback color for the slot */ ''}
                   this.queue.push(mut);
           return this.queue;
       }
+      selectionChanged(sel) {
+          return !this.suppressingSelectionUpdates && !this.currentSelection.eq(sel) && hasFocusAndSelection(this.view) && !this.ignoreSelectionChange(sel);
+      }
       flush() {
           let { view } = this;
           if (!view.docView || this.flushingSoon > -1)
@@ -37991,8 +37961,7 @@ so this becomes the fallback color for the slot */ ''}
           let mutations = this.pendingRecords();
           if (mutations.length)
               this.queue = [];
-          let sel = view.domSelectionRange();
-          let newSel = !this.suppressingSelectionUpdates && !this.currentSelection.eq(sel) && hasFocusAndSelection(view) && !this.ignoreSelectionChange(sel);
+          let sel = view.domSelectionRange(), newSel = this.selectionChanged(sel);
           let from = -1, to = -1, typeOver = false, added = [];
           if (view.editable) {
               for (let i = 0; i < mutations.length; i++) {
@@ -38280,6 +38249,8 @@ so this becomes the fallback color for the slot */ ''}
       }
       view.input.lastKeyCode = null;
       let change = findDiff(compare.content, parse.doc.content, parse.from, preferredPos, preferredSide);
+      if (change)
+          view.input.domChangeCount++;
       if ((ios && view.input.lastIOSEnter > Date.now() - 225 || android) &&
           addedNodes.some(n => n.nodeType == 1 && !isInline.test(n.nodeName)) &&
           (!change || change.endA >= change.endB) &&
@@ -38305,7 +38276,6 @@ so this becomes the fallback color for the slot */ ''}
               return;
           }
       }
-      view.input.domChangeCount++;
       // Handle the case where overwriting a selection by typing matches
       // the start or end of the selected content, creating a change
       // that's smaller than what was actually overwritten.
@@ -39028,6 +38998,8 @@ so this becomes the fallback color for the slot */ ''}
       */
       domSelectionRange() {
           let sel = this.domSelection();
+          if (!sel)
+              return { focusNode: null, focusOffset: 0, anchorNode: null, anchorOffset: 0 };
           return safari && this.root.nodeType === 11 &&
               deepActiveElement(this.dom.ownerDocument) == this.dom && safariShadowSelectionRange(this, sel) || sel;
       }
@@ -39065,7 +39037,7 @@ so this becomes the fallback color for the slot */ ''}
           dom.className = "ProseMirror-separator";
           dom.setAttribute("mark-placeholder", "true");
           dom.setAttribute("alt", "");
-          view.cursorWrapper = { dom, deco: Decoration.widget(view.state.selection.head, dom, { raw: true, marks: view.markCursor }) };
+          view.cursorWrapper = { dom, deco: Decoration.widget(view.state.selection.from, dom, { raw: true, marks: view.markCursor }) };
       }
       else {
           view.cursorWrapper = null;
@@ -41000,7 +40972,7 @@ so this becomes the fallback color for the slot */ ''}
 
   function findDuplicates(items) {
       const filtered = items.filter((el, index) => items.indexOf(el) !== index);
-      return [...new Set(filtered)];
+      return Array.from(new Set(filtered));
   }
 
   class ExtensionManager {
@@ -41802,7 +41774,11 @@ so this becomes the fallback color for the slot */ ''}
               if (isArrayContent) {
                   return Fragment.fromArray(content.map(item => schema.nodeFromJSON(item)));
               }
-              return schema.nodeFromJSON(content);
+              const node = schema.nodeFromJSON(content);
+              if (options.errorOnInvalidContent) {
+                  node.check();
+              }
+              return node;
           }
           catch (error) {
               if (options.errorOnInvalidContent) {
@@ -42563,7 +42539,7 @@ so this becomes the fallback color for the slot */ ''}
               .resolve(from)
               .marks()
               .forEach(mark => {
-              const $pos = doc.resolve(from - 1);
+              const $pos = doc.resolve(from);
               const range = getMarkRange($pos, mark.type);
               if (!range) {
                   return;
@@ -42705,31 +42681,40 @@ so this becomes the fallback color for the slot */ ''}
   }
 
   /**
-   * Returns true if the given node is empty.
-   * When `checkChildren` is true (default), it will also check if all children are empty.
+   * Returns true if the given prosemirror node is empty.
    */
-  function isNodeEmpty(node, { checkChildren } = { checkChildren: true }) {
+  function isNodeEmpty(node, { checkChildren = true, ignoreWhitespace = false, } = {}) {
+      var _a;
+      if (ignoreWhitespace) {
+          if (node.type.name === 'hardBreak') {
+              // Hard breaks are considered empty
+              return true;
+          }
+          if (node.isText) {
+              return /^\s*$/m.test((_a = node.text) !== null && _a !== void 0 ? _a : '');
+          }
+      }
       if (node.isText) {
           return !node.text;
       }
+      if (node.isAtom || node.isLeaf) {
+          return false;
+      }
       if (node.content.childCount === 0) {
           return true;
       }
-      if (node.isLeaf) {
-          return false;
-      }
       if (checkChildren) {
-          let hasSameContent = true;
+          let isContentEmpty = true;
           node.content.forEach(childNode => {
-              if (hasSameContent === false) {
+              if (isContentEmpty === false) {
                   // Exit early for perf
                   return;
               }
-              if (!isNodeEmpty(childNode)) {
-                  hasSameContent = false;
+              if (!isNodeEmpty(childNode, { ignoreWhitespace, checkChildren })) {
+                  isContentEmpty = false;
               }
           });
-          return hasSameContent;
+          return isContentEmpty;
       }
       return false;
   }
@@ -42942,7 +42927,7 @@ so this becomes the fallback color for the slot */ ''}
       return can;
   };
 
-  const splitListItem = typeOrName => ({ tr, state, dispatch, editor, }) => {
+  const splitListItem = (typeOrName, overrideAttrs = {}) => ({ tr, state, dispatch, editor, }) => {
       var _a;
       const type = getNodeType(typeOrName, state.schema);
       const { $from, $to } = state.selection;
@@ -42978,7 +42963,10 @@ so this becomes the fallback color for the slot */ ''}
               // eslint-disable-next-line
               const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1 : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
               // Add a second list item with an empty default start node
-              const newNextTypeAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
+              const newNextTypeAttributes = {
+                  ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
+                  ...overrideAttrs,
+              };
               const nextType = ((_a = type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.createAndFill(newNextTypeAttributes)) || undefined;
               wrap = wrap.append(Fragment.from(type.createAndFill(null, nextType) || undefined));
               const start = $from.before($from.depth - (depthBefore - 1));
@@ -43000,8 +42988,14 @@ so this becomes the fallback color for the slot */ ''}
           return true;
       }
       const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
-      const newTypeAttributes = getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs);
-      const newNextTypeAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
+      const newTypeAttributes = {
+          ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
+          ...overrideAttrs,
+      };
+      const newNextTypeAttributes = {
+          ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
+          ...overrideAttrs,
+      };
       tr.delete($from.pos, $to.pos);
       const types = nextType
           ? [
@@ -43727,8 +43721,8 @@ img.ProseMirror-separator {
   display: inline !important;
   border: none !important;
   margin: 0 !important;
-  width: 1px !important;
-  height: 1px !important;
+  width: 0 !important;
+  height: 0 !important;
 }
 
 .ProseMirror-gapcursor {
@@ -43793,6 +43787,10 @@ img.ProseMirror-separator {
       constructor(options = {}) {
           super();
           this.isFocused = false;
+          /**
+           * The editor is considered initialized after the `create` event has been emitted.
+           */
+          this.isInitialized = false;
           this.extensionStorage = {};
           this.options = {
               element: document.createElement('div'),
@@ -43843,6 +43841,7 @@ img.ProseMirror-separator {
               }
               this.commands.focus(this.options.autofocus);
               this.emit('create', { editor: this });
+              this.isInitialized = true;
           }, 0);
       }
       /**
@@ -55328,6 +55327,7 @@ img.ProseMirror-separator {
    */
   const TextStyle$1 = Mark.create({
       name: 'textStyle',
+      priority: 101,
       addOptions() {
           return {
               HTMLAttributes: {},
@@ -58112,10 +58112,20 @@ img.ProseMirror-separator {
   }
   // From DOMPurify
   // https://github.com/cure53/DOMPurify/blob/main/src/regexp.js
-  const ATTR_WHITESPACE = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g; // eslint-disable-line no-control-regex
-  const IS_ALLOWED_URI = /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i; // eslint-disable-line no-useless-escape
-  function isAllowedUri(uri) {
-      return !uri || uri.replace(ATTR_WHITESPACE, '').match(IS_ALLOWED_URI);
+  // eslint-disable-next-line no-control-regex
+  const ATTR_WHITESPACE = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g;
+  function isAllowedUri(uri, protocols) {
+      const allowedProtocols = ['http', 'https', 'ftp', 'ftps', 'mailto', 'tel', 'callto', 'sms', 'cid', 'xmpp'];
+      if (protocols) {
+          protocols.forEach(protocol => {
+              const nextProtocol = (typeof protocol === 'string' ? protocol : protocol.scheme);
+              if (nextProtocol) {
+                  allowedProtocols.push(nextProtocol);
+              }
+          });
+      }
+      // eslint-disable-next-line no-useless-escape
+      return !uri || uri.replace(ATTR_WHITESPACE, '').match(new RegExp(`^(?:(?:${allowedProtocols.join('|')}):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))`, 'i'));
   }
   /**
    * This extension allows you to create links.
@@ -58160,6 +58170,9 @@ img.ProseMirror-separator {
           return {
               href: {
                   default: null,
+                  parseHTML(element) {
+                      return element.getAttribute('href');
+                  },
               },
               target: {
                   default: this.options.HTMLAttributes.target,
@@ -58178,16 +58191,16 @@ img.ProseMirror-separator {
                   getAttrs: dom => {
                       const href = dom.getAttribute('href');
                       // prevent XSS attacks
-                      if (!href || !isAllowedUri(href)) {
+                      if (!href || !isAllowedUri(href, this.options.protocols)) {
                           return false;
                       }
-                      return { href };
+                      return null;
                   },
               }];
       },
       renderHTML({ HTMLAttributes }) {
           // prevent XSS attacks
-          if (!isAllowedUri(HTMLAttributes.href)) {
+          if (!isAllowedUri(HTMLAttributes.href, this.options.protocols)) {
               // strip out the href
               return ['a', mergeAttributes(this.options.HTMLAttributes, { ...HTMLAttributes, href: '' }), 0];
           }
@@ -58370,9 +58383,9 @@ img.ProseMirror-separator {
                       const started = !prev.active && next.active;
                       const stopped = prev.active && !next.active;
                       const changed = !started && !stopped && prev.query !== next.query;
-                      const handleStart = started;
+                      const handleStart = started || (moved && changed);
                       const handleChange = changed || moved;
-                      const handleExit = stopped;
+                      const handleExit = stopped || (moved && changed);
                       // Cancel when suggestion isn't active
                       if (!handleStart && !handleChange && !handleExit) {
                           return;
@@ -58746,6 +58759,7 @@ img.ProseMirror-separator {
    */
   const TextStyle = Mark.create({
       name: 'textStyle',
+      priority: 101,
       addOptions() {
           return {
               HTMLAttributes: {},
@@ -58816,6 +58830,10 @@ img.ProseMirror-separator {
                           : 1;
                   },
               },
+              type: {
+                  default: undefined,
+                  parseHTML: element => element.getAttribute('type'),
+              },
           };
       },
       parseHTML() {
@@ -62053,7 +62071,7 @@ img.ProseMirror-separator {
       ...columnDef
     };
     const accessorKey = resolvedColumnDef.accessorKey;
-    let id = (_ref = (_resolvedColumnDef$id = resolvedColumnDef.id) != null ? _resolvedColumnDef$id : accessorKey ? accessorKey.replace('.', '_') : undefined) != null ? _ref : typeof resolvedColumnDef.header === 'string' ? resolvedColumnDef.header : undefined;
+    let id = (_ref = (_resolvedColumnDef$id = resolvedColumnDef.id) != null ? _resolvedColumnDef$id : accessorKey ? typeof String.prototype.replaceAll === 'function' ? accessorKey.replaceAll('.', '_') : accessorKey.replace(/\./g, '_') : undefined) != null ? _ref : typeof resolvedColumnDef.header === 'string' ? resolvedColumnDef.header : undefined;
     let accessorFn;
     if (resolvedColumnDef.accessorFn) {
       accessorFn = resolvedColumnDef.accessorFn;
@@ -62462,8 +62480,8 @@ img.ProseMirror-separator {
   };
 
   const includesString = (row, columnId, filterValue) => {
-    var _row$getValue;
-    const search = filterValue.toLowerCase();
+    var _filterValue$toString, _row$getValue;
+    const search = filterValue == null || (_filterValue$toString = filterValue.toString()) == null ? void 0 : _filterValue$toString.toLowerCase();
     return Boolean((_row$getValue = row.getValue(columnId)) == null || (_row$getValue = _row$getValue.toString()) == null || (_row$getValue = _row$getValue.toLowerCase()) == null ? void 0 : _row$getValue.includes(search));
   };
   includesString.autoRemove = val => testFalsey(val);
@@ -67247,7 +67265,8 @@ focus outline in that case.
       instance.options.isScrollingResetDelay
     );
     const createHandler = (isScrolling) => () => {
-      offset = element[instance.options.horizontal ? "scrollLeft" : "scrollTop"];
+      const { horizontal, isRtl } = instance.options;
+      offset = horizontal ? element["scrollLeft"] * (isRtl && -1 || 1) : element["scrollTop"];
       fallback();
       cb(offset, isScrolling);
     };
@@ -67358,20 +67377,36 @@ focus outline in that case.
           lanes: 1,
           isScrollingResetDelay: 150,
           enabled: true,
+          isRtl: false,
           ...opts2
         };
       };
-      this.notify = (force, sync) => {
+      this.notify = (sync) => {
         var _a, _b;
-        const { startIndex, endIndex } = this.range ?? {
-          startIndex: void 0,
-          endIndex: void 0
-        };
-        const range = this.calculateRange();
-        if (force || startIndex !== (range == null ? void 0 : range.startIndex) || endIndex !== (range == null ? void 0 : range.endIndex)) {
-          (_b = (_a = this.options).onChange) == null ? void 0 : _b.call(_a, this, sync);
-        }
+        (_b = (_a = this.options).onChange) == null ? void 0 : _b.call(_a, this, sync);
       };
+      this.maybeNotify = memo(
+        () => {
+          this.calculateRange();
+          return [
+            this.isScrolling,
+            this.range ? this.range.startIndex : null,
+            this.range ? this.range.endIndex : null
+          ];
+        },
+        (isScrolling) => {
+          this.notify(isScrolling);
+        },
+        {
+          key: "maybeNotify",
+          debug: () => this.options.debug,
+          initialDeps: [
+            this.isScrolling,
+            this.range ? this.range.startIndex : null,
+            this.range ? this.range.endIndex : null
+          ]
+        }
+      );
       this.cleanup = () => {
         this.unsubs.filter(Boolean).forEach((d) => d());
         this.unsubs = [];
@@ -67391,7 +67426,7 @@ focus outline in that case.
         if (this.scrollElement !== scrollElement) {
           this.cleanup();
           if (!scrollElement) {
-            this.notify(false, false);
+            this.maybeNotify();
             return;
           }
           this.scrollElement = scrollElement;
@@ -67407,7 +67442,7 @@ focus outline in that case.
           this.unsubs.push(
             this.options.observeElementRect(this, (rect) => {
               this.scrollRect = rect;
-              this.notify(false, false);
+              this.maybeNotify();
             })
           );
           this.unsubs.push(
@@ -67415,9 +67450,8 @@ focus outline in that case.
               this.scrollAdjustments = 0;
               this.scrollDirection = isScrolling ? this.getScrollOffset() < offset ? "forward" : "backward" : null;
               this.scrollOffset = offset;
-              const prevIsScrolling = this.isScrolling;
               this.isScrolling = isScrolling;
-              this.notify(prevIsScrolling !== isScrolling, isScrolling);
+              this.maybeNotify();
             })
           );
         }
@@ -67490,7 +67524,6 @@ focus outline in that case.
       this.getMeasurements = memo(
         () => [this.getMeasurementOptions(), this.itemSizeCache],
         ({ count, paddingStart, scrollMargin, getItemKey, enabled }, itemSizeCache) => {
-          var _a;
           if (!enabled) {
             this.measurementsCache = [];
             this.itemSizeCache.clear();
@@ -67506,33 +67539,6 @@ focus outline in that case.
           this.pendingMeasuredCacheIndexes = [];
           const measurements = this.measurementsCache.slice(0, min);
           for (let i = min; i < count; i++) {
-            let measureElement2 = (_a = this.measurementsCache[i]) == null ? void 0 : _a.measureElement;
-            if (!measureElement2) {
-              measureElement2 = (node) => {
-                const key2 = getItemKey(i);
-                const prevNode = this.elementsCache.get(key2);
-                if (!node) {
-                  if (prevNode) {
-                    this.observer.unobserve(prevNode);
-                    this.elementsCache.delete(key2);
-                  }
-                  return;
-                }
-                if (prevNode !== node) {
-                  if (prevNode) {
-                    this.observer.unobserve(prevNode);
-                  }
-                  this.observer.observe(node);
-                  this.elementsCache.set(key2, node);
-                }
-                if (node.isConnected) {
-                  this.resizeItem(
-                    i,
-                    this.options.measureElement(node, void 0, this)
-                  );
-                }
-              };
-            }
             const key = getItemKey(i);
             const furthestMeasurement = this.options.lanes === 1 ? measurements[i - 1] : this.getFurthestMeasurement(measurements, i);
             const start = furthestMeasurement ? furthestMeasurement.end + this.options.gap : paddingStart + scrollMargin;
@@ -67546,8 +67552,7 @@ focus outline in that case.
               size,
               end,
               key,
-              lane,
-              measureElement: measureElement2
+              lane
             };
           }
           this.measurementsCache = measurements;
@@ -67604,29 +67609,26 @@ focus outline in that case.
         return parseInt(indexStr, 10);
       };
       this._measureElement = (node, entry) => {
-        const i = this.indexFromElement(node);
-        const item = this.getMeasurements()[i];
-        if (!item || !node.isConnected) {
-          this.elementsCache.forEach((cached, key) => {
-            if (cached === node) {
-              this.observer.unobserve(node);
-              this.elementsCache.delete(key);
-            }
-          });
+        const index = this.indexFromElement(node);
+        const item = this.measurementsCache[index];
+        if (!item) {
           return;
         }
-        const prevNode = this.elementsCache.get(item.key);
+        const key = item.key;
+        const prevNode = this.elementsCache.get(key);
         if (prevNode !== node) {
           if (prevNode) {
             this.observer.unobserve(prevNode);
           }
           this.observer.observe(node);
-          this.elementsCache.set(item.key, node);
+          this.elementsCache.set(key, node);
+        }
+        if (node.isConnected) {
+          this.resizeItem(index, this.options.measureElement(node, entry, this));
         }
-        this.resizeItem(i, this.options.measureElement(node, entry, this));
       };
       this.resizeItem = (index, size) => {
-        const item = this.getMeasurements()[index];
+        const item = this.measurementsCache[index];
         if (!item) {
           return;
         }
@@ -67644,11 +67646,17 @@ focus outline in that case.
           }
           this.pendingMeasuredCacheIndexes.push(item.index);
           this.itemSizeCache = new Map(this.itemSizeCache.set(item.key, size));
-          this.notify(true, false);
+          this.notify(false);
         }
       };
       this.measureElement = (node) => {
         if (!node) {
+          this.elementsCache.forEach((cached, key) => {
+            if (!cached.isConnected) {
+              this.observer.unobserve(cached);
+              this.elementsCache.delete(key);
+            }
+          });
           return;
         }
         this._measureElement(node, void 0);
@@ -67665,7 +67673,7 @@ focus outline in that case.
           return virtualItems;
         },
         {
-          key: "getIndexes",
+          key: "getVirtualItems",
           debug: () => this.options.debug
         }
       );
@@ -67709,7 +67717,7 @@ focus outline in that case.
       };
       this.getOffsetForIndex = (index, align = "auto") => {
         index = Math.max(0, Math.min(index, this.options.count - 1));
-        const item = this.getMeasurements()[index];
+        const item = this.measurementsCache[index];
         if (!item) {
           return void 0;
         }
@@ -67809,9 +67817,8 @@ focus outline in that case.
         this.options.scrollToFn(offset, { behavior, adjustments }, this);
       };
       this.measure = () => {
-        var _a, _b;
         this.itemSizeCache = /* @__PURE__ */ new Map();
-        (_b = (_a = this.options).onChange) == null ? void 0 : _b.call(_a, this, false);
+        this.notify(false);
       };
       this.setOptions(opts);
     }