@ni/ok-components 1.12.3 → 1.12.4

package/dist/all-components-bundle.js

@@ -10160,7 +10160,7 @@
   }
 
   /*!
-  * tabbable 6.5.0
+  * tabbable 6.5.1
   * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
   */
   // NOTE: separate `:not()` selectors has broader browser support than the newer
@@ -10169,10 +10169,9 @@
   var NoElement = typeof Element === 'undefined';
   var matches$1 = NoElement ? function () {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
   var getRootNode = !NoElement && Element.prototype.getRootNode ? function (element) {
-    var _element$getRootNode;
-    return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);
+    return element == null || element.getRootNode == null ? void 0 : element.getRootNode();
   } : function (element) {
-    return element === null || element === void 0 ? void 0 : element.ownerDocument;
+    return element == null ? void 0 : element.ownerDocument;
   };
   var isInput = function isInput(node) {
     return node.tagName === 'INPUT';
@@ -10214,22 +10213,22 @@
     //  from the DOM as in https://github.com/focus-trap/focus-trap-react/issues/905), then
     //  `ownerDocument` will be `null`, hence the optional chaining on it.
     var nodeRoot = node && getRootNode(node);
-    var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
+    var nodeRootHost = (_nodeRoot = nodeRoot) == null ? void 0 : _nodeRoot.host;
 
     // in some cases, a detached node will return itself as the root instead of a document or
     //  shadow root object, in which case, we shouldn't try to look further up the host chain
     var attached = false;
     if (nodeRoot && nodeRoot !== node) {
-      var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;
-      attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));
+      var _nodeRootHost, _node$ownerDocument;
+      attached = !!((_nodeRootHost = nodeRootHost) != null && (_nodeRootHost = _nodeRootHost.ownerDocument) != null && _nodeRootHost.contains(nodeRootHost) || node != null && (_node$ownerDocument = node.ownerDocument) != null && _node$ownerDocument.contains(node));
       while (!attached && nodeRootHost) {
-        var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;
+        var _nodeRoot2, _nodeRootHost2;
         // since it's not attached and we have a root host, the node MUST be in a nested shadow DOM,
         //  which means we need to get the host's host and check if that parent host is contained
         //  in (i.e. attached to) the document
         nodeRoot = getRootNode(nodeRootHost);
-        nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;
-        attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));
+        nodeRootHost = (_nodeRoot2 = nodeRoot) == null ? void 0 : _nodeRoot2.host;
+        attached = !!((_nodeRootHost2 = nodeRootHost) != null && (_nodeRootHost2 = _nodeRootHost2.ownerDocument) != null && _nodeRootHost2.contains(nodeRootHost));
       }
     }
     return attached;
@@ -22771,8 +22770,8 @@ so this becomes the fallback color for the slot */ ''}
     </template>
 `;
 
-  // Based on: https://github.com/microsoft/fast/blob/%40microsoft/fast-foundation_v2.49.5/packages/web-components/fast-foundation/src/combobox/combobox.form-associated.ts
   /* eslint-disable max-classes-per-file */
+  // Based on: https://github.com/microsoft/fast/blob/%40microsoft/fast-foundation_v2.49.5/packages/web-components/fast-foundation/src/combobox/combobox.form-associated.ts
   // eslint-disable-next-line jsdoc/require-jsdoc
   let Combobox$1 = class Combobox extends ListboxElement {
   };
@@ -33305,14 +33304,27 @@ so this becomes the fallback color for the slot */ ''}
           }, parent), oldSlice.openStart, oldSlice.openEnd);
           return StepResult.fromReplace(doc, this.from, this.to, slice);
       }
-      invert() {
-          return new RemoveMarkStep(this.from, this.to, this.mark);
+      invert(doc) {
+          let steps = [];
+          doc.nodesBetween(this.from, this.to, (node, pos) => {
+              if (node.isInline && node.isAtom) {
+                  let added = this.mark.addToSet(node.marks);
+                  if (!Mark$1.sameSet(added, node.marks)) {
+                      let from = Math.max(this.from, pos), to = Math.min(this.to, pos + node.nodeSize);
+                      pushMarkStep(RemoveMarkStep, from, to, this.mark, steps);
+                      for (let mark of node.marks)
+                          if (!mark.isInSet(added))
+                              pushMarkStep(AddMarkStep, from, to, mark, steps);
+                  }
+              }
+          });
+          return steps.length == 1 ? steps[0] : new MarkSetStep(steps);
       }
       map(mapping) {
-          let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-          if (from.deleted && to.deleted || from.pos >= to.pos)
+          let from = mapping.map(this.from, 1), to = mapping.map(this.to, -1);
+          if (from >= to)
               return null;
-          return new AddMarkStep(from.pos, to.pos, this.mark);
+          return new AddMarkStep(from, to, this.mark);
       }
       merge(other) {
           if (other instanceof AddMarkStep &&
@@ -33367,14 +33379,19 @@ so this becomes the fallback color for the slot */ ''}
           }, doc), oldSlice.openStart, oldSlice.openEnd);
           return StepResult.fromReplace(doc, this.from, this.to, slice);
       }
-      invert() {
-          return new AddMarkStep(this.from, this.to, this.mark);
+      invert(doc) {
+          let steps = [];
+          doc.nodesBetween(this.from, this.to, (node, pos) => {
+              if (node.isInline && node.isAtom && this.mark.isInSet(node.marks))
+                  pushMarkStep(AddMarkStep, Math.max(this.from, pos), Math.min(this.to, pos + node.nodeSize), this.mark, steps);
+          });
+          return steps.length == 1 ? steps[0] : new MarkSetStep(steps);
       }
       map(mapping) {
-          let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-          if (from.deleted && to.deleted || from.pos >= to.pos)
+          let from = mapping.map(this.from, 1), to = mapping.map(this.to, -1);
+          if (from >= to)
               return null;
-          return new RemoveMarkStep(from.pos, to.pos, this.mark);
+          return new RemoveMarkStep(from, to, this.mark);
       }
       merge(other) {
           if (other instanceof RemoveMarkStep &&
@@ -33397,6 +33414,51 @@ so this becomes the fallback color for the slot */ ''}
       }
   }
   Step$1.jsonID("removeMark", RemoveMarkStep);
+  function pushMarkStep(cls, from, to, mark, target) {
+      let last = target.length ? target[target.length - 1] : null;
+      if (last && last instanceof cls && last.to == from && last.mark.eq(mark)) {
+          target[target.length - 1] = new cls(last.from, to, mark);
+      }
+      else {
+          target.push(new cls(from, to, mark));
+      }
+  }
+  class MarkSetStep extends Step$1 {
+      constructor(steps) {
+          super();
+          this.steps = steps;
+      }
+      apply(doc) {
+          for (let step of this.steps) {
+              let result = step.apply(doc);
+              if (!result.doc)
+                  return result;
+              doc = result.doc;
+          }
+          return new StepResult(doc, null);
+      }
+      invert(doc) {
+          return new MarkSetStep(this.steps.map(s => s.invert(doc)));
+      }
+      map(mapping) {
+          let result = [];
+          for (let step of this.steps) {
+              let mapped = step.map(mapping);
+              if (mapped)
+                  result.push(mapped);
+          }
+          return result.length ? new MarkSetStep(result) : null;
+      }
+      toJSON() {
+          return { stepType: "markSet", steps: this.steps.map(s => s.toJSON()) };
+      }
+      static fromJSON(schema, json) {
+          if (!Array.isArray(json.steps) || !json.steps.every((s) => s.stepType == "addMark" || s.stepType == "removeMark"))
+              throw new RangeError("Invalid JSON for MarkSetStep");
+          return new MarkSetStep(json.steps.map((s) => Step$1.fromJSON(schema, s)));
+      }
+  }
+  Step$1.jsonID("markSet", MarkSetStep);
   /**
   Add a mark to a specific node.
   */
@@ -33721,36 +33783,22 @@ so this becomes the fallback color for the slot */ ''}
   }
 
   function addMark(tr, from, to, mark) {
-      let removed = [], added = [];
-      let removing, adding;
+      let added = [];
       tr.doc.nodesBetween(from, to, (node, pos, parent) => {
           if (!node.isInline)
               return;
           let marks = node.marks;
           if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
               let start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
-              let newSet = mark.addToSet(marks);
-              for (let i = 0; i < marks.length; i++) {
-                  if (!marks[i].isInSet(newSet)) {
-                      if (removing && removing.to == start && removing.mark.eq(marks[i]))
-                          removing.to = end;
-                      else
-                          removed.push(removing = new RemoveMarkStep(start, end, marks[i]));
-                  }
-              }
-              if (adding && adding.to == start)
-                  adding.to = end;
-              else
-                  added.push(adding = new AddMarkStep(start, end, mark));
+              pushMarkStep(AddMarkStep, start, end, mark, added);
           }
       });
-      removed.forEach(s => tr.step(s));
       added.forEach(s => tr.step(s));
   }
   function removeMark(tr, from, to, mark) {
       let matched = [], step = 0;
       tr.doc.nodesBetween(from, to, (node, pos) => {
-          if (!node.isInline)
+          if (!node.isInline || !node.isAtom)
               return;
           step++;
           let toRemove = null;
@@ -36763,7 +36811,7 @@ so this becomes the fallback color for the slot */ ''}
       let splitDepth = wrappers.length - found;
       let splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0), parent = range.parent;
       for (let i = range.startIndex, e = range.endIndex, first = true; i < e; i++, first = false) {
-          if (!first && canSplit(tr.doc, splitPos, splitDepth)) {
+          if (!first && splitDepth && canSplit(tr.doc, splitPos, splitDepth)) {
               tr.split(splitPos, splitDepth);
               splitPos += 2 * splitDepth;
           }
@@ -36771,26 +36819,30 @@ so this becomes the fallback color for the slot */ ''}
       }
       return tr;
   }
+  function isItem(itemType, type) {
+      return itemType instanceof NodeType$1 ? type == itemType : itemType.indexOf(type) > -1;
+  }
   /**
   Create a command to lift the list item around the selection up into
-  a wrapping list.
+  a wrapping list. `itemType` may be an array of list item types.
   */
   function liftListItem(itemType) {
       return function (state, dispatch) {
           let { $from, $to } = state.selection;
-          let range = $from.blockRange($to, node => node.childCount > 0 && node.firstChild.type == itemType);
+          let range = $from.blockRange($to, node => node.childCount > 0 && isItem(itemType, node.firstChild.type));
           if (!range)
               return false;
           if (!dispatch)
               return true;
-          if ($from.node(range.depth - 1).type == itemType) // Inside a parent list
-              return liftToOuterList(state, dispatch, itemType, range);
+          if (isItem(itemType, $from.node(range.depth - 1).type)) // Inside a parent list
+              return liftToOuterList(state, dispatch, range);
           else // Outer list node
               return liftOutOfList(state, dispatch, range);
       };
   }
-  function liftToOuterList(state, dispatch, itemType, range) {
+  function liftToOuterList(state, dispatch, range) {
       let tr = state.tr, end = range.end, endOfList = range.$to.end(range.depth);
+      let itemType = range.parent.child(range.endIndex - 1).type;
       if (end < endOfList) {
           // There are siblings after the lifted items, which must become
           // children of the last item
@@ -36832,24 +36884,24 @@ so this becomes the fallback color for the slot */ ''}
   }
   /**
   Create a command to sink the list item around the selection down
-  into an inner list.
+  into an inner list. `itemType` may be an array of list item types.
   */
   function sinkListItem(itemType) {
       return function (state, dispatch) {
           let { $from, $to } = state.selection;
-          let range = $from.blockRange($to, node => node.childCount > 0 && node.firstChild.type == itemType);
+          let range = $from.blockRange($to, node => node.childCount > 0 && isItem(itemType, node.firstChild.type));
           if (!range)
               return false;
           let startIndex = range.startIndex;
           if (startIndex == 0)
               return false;
           let parent = range.parent, nodeBefore = parent.child(startIndex - 1);
-          if (nodeBefore.type != itemType)
+          if (!isItem(itemType, nodeBefore.type))
               return false;
           if (dispatch) {
               let nestedBefore = nodeBefore.lastChild && nodeBefore.lastChild.type == parent.type;
-              let inner = Fragment.from(nestedBefore ? itemType.create() : null);
-              let slice = new Slice(Fragment.from(itemType.create(null, Fragment.from(parent.type.create(null, inner)))), nestedBefore ? 3 : 1, 0);
+              let inner = Fragment.from(nestedBefore ? nodeBefore.lastChild.lastChild.type.create() : null);
+              let slice = new Slice(Fragment.from(nodeBefore.type.create(null, Fragment.from(parent.type.create(null, inner)))), nestedBefore ? 3 : 1, 0);
               let before = range.start, after = range.end;
               dispatch(state.tr.step(new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice, 1, true))
                   .scrollIntoView());
@@ -37706,7 +37758,13 @@ so this becomes the fallback color for the slot */ ''}
               atEnd = offset > domIndex(this.contentDOM);
           }
           else if (this.contentDOM && this.contentDOM != this.dom && this.dom.contains(this.contentDOM)) {
-              atEnd = !!(dom.compareDocumentPosition(this.contentDOM) & 4);
+              let rel = dom.compareDocumentPosition(this.contentDOM);
+              if (rel & 16) { // this.contentDOM is inside dom
+                  atEnd = offset > Array.from(dom.childNodes).findIndex(n => n.contains(this.contentDOM));
+              }
+              else { // Check if after or before
+                  atEnd = !(rel & 4);
+              }
           }
           else if (this.dom.firstChild) {
               if (offset == 0)
@@ -38029,8 +38087,10 @@ so this becomes the fallback color for the slot */ ''}
               });
           if (!widget.type.spec.raw) {
               let elt = isElt(dom) ? dom : document.createElement("span");
-              if (elt != dom)
+              if (elt != dom) {
                   elt.appendChild(dom);
+                  dom = elt;
+              }
               if (!elt.hasAttribute("contenteditable"))
                   elt.contentEditable = "false";
               elt.classList.add("ProseMirror-widget");
@@ -39339,7 +39399,7 @@ so this becomes the fallback color for the slot */ ''}
                   return apply(view, next);
               return false;
           }
-          else if (!(mac$2 && mods.indexOf("m") > -1)) {
+          else if (!mac$2 || mods.indexOf("m") < 0) {
               let $head = sel.$head, node = $head.textOffset ? null : dir < 0 ? $head.nodeBefore : $head.nodeAfter, desc;
               if (!node || node.isText)
                   return false;
@@ -39528,17 +39588,14 @@ so this becomes the fallback color for the slot */ ''}
               offset = before.nodeValue.length;
           }
       }
-      let sel = view.domSelection();
+      let sel = view.domSelection(), range = view.domSelectionRange();
       if (!sel)
           return;
-      if (selectionCollapsed(sel)) {
-          let range = document.createRange();
-          range.setEnd(node, offset);
-          range.setStart(node, offset);
-          sel.removeAllRanges();
-          sel.addRange(range);
+      if (selectionCollapsed(range)) {
+          sel.collapse(node, offset);
       }
       else if (sel.extend) {
+          sel.collapse(range.anchorNode, range.anchorOffset);
           sel.extend(node, offset);
       }
       view.domObserver.setCurSelection();
@@ -39566,7 +39623,13 @@ so this becomes the fallback color for the slot */ ''}
                   return after.left > coords.left ? "ltr" : "rtl";
           }
       }
-      let computed = getComputedStyle(view.dom).direction;
+      let block = view.dom;
+      for (let d = $pos.depth; d > 0; d--)
+          if ($pos.node(d).isBlock) {
+              block = view.nodeDOM($pos.before(d)) || block;
+              break;
+          }
+      let computed = getComputedStyle(block).direction;
       return computed == "rtl" ? "rtl" : "ltr";
   }
   // Check whether vertical selection motion would involve node
@@ -40839,6 +40902,23 @@ so this becomes the fallback color for the slot */ ''}
               return false;
       return true;
   }
+  class FragmentCursor {
+      constructor(frag) {
+          this.frag = frag;
+          this.index = 0;
+          this.off = 0;
+      }
+      nodeAt(off) {
+          while (this.off <= off && this.index < this.frag.childCount) {
+              let next = this.frag.child(this.index);
+              if (this.off == off)
+                  return next;
+              this.off += next.nodeSize;
+              this.index++;
+          }
+          return null;
+      }
+  }
   class WidgetType {
       constructor(toDOM, spec) {
           this.toDOM = toDOM;
@@ -40894,9 +40974,9 @@ so this becomes the fallback color for the slot */ ''}
               return null;
           return new Decoration(from.pos - offset, to.pos - offset, this);
       }
-      valid(node, span) {
-          let { index, offset } = node.content.findIndex(span.from), child;
-          return offset == span.from && !(child = node.child(index)).isText && offset + child.nodeSize == span.to;
+      valid(node, span, cursor) {
+          let found = cursor.nodeAt(span.from);
+          return !!found && !found.isText && span.from + found.nodeSize == span.to;
       }
       eq(other) {
           return this == other ||
@@ -41053,12 +41133,15 @@ so this becomes the fallback color for the slot */ ''}
       */
       mapInner(mapping, node, offset, oldOffset, options) {
           let newLocal;
-          for (let i = 0; i < this.local.length; i++) {
-              let mapped = this.local[i].map(mapping, offset, oldOffset);
-              if (mapped && mapped.type.valid(node, mapped))
-                  (newLocal || (newLocal = [])).push(mapped);
-              else if (options.onRemove)
-                  options.onRemove(this.local[i].spec);
+          if (this.local.length) {
+              let cur = new FragmentCursor(node.content);
+              for (let i = 0; i < this.local.length; i++) {
+                  let mapped = this.local[i].map(mapping, offset, oldOffset);
+                  if (mapped && mapped.type.valid(node, mapped, cur))
+                      (newLocal || (newLocal = [])).push(mapped);
+                  else if (options.onRemove)
+                      options.onRemove(this.local[i].spec);
+              }
           }
           if (this.children.length)
               return mapChildren(this.children, newLocal || [], mapping, node, offset, oldOffset, options);
@@ -41095,9 +41178,12 @@ so this becomes the fallback color for the slot */ ''}
               childIndex += 3;
           });
           let local = moveSpans(childIndex ? withoutNulls(decorations) : decorations, -offset);
-          for (let i = 0; i < local.length; i++)
-              if (!local[i].type.valid(doc, local[i]))
-                  local.splice(i--, 1);
+          if (local.length) {
+              let cur = new FragmentCursor(doc.content);
+              for (let i = 0; i < local.length; i++)
+                  if (!local[i].type.valid(doc, local[i], cur))
+                      local.splice(i--, 1);
+          }
           return new DecorationSet(local.length ? this.local.concat(local).sort(byPos) : this.local, children || this.children);
       }
       /**
@@ -41440,12 +41526,15 @@ so this becomes the fallback color for the slot */ ''}
           }
       });
       let locals = moveSpans(hasNulls ? withoutNulls(spans) : spans, -offset).sort(byPos);
-      for (let i = 0; i < locals.length; i++)
-          if (!locals[i].type.valid(node, locals[i])) {
-              if (options.onRemove)
-                  options.onRemove(locals[i].spec);
-              locals.splice(i--, 1);
-          }
+      if (locals.length) {
+          let cur = new FragmentCursor(node.content);
+          for (let i = 0; i < locals.length; i++)
+              if (!locals[i].type.valid(node, locals[i], cur)) {
+                  if (options.onRemove)
+                      options.onRemove(locals[i].spec);
+                  locals.splice(i--, 1);
+              }
+      }
       return locals.length || children.length ? new DecorationSet(locals, children) : empty$1;
   }
   // Used to sort decorations so that ones with a low start position
@@ -41678,8 +41767,11 @@ 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 selRange, newSel = false;
+          if (!this.suppressingSelectionUpdates && hasFocusAndSelection(view)) {
+              selRange = view.domSelectionRange();
+              newSel = !this.currentSelection.eq(selRange) && !this.ignoreSelectionChange(selRange);
+          }
           let from = -1, to = -1, typeOver = false, added = [];
           if (view.editable) {
               for (let i = 0; i < mutations.length; i++) {
@@ -41734,11 +41826,11 @@ so this becomes the fallback color for the slot */ ''}
           // the state
           if (from < 0 && newSel && view.input.lastFocus > Date.now() - 200 &&
               Math.max(view.input.lastTouch, view.input.lastClick.time) < Date.now() - 300 &&
-              selectionCollapsed(sel) && (readSel = selectionFromDOM(view)) &&
+              selectionCollapsed(selRange) && (readSel = selectionFromDOM(view)) &&
               readSel.eq(Selection$2.near(view.state.doc.resolve(0), 1))) {
               view.input.lastFocus = 0;
               selectionToDOM(view);
-              this.currentSelection.set(sel);
+              this.currentSelection.set(selRange);
               view.scrollToSelection();
           }
           else if (from > -1 || newSel) {
@@ -41753,9 +41845,10 @@ so this becomes the fallback color for the slot */ ''}
               this.handleDOMChange(from, to, typeOver, added);
               if (view.docView && view.docView.dirty)
                   view.updateState(view.state);
-              else if (!this.currentSelection.eq(sel))
+              else if (selRange && !this.currentSelection.eq(selRange))
                   selectionToDOM(view);
-              this.currentSelection.set(sel);
+              if (selRange)
+                  this.currentSelection.set(selRange);
           }
       }
       registerMutation(mut, added) {
@@ -42087,7 +42180,8 @@ so this becomes the fallback color for the slot */ ''}
       }
       // Same for backspace
       if (view.state.selection.anchor > change.start &&
-          looksLikeBackspace(doc, change.start, change.endA, $from, $to) &&
+          (inlineChange ? change.endA > change.start && change.endB == change.start
+              : looksLikeBlockJoin(doc, change.start, change.endA, $from, $to)) &&
           view.someProp("handleKeyDown", f => f(view, keyEvent(8, "Backspace")))) {
           if (android && chrome)
               view.domObserver.suppressSelectionUpdates(); // #820
@@ -42208,7 +42302,7 @@ so this becomes the fallback color for the slot */ ''}
       if (Fragment.from(updated).eq(cur))
           return { mark, type };
   }
-  function looksLikeBackspace(old, start, end, $newStart, $newEnd) {
+  function looksLikeBlockJoin(old, start, end, $newStart, $newEnd) {
       if ( // The content must have shrunk
       end - start <= $newEnd.pos - $newStart.pos ||
           // newEnd must point directly at or after the end of the block that newStart points into
@@ -42216,7 +42310,7 @@ so this becomes the fallback color for the slot */ ''}
           return false;
       let $start = old.resolve(start);
       // Handle the case where, rather than joining blocks, the change just removed an entire block
-      if (!$newStart.parent.isTextblock) {
+      if (!$newStart.parent.inlineContent) {
           let after = $start.nodeAfter;
           return after != null && end == start + after.nodeSize;
       }
@@ -44047,6 +44141,7 @@ so this becomes the fallback color for the slot */ ''}
   	if (dispatch) {
   		const tr = state.tr;
   		const { ranges } = state.selection;
+  		const marks = state.selection instanceof TextSelection ? state.selection.$from.marksAcross(state.selection.$to) : null;
   		const mapFrom = tr.steps.length;
   		ranges.forEach((range) => {
   			const mapping = tr.mapping.slice(mapFrom);
@@ -44056,6 +44151,7 @@ so this becomes the fallback color for the slot */ ''}
   			tr.deleteRange(from, to);
   		});
   		if (!tr.selection.empty) tr.setSelection(TextSelection.near(tr.doc.resolve(tr.selection.from)));
+  		if (marks) tr.ensureMarks(marks);
   		tr.scrollIntoView();
   		dispatch(tr);
   	}
@@ -44945,30 +45041,121 @@ so this becomes the fallback color for the slot */ ''}
   	return container.innerHTML;
   }
   //#endregion
-  //#region src/utilities/isFunction.ts
-  function isFunction$3(value) {
-  	return typeof value === "function";
+  //#region src/schema/getSchemaAttributes.ts
+  /**
+  * Combines external attribute structure with local attribute behavior.
+  * @param attributes The attributes from resolved local extensions
+  * @param schema The schema that defines the allowed attributes
+  * @returns Only attributes present in the schema
+  */
+  function getSchemaAttributes(attributes, schema) {
+  	const attributesByType = /* @__PURE__ */ new Map();
+  	for (const attribute of attributes) {
+  		var _attributesByType$get;
+  		const typeAttributes = (_attributesByType$get = attributesByType.get(attribute.type)) !== null && _attributesByType$get !== void 0 ? _attributesByType$get : /* @__PURE__ */ new Map();
+  		typeAttributes.set(attribute.name, attribute);
+  		attributesByType.set(attribute.type, typeAttributes);
+  	}
+  	return [...Object.values(schema.nodes), ...Object.values(schema.marks)].flatMap((type) => {
+  		var _type$spec$attrs;
+  		return Object.entries((_type$spec$attrs = type.spec.attrs) !== null && _type$spec$attrs !== void 0 ? _type$spec$attrs : {}).map(([name, spec]) => {
+  			var _attributesByType$get2;
+  			const local = (_attributesByType$get2 = attributesByType.get(type.name)) === null || _attributesByType$get2 === void 0 ? void 0 : _attributesByType$get2.get(name);
+  			const hasDefault = Object.hasOwn(spec, "default");
+  			return {
+  				type: type.name,
+  				name,
+  				attribute: {
+  					rendered: true,
+  					renderHTML: null,
+  					parseHTML: null,
+  					keepOnSplit: true,
+  					...local === null || local === void 0 ? void 0 : local.attribute,
+  					default: spec.default,
+  					isRequired: !hasDefault,
+  					validate: spec.validate
+  				}
+  			};
+  		});
+  	});
   }
   //#endregion
-  //#region src/utilities/callOrReturn.ts
+  //#region src/schema/schemaSpecFields.ts
+  const nodeSchemaFields = {
+  	content: "string",
+  	marks: "string",
+  	group: "string",
+  	inline: "boolean",
+  	atom: "boolean",
+  	selectable: "boolean",
+  	draggable: "boolean",
+  	code: "boolean",
+  	whitespace: ["pre", "normal"],
+  	definingAsContext: "boolean",
+  	definingForContent: "boolean",
+  	defining: "boolean",
+  	isolating: "boolean",
+  	linebreakReplacement: "boolean"
+  };
+  const markSchemaFields = {
+  	inclusive: "boolean",
+  	excludes: "string",
+  	group: "string",
+  	spanning: "boolean",
+  	code: "boolean"
+  };
+  //#endregion
+  //#region src/schema/mergeSchemaSpec.ts
+  function structuralFields(spec, fields, path) {
+  	return Object.fromEntries(Object.entries(fields).flatMap(([name, expected]) => {
+  		const value = spec[name];
+  		if (value === void 0) return [];
+  		if (!(typeof expected === "string" ? typeof value === expected : typeof value === "string" && expected.includes(value))) throw new RangeError(`Invalid schemaSpec field '${path}.${name}'`);
+  		return [[name, value]];
+  	}));
+  }
+  function mergeType(name, local, external, fields) {
+  	return {
+  		...Object.fromEntries(Object.entries(local).filter(([key]) => key !== "attrs" && !Object.hasOwn(fields, key))),
+  		...structuralFields(external, fields, name),
+  		attrs: external.attrs
+  	};
+  }
+  function checkTypes(local, external, kind) {
+  	for (const name of Object.keys(external)) if (!Object.hasOwn(local, name)) throw new RangeError(`schemaSpec requires a local ${kind} extension named '${name}'`);
+  	for (const name of Object.keys(local)) if (!Object.hasOwn(external, name)) throw new RangeError(`Local ${kind} extension '${name}' is not in schemaSpec`);
+  }
   /**
-  * Optionally calls `value` as a function.
-  * Otherwise it is returned directly.
-  * @param value Function or any value.
-  * @param context Optional context to bind to function.
-  * @param props Optional props to pass to function.
+  * Combines external structure with local DOM behavior and extension metadata.
+  * @param local The specifications generated by resolved local extensions
+  * @param external The schema compiled from the provided specification
+  * @returns A specification in the external schema's node and mark order
   */
-  function callOrReturn(value, context = void 0, ...props) {
-  	if (isFunction$3(value)) {
-  		if (context) return value.bind(context)(...props);
-  		return value(...props);
-  	}
-  	return value;
+  function mergeSchemaSpec(local, external) {
+  	checkTypes(local.nodes, external.nodes, "node");
+  	checkTypes(local.marks, external.marks, "mark");
+  	let nodes = external.spec.nodes;
+  	let marks = external.spec.marks;
+  	external.spec.nodes.forEach((name, spec) => {
+  		nodes = nodes.update(name, mergeType(name, local.nodes[name], spec, nodeSchemaFields));
+  	});
+  	external.spec.marks.forEach((name, spec) => {
+  		marks = marks.update(name, mergeType(name, local.marks[name], spec, markSchemaFields));
+  	});
+  	return {
+  		topNode: external.topNodeType.name,
+  		nodes,
+  		marks
+  	};
   }
   //#endregion
-  //#region src/utilities/isEmptyObject.ts
-  function isEmptyObject(value = {}) {
-  	return Object.keys(value).length === 0 && value.constructor === Object;
+  //#region src/utilities/findDuplicates.ts
+  /**
+  * Find duplicates in an array.
+  */
+  function findDuplicates(items) {
+  	const filtered = items.filter((el, index) => items.indexOf(el) !== index);
+  	return Array.from(new Set(filtered));
   }
   //#endregion
   //#region src/helpers/splitExtensions.ts
@@ -45055,6 +45242,32 @@ so this becomes the fallback color for the slot */ ''}
   	return extensionAttributes;
   }
   //#endregion
+  //#region src/utilities/isFunction.ts
+  function isFunction$3(value) {
+  	return typeof value === "function";
+  }
+  //#endregion
+  //#region src/utilities/callOrReturn.ts
+  /**
+  * Optionally calls `value` as a function.
+  * Otherwise it is returned directly.
+  * @param value Function or any value.
+  * @param context Optional context to bind to function.
+  * @param props Optional props to pass to function.
+  */
+  function callOrReturn(value, context = void 0, ...props) {
+  	if (isFunction$3(value)) {
+  		if (context) return value.bind(context)(...props);
+  		return value(...props);
+  	}
+  	return value;
+  }
+  //#endregion
+  //#region src/utilities/isEmptyObject.ts
+  function isEmptyObject(value = {}) {
+  	return Object.keys(value).length === 0 && value.constructor === Object;
+  }
+  //#endregion
   //#region src/utilities/mergeAttributes.ts
   /** Splits a CSS style string into declarations, ignoring semicolons inside quotes/parentheses. */
   function splitStyleDeclarations(styles) {
@@ -45191,7 +45404,7 @@ so this becomes the fallback color for the slot */ ''}
   	};
   }
   //#endregion
-  //#region src/helpers/getSchemaByResolvedExtensions.ts
+  //#region src/helpers/getSchemaSpecByResolvedExtensions.ts
   function cleanUpSchemaItem(data) {
   	return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
   		if (key === "attrs" && isEmptyObject(value)) return false;
@@ -45211,103 +45424,108 @@ so this becomes the fallback color for the slot */ ''}
   	return [extensionAttribute.name, spec];
   }
   /**
-  * Creates a new Prosemirror schema based on the given extensions.
+  * Builds schema specifications without compiling content expressions.
   * @param extensions An array of Tiptap extensions
   * @param editor The editor instance
-  * @returns A Prosemirror schema
+  * @param allAttributes The effective attributes used for schema and DOM behavior
+  * @returns The node and mark specifications
   */
-  function getSchemaByResolvedExtensions(extensions, editor) {
+  function getSchemaSpecByResolvedExtensions(extensions, editor, allAttributes = getAttributesFromExtensions(extensions)) {
   	var _nodeExtensions$find;
-  	const allAttributes = getAttributesFromExtensions(extensions);
   	const { nodeExtensions, markExtensions } = splitExtensions(extensions);
-  	const topNode = (_nodeExtensions$find = nodeExtensions.find((extension) => getExtensionField(extension, "topNode"))) === null || _nodeExtensions$find === void 0 ? void 0 : _nodeExtensions$find.name;
-  	const nodes = Object.fromEntries(nodeExtensions.map((extension) => {
-  		const extensionAttributes = allAttributes.filter((attribute) => attribute.type === extension.name);
-  		const context = {
-  			name: extension.name,
-  			options: extension.options,
-  			storage: extension.storage,
-  			editor
-  		};
-  		const schema = cleanUpSchemaItem({
-  			...extensions.reduce((fields, e) => {
-  				const extendNodeSchema = getExtensionField(e, "extendNodeSchema", context);
-  				return {
-  					...fields,
-  					...extendNodeSchema ? extendNodeSchema(extension) : {}
-  				};
-  			}, {}),
-  			content: callOrReturn(getExtensionField(extension, "content", context)),
-  			marks: callOrReturn(getExtensionField(extension, "marks", context)),
-  			group: callOrReturn(getExtensionField(extension, "group", context)),
-  			inline: callOrReturn(getExtensionField(extension, "inline", context)),
-  			atom: callOrReturn(getExtensionField(extension, "atom", context)),
-  			selectable: callOrReturn(getExtensionField(extension, "selectable", context)),
-  			draggable: callOrReturn(getExtensionField(extension, "draggable", context)),
-  			code: callOrReturn(getExtensionField(extension, "code", context)),
-  			whitespace: callOrReturn(getExtensionField(extension, "whitespace", context)),
-  			linebreakReplacement: callOrReturn(getExtensionField(extension, "linebreakReplacement", context)),
-  			defining: callOrReturn(getExtensionField(extension, "defining", context)),
-  			isolating: callOrReturn(getExtensionField(extension, "isolating", context)),
-  			attrs: Object.fromEntries(extensionAttributes.map(buildAttributeSpec))
-  		});
-  		const parseHTML = callOrReturn(getExtensionField(extension, "parseHTML", context));
-  		if (parseHTML) schema.parseDOM = parseHTML.map((parseRule) => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
-  		const renderHTML = getExtensionField(extension, "renderHTML", context);
-  		if (renderHTML) schema.toDOM = (node) => renderHTML({
-  			node,
-  			HTMLAttributes: getRenderedAttributes(node, extensionAttributes)
-  		});
-  		const renderText = getExtensionField(extension, "renderText", context);
-  		if (renderText) schema.toText = renderText;
-  		return [extension.name, schema];
-  	}));
-  	const marks = Object.fromEntries(markExtensions.map((extension) => {
-  		const extensionAttributes = allAttributes.filter((attribute) => attribute.type === extension.name);
-  		const context = {
-  			name: extension.name,
-  			options: extension.options,
-  			storage: extension.storage,
-  			editor
-  		};
-  		const schema = cleanUpSchemaItem({
-  			...extensions.reduce((fields, e) => {
-  				const extendMarkSchema = getExtensionField(e, "extendMarkSchema", context);
-  				return {
-  					...fields,
-  					...extendMarkSchema ? extendMarkSchema(extension) : {}
-  				};
-  			}, {}),
-  			inclusive: callOrReturn(getExtensionField(extension, "inclusive", context)),
-  			excludes: callOrReturn(getExtensionField(extension, "excludes", context)),
-  			group: callOrReturn(getExtensionField(extension, "group", context)),
-  			spanning: callOrReturn(getExtensionField(extension, "spanning", context)),
-  			code: callOrReturn(getExtensionField(extension, "code", context)),
-  			attrs: Object.fromEntries(extensionAttributes.map(buildAttributeSpec))
-  		});
-  		const parseHTML = callOrReturn(getExtensionField(extension, "parseHTML", context));
-  		if (parseHTML) schema.parseDOM = parseHTML.map((parseRule) => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
-  		const renderHTML = getExtensionField(extension, "renderHTML", context);
-  		if (renderHTML) schema.toDOM = (mark) => renderHTML({
-  			mark,
-  			HTMLAttributes: getRenderedAttributes(mark, extensionAttributes)
-  		});
-  		return [extension.name, schema];
-  	}));
-  	return new Schema$2({
-  		topNode,
-  		nodes,
-  		marks
-  	});
+  	return {
+  		topNode: (_nodeExtensions$find = nodeExtensions.find((extension) => getExtensionField(extension, "topNode"))) === null || _nodeExtensions$find === void 0 ? void 0 : _nodeExtensions$find.name,
+  		nodes: Object.fromEntries(nodeExtensions.map((extension) => {
+  			const extensionAttributes = allAttributes.filter((attribute) => attribute.type === extension.name);
+  			const context = {
+  				name: extension.name,
+  				options: extension.options,
+  				storage: extension.storage,
+  				editor
+  			};
+  			const schema = cleanUpSchemaItem({
+  				...extensions.reduce((fields, e) => {
+  					const extendNodeSchema = getExtensionField(e, "extendNodeSchema", context);
+  					return {
+  						...fields,
+  						...extendNodeSchema ? extendNodeSchema(extension) : {}
+  					};
+  				}, {}),
+  				content: callOrReturn(getExtensionField(extension, "content", context)),
+  				marks: callOrReturn(getExtensionField(extension, "marks", context)),
+  				group: callOrReturn(getExtensionField(extension, "group", context)),
+  				inline: callOrReturn(getExtensionField(extension, "inline", context)),
+  				atom: callOrReturn(getExtensionField(extension, "atom", context)),
+  				selectable: callOrReturn(getExtensionField(extension, "selectable", context)),
+  				draggable: callOrReturn(getExtensionField(extension, "draggable", context)),
+  				code: callOrReturn(getExtensionField(extension, "code", context)),
+  				whitespace: callOrReturn(getExtensionField(extension, "whitespace", context)),
+  				linebreakReplacement: callOrReturn(getExtensionField(extension, "linebreakReplacement", context)),
+  				defining: callOrReturn(getExtensionField(extension, "defining", context)),
+  				isolating: callOrReturn(getExtensionField(extension, "isolating", context)),
+  				attrs: Object.fromEntries(extensionAttributes.map(buildAttributeSpec))
+  			});
+  			const parseHTML = callOrReturn(getExtensionField(extension, "parseHTML", context));
+  			if (parseHTML) schema.parseDOM = parseHTML.map((parseRule) => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
+  			const renderHTML = getExtensionField(extension, "renderHTML", context);
+  			if (renderHTML) schema.toDOM = (node) => renderHTML({
+  				node,
+  				HTMLAttributes: getRenderedAttributes(node, extensionAttributes)
+  			});
+  			const renderText = getExtensionField(extension, "renderText", context);
+  			if (renderText) schema.toText = renderText;
+  			return [extension.name, schema];
+  		})),
+  		marks: Object.fromEntries(markExtensions.map((extension) => {
+  			const extensionAttributes = allAttributes.filter((attribute) => attribute.type === extension.name);
+  			const context = {
+  				name: extension.name,
+  				options: extension.options,
+  				storage: extension.storage,
+  				editor
+  			};
+  			const schema = cleanUpSchemaItem({
+  				...extensions.reduce((fields, e) => {
+  					const extendMarkSchema = getExtensionField(e, "extendMarkSchema", context);
+  					return {
+  						...fields,
+  						...extendMarkSchema ? extendMarkSchema(extension) : {}
+  					};
+  				}, {}),
+  				inclusive: callOrReturn(getExtensionField(extension, "inclusive", context)),
+  				excludes: callOrReturn(getExtensionField(extension, "excludes", context)),
+  				group: callOrReturn(getExtensionField(extension, "group", context)),
+  				spanning: callOrReturn(getExtensionField(extension, "spanning", context)),
+  				code: callOrReturn(getExtensionField(extension, "code", context)),
+  				attrs: Object.fromEntries(extensionAttributes.map(buildAttributeSpec))
+  			});
+  			const parseHTML = callOrReturn(getExtensionField(extension, "parseHTML", context));
+  			if (parseHTML) schema.parseDOM = parseHTML.map((parseRule) => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
+  			const renderHTML = getExtensionField(extension, "renderHTML", context);
+  			if (renderHTML) schema.toDOM = (mark) => renderHTML({
+  				mark,
+  				HTMLAttributes: getRenderedAttributes(mark, extensionAttributes)
+  			});
+  			return [extension.name, schema];
+  		}))
+  	};
   }
   //#endregion
-  //#region src/utilities/findDuplicates.ts
+  //#region src/helpers/getSchemaByResolvedExtensions.ts
   /**
-  * Find duplicates in an array.
+  * Creates a ProseMirror schema from resolved extensions.
+  * @param extensions The flattened and sorted extensions
+  * @param editor The editor instance
+  * @param schemaSpec The external structure to use with local extension behavior
+  * @returns A ProseMirror schema
   */
-  function findDuplicates(items) {
-  	const filtered = items.filter((el, index) => items.indexOf(el) !== index);
-  	return Array.from(new Set(filtered));
+  function getSchemaByResolvedExtensions(extensions, editor, schemaSpec) {
+  	if (schemaSpec === void 0) return new Schema$2(getSchemaSpecByResolvedExtensions(extensions, editor));
+  	const duplicates = findDuplicates(extensions.filter((extension) => extension.type !== "extension").map((extension) => extension.name));
+  	if (duplicates.length) throw new RangeError(`Duplicate local schema types: ${duplicates.join(", ")}`);
+  	const external = new Schema$2(schemaSpec);
+  	const local = getSchemaSpecByResolvedExtensions(extensions, editor, getSchemaAttributes(getAttributesFromExtensions(extensions), external));
+  	return new Schema$2(mergeSchemaSpec(local, external));
   }
   //#endregion
   //#region src/helpers/sortExtensions.ts
@@ -45462,6 +45680,7 @@ so this becomes the fallback color for the slot */ ''}
   function getChangedRanges(transform) {
   	const { mapping, steps } = transform;
   	const changes = [];
+  	const inverted = mapping.invert();
   	mapping.maps.forEach((stepMap, index) => {
   		const ranges = [];
   		if (!stepMap.ranges.length) {
@@ -45477,11 +45696,12 @@ so this becomes the fallback color for the slot */ ''}
   				to
   			});
   		});
+  		const rest = mapping.slice(index);
   		ranges.forEach(({ from, to }) => {
-  			const newStart = mapping.slice(index).map(from, -1);
-  			const newEnd = mapping.slice(index).map(to);
-  			const oldStart = mapping.invert().map(newStart, -1);
-  			const oldEnd = mapping.invert().map(newEnd);
+  			const newStart = rest.map(from, -1);
+  			const newEnd = rest.map(to);
+  			const oldStart = inverted.map(newStart, -1);
+  			const oldEnd = inverted.map(newEnd);
   			changes.push({
   				oldRange: {
   					from: oldStart,
@@ -45751,6 +45971,40 @@ so this becomes the fallback color for the slot */ ''}
   	return value instanceof NodeSelection;
   }
   //#endregion
+  //#region src/helpers/isProseMirrorStep.ts
+  /**
+  * Checks if a value is a ProseMirror step
+  * @param value The value to check
+  * @returns - A boolean, if the boolean is true the value is a ProseMirror Step
+  * @example ```js
+  * isProseMirrorStep(transaction.steps[0])
+  * ```
+  */
+  function isProseMirrorStep(value) {
+  	if (value === null || typeof value !== "object") return false;
+  	const step = value;
+  	if (typeof step.apply !== "function" || typeof step.getMap !== "function" || typeof step.invert !== "function" || typeof step.map !== "function" || typeof step.merge !== "function" || typeof step.toJSON !== "function") return false;
+  	return true;
+  }
+  //#endregion
+  //#region src/helpers/isProseMirrorReplaceStep.ts
+  /**
+  * Checks if a value is a ProseMirror replace step result
+  * @param value The value to check
+  * @returns - A boolean, if the boolean is true the value is a ProseMirror ReplaceStep
+  * @example ```js
+  * isProseMirrorReplaceStep(transaction.steps[0])
+  * ```
+  */
+  function isProseMirrorReplaceStep(value) {
+  	if (value === null || typeof value !== "object") return false;
+  	const step = value;
+  	if (!isProseMirrorStep(step)) return false;
+  	const json = step.toJSON();
+  	if (json === null || typeof json !== "object" || json.stepType !== "replace") return false;
+  	return true;
+  }
+  //#endregion
   //#region src/helpers/MappablePosition.ts
   /**
   * A class that represents a mappable position in the editor. It can be extended
@@ -46072,6 +46326,94 @@ so this becomes the fallback color for the slot */ ''}
   	return true;
   };
   //#endregion
+  //#region src/commands/utils/createNode.ts
+  /** Creates a node when its content and required attributes are valid. */
+  function createNode(type, content, attrs) {
+  	if (!type.validContent(content)) return null;
+  	try {
+  		return type.create(attrs, content);
+  	} catch {
+  		return null;
+  	}
+  }
+  //#endregion
+  //#region src/commands/utils/flushPendingContent.ts
+  /** Converts and appends the content accumulated for the current list item. */
+  function flushPendingContent(state, itemType) {
+  	if (state.pendingContent.length === 0) return true;
+  	const item = createNode(itemType, Fragment.from(state.pendingContent));
+  	if (!item) return false;
+  	state.items.push(item);
+  	state.pendingContent = [];
+  	return true;
+  }
+  //#endregion
+  //#region src/commands/utils/appendContentNode.ts
+  /** Appends a content node to the current item or starts a new item when needed. */
+  function appendContentNode(node, state, itemType) {
+  	if (itemType.validContent(Fragment.from([...state.pendingContent, node]))) {
+  		state.pendingContent.push(node);
+  		return true;
+  	}
+  	if (!flushPendingContent(state, itemType) || !itemType.validContent(Fragment.from(node))) return false;
+  	state.pendingContent.push(node);
+  	return true;
+  }
+  //#endregion
+  //#region src/commands/utils/appendNestedList.ts
+  /** Preserves a nested list when supported or flattens its converted items. */
+  function appendNestedList(sourceList, state, context, convertListItems) {
+  	const nestedItems = convertListItems(sourceList, context);
+  	if (!nestedItems) return false;
+  	const nestedList = createNode(context.listType, Fragment.from(nestedItems), sourceList.attrs);
+  	if (!nestedList) return false;
+  	if (context.itemType.validContent(Fragment.from([...state.pendingContent, nestedList]))) {
+  		state.pendingContent.push(nestedList);
+  		return true;
+  	}
+  	if (!flushPendingContent(state, context.itemType)) return false;
+  	state.items.push(...nestedItems);
+  	return true;
+  }
+  //#endregion
+  //#region src/commands/utils/convertListItem.ts
+  /** Converts one source list item into one or more target list items. */
+  function convertListItem(sourceItem, context, convertListItems) {
+  	const state = {
+  		items: [],
+  		pendingContent: []
+  	};
+  	for (let index = 0; index < sourceItem.childCount; index += 1) {
+  		const child = sourceItem.child(index);
+  		if (!(context.isListNode(child) ? appendNestedList(child, state, context, convertListItems) : appendContentNode(child, state, context.itemType))) return null;
+  	}
+  	return flushPendingContent(state, context.itemType) ? state.items : null;
+  }
+  //#endregion
+  //#region src/commands/utils/convertListItems.ts
+  /** Recursively converts all items in a source list to the target list schema. */
+  function convertListItems(sourceList, context) {
+  	const convertedItems = [];
+  	for (let index = 0; index < sourceList.childCount; index += 1) {
+  		const items = convertListItem(sourceList.child(index), context, convertListItems);
+  		if (!items) return null;
+  		convertedItems.push(...items);
+  	}
+  	return convertedItems;
+  }
+  //#endregion
+  //#region src/commands/utils/findNodePosition.ts
+  /** Finds a descendant node's position relative to its root node. */
+  function findNodePosition(root, target) {
+  	let targetPos = null;
+  	root.descendants((node, pos) => {
+  		if (node !== target) return true;
+  		targetPos = pos;
+  		return false;
+  	});
+  	return targetPos;
+  }
+  //#endregion
   //#region src/commands/toggleList.ts
   /**
   * Normalise a list type attribute for comparison.
@@ -46151,6 +46493,43 @@ so this becomes the fallback color for the slot */ ''}
   			tr.setNodeMarkup(currentList.pos, listType);
   			return true;
   		}).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
+  		if (isList(currentList.node.type.name, extensions)) {
+  			var _currentList$node$fir;
+  			const currentItemType = (_currentList$node$fir = currentList.node.firstChild) === null || _currentList$node$fir === void 0 ? void 0 : _currentList$node$fir.type;
+  			if (currentItemType && currentItemType !== itemType) {
+  				const convertedItems = convertListItems(currentList.node, {
+  					listType,
+  					itemType,
+  					isListNode: (node) => isList(node.type.name, extensions)
+  				});
+  				const convertedContent = convertedItems ? Fragment.from(convertedItems) : null;
+  				if (!convertedContent || !listType.validContent(convertedContent)) return false;
+  				return chain().command(() => {
+  					const { $anchor, $head } = tr.selection;
+  					const anchorParent = $anchor.parent;
+  					const headParent = $head.parent;
+  					const anchorOffset = $anchor.parentOffset;
+  					const headOffset = $head.parentOffset;
+  					let newList;
+  					try {
+  						newList = listType.create(attributes, convertedContent);
+  					} catch {
+  						return false;
+  					}
+  					tr.replaceWith(currentList.pos, currentList.pos + currentList.node.nodeSize, newList);
+  					if (anchorParent.inlineContent && headParent.inlineContent) {
+  						const anchorParentPos = findNodePosition(newList, anchorParent);
+  						const headParentPos = findNodePosition(newList, headParent);
+  						if (anchorParentPos !== null && headParentPos !== null) {
+  							const anchor = currentList.pos + anchorParentPos + 2 + anchorOffset;
+  							const head = currentList.pos + headParentPos + 2 + headOffset;
+  							tr.setSelection(TextSelection.create(tr.doc, anchor, head));
+  						}
+  					}
+  					return true;
+  				}).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
+  			}
+  		}
   	}
   	if (!keepMarks || !marks || !dispatch) return chain().command(() => {
   		if (can().wrapInList(listType, attributes)) return true;
@@ -47348,6 +47727,34 @@ so this becomes the fallback color for the slot */ ''}
   }
   //#endregion
   //#region src/utilities/markdown/parseIndentedBlocks.ts
+  function dedentLine(line, indentSize) {
+  	return line.replace(/^[ \t]*/, (whitespace) => {
+  		const tabSize = 4;
+  		let columns = 0;
+  		for (const character of whitespace) columns += character === "	" ? tabSize - columns % tabSize : 1;
+  		return " ".repeat(Math.max(0, columns - indentSize));
+  	});
+  }
+  function continuesParagraph(line, blockTokens) {
+  	const source = `text\n${line}\n`;
+  	const token = blockTokens(source)[0];
+  	return ((token === null || token === void 0 ? void 0 : token.type) === "paragraph" || (token === null || token === void 0 ? void 0 : token.type) === "text") && token.raw === source;
+  }
+  /** Joins paragraph continuation lines and leaves nested blocks for separate parsing. */
+  function parseContinuation(mainContent, nestedContent, lexer) {
+  	var _lexer$isParagraphCon;
+  	const lines = nestedContent.split("\n");
+  	const isContinuation = (_lexer$isParagraphCon = lexer.isParagraphContinuation) !== null && _lexer$isParagraphCon !== void 0 ? _lexer$isParagraphCon : ((line) => continuesParagraph(line, lexer.blockTokens));
+  	let continuationLength = 0;
+  	for (const line of lines) {
+  		if (!line.trim() || !isContinuation(line)) break;
+  		continuationLength += 1;
+  	}
+  	return {
+  		mainContent: [mainContent, ...lines.slice(0, continuationLength).map((line) => line.trimStart())].join("\n"),
+  		nestedContent: lines.slice(continuationLength).join("\n")
+  	};
+  }
   /**
   * Parses markdown text into hierarchical indented blocks with proper nesting.
   *
@@ -47430,7 +47837,9 @@ so this becomes the fallback color for the slot */ ''}
   		let nestedTokens;
   		const nestedContent = itemContent.slice(1);
   		if (nestedContent.length > 0) {
-  			const dedentedNested = nestedContent.map((nestedLine) => nestedLine.slice(indentLevel + baseIndentSize)).join("\n");
+  			const continuation = parseContinuation(mainContent, nestedContent.map((nestedLine) => dedentLine(nestedLine, indentLevel + baseIndentSize)).join("\n"), lexer);
+  			itemData.mainContent = continuation.mainContent;
+  			const dedentedNested = continuation.nestedContent;
   			if (dedentedNested.trim()) {
   				if (config.customNestedParser) nestedTokens = config.customNestedParser(dedentedNested);
   				else nestedTokens = lexer.blockTokens(dedentedNested);
@@ -47442,7 +47851,7 @@ so this becomes the fallback color for the slot */ ''}
   	if (items.length === 0) return;
   	return {
   		items,
-  		raw: totalRaw
+  		raw: totalRaw.slice(0, src.length)
   	};
   }
   //#endregion
@@ -47467,6 +47876,7 @@ so this becomes the fallback color for the slot */ ''}
   * @param options - Optional rendering options
   * @param options.alignNestedToPrefix - Indent nested content to the width of the prefix
   * instead of the configured indent size, when the configured one is narrower
+  * @param options.indentMainContent - Indent continuation lines in the opening paragraph
   * @returns The rendered markdown string
   *
   * @example
@@ -47516,7 +47926,8 @@ so this becomes the fallback color for the slot */ ''}
   	if (!node || !Array.isArray(node.content)) return "";
   	const prefix = typeof prefixOrGenerator === "function" ? prefixOrGenerator(ctx) : prefixOrGenerator;
   	const [content, ...children] = node.content;
-  	let output = `${prefix}${h.renderChildren([content])}`;
+  	const mainContent = h.renderChildren([content]);
+  	let output = `${prefix}${(options === null || options === void 0 ? void 0 : options.indentMainContent) ? mainContent.split("\n").map((line, index) => index === 0 ? line : h.indent(line)).join("\n") : mainContent}`;
   	if (children && children.length > 0) children.forEach((child, index) => {
   		var _h$renderChild, _h$renderChild2;
   		const childContent = (_h$renderChild = (_h$renderChild2 = h.renderChild) === null || _h$renderChild2 === void 0 ? void 0 : _h$renderChild2.call(h, child, index + 1)) !== null && _h$renderChild !== void 0 ? _h$renderChild : h.renderChildren([child]);
@@ -48069,7 +48480,8 @@ so this becomes the fallback color for the slot */ ''}
   		this.editor = editor;
   		this.baseExtensions = extensions;
   		this.extensions = resolveExtensions(extensions);
-  		this.schema = getSchemaByResolvedExtensions(this.extensions, editor);
+  		this.hasSchemaSpec = editor.options.schemaSpec !== void 0;
+  		this.schema = getSchemaByResolvedExtensions(this.extensions, editor, editor.options.schemaSpec);
   		this.setupExtensions();
   	}
   	/**
@@ -48195,7 +48607,8 @@ so this becomes the fallback color for the slot */ ''}
   	* @returns An array of attributes
   	*/
   	get attributes() {
-  		return getAttributesFromExtensions(this.extensions);
+  		const attributes = getAttributesFromExtensions(this.extensions);
+  		return this.hasSchemaSpec ? getSchemaAttributes(attributes, this.schema) : attributes;
   	}
   	/**
   	* Get all node views from the extensions.
@@ -48771,10 +49184,12 @@ so this becomes the fallback color for the slot */ ''}
   	hasChecked = true;
   	let content;
   	try {
-  		content = ReplaceStep.fromJSON(schema, {
+  		const step = ReplaceStep.fromJSON(schema, {
   			from: 0,
   			to: 0
-  		}).slice.content;
+  		});
+  		if (!isProseMirrorReplaceStep(step)) return;
+  		content = step.slice.content;
   	} catch {
   		return;
   	}
@@ -54773,114 +55188,141 @@ img.ProseMirror-separator {
     return true
   }
 
-  function reference (state, startLine, _endLine, silent) {
-    let pos = state.bMarks[startLine] + state.tShift[startLine];
-    let max = state.eMarks[startLine];
-    let nextLine = startLine + 1;
+  // CommonMark limits reference labels to 999 Unicode code points.
+  const MAX_LABEL_LENGTH = 999;
 
-    // if it's indented more than 3 spaces, it should be a code block
-    if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
+  function countCodePoints (str) {
+    let length = str.length;
 
-    if (state.src.charCodeAt(pos) !== 0x5B/* [ */) { return false }
+    for (let i = 0; i < str.length - 1; i++) {
+      const high = str.charCodeAt(i);
+      if (high < 0xD800 || high > 0xDBFF) { continue }
 
-    function getNextLine (nextLine) {
-      const endLine = state.lineMax;
-
-      if (nextLine >= endLine || state.isEmpty(nextLine)) {
-        // empty line or end of input
-        return null
+      const low = str.charCodeAt(i + 1);
+      if (low >= 0xDC00 && low <= 0xDFFF) {
+        length--;
+        i++;
       }
+    }
 
-      let isContinuation = false;
+    return length
+  }
 
-      // this would be a code block normally, but after paragraph
-      // it's considered a lazy continuation regardless of what's there
-      if (state.sCount[nextLine] - state.blkIndent > 3) { isContinuation = true; }
+  // Exclusive end offset of the line, after its newline if present
+  function lineEnd (state, line) {
+    return Math.min(state.eMarks[line] + 1, state.src.length)
+  }
 
-      // quirk for blockquotes, this line should already be checked by that rule
-      if (state.sCount[nextLine] < 0) { isContinuation = true; }
-
-      if (!isContinuation) {
-        const terminatorRules = state.md.block.ruler.getRules('reference');
-        const oldParentType = state.parentType;
-        state.parentType = 'reference';
-
-        // Some tags can terminate paragraph without empty line.
-        let terminate = false;
-        for (let i = 0, l = terminatorRules.length; i < l; i++) {
-          if (terminatorRules[i](state, nextLine, endLine, true)) {
-            terminate = true;
-            break
-          }
-        }
+  // Returns -1 if the reference can't continue on this line
+  function getNextLinePos (state, nextLine) {
+    const endLine = state.lineMax;
+
+    if (nextLine >= endLine || state.isEmpty(nextLine)) {
+      // empty line or end of input
+      return -1
+    }
+
+    let isContinuation = false;
 
-        state.parentType = oldParentType;
-        if (terminate) {
-          // terminated by another block
-          return null
+    // this would be a code block normally, but after paragraph
+    // it's considered a lazy continuation regardless of what's there
+    if (state.sCount[nextLine] - state.blkIndent > 3) { isContinuation = true; }
+
+    // quirk for blockquotes, this line should already be checked by that rule
+    if (state.sCount[nextLine] < 0) { isContinuation = true; }
+
+    if (!isContinuation) {
+      const terminatorRules = state.md.block.ruler.getRules('reference');
+      const oldParentType = state.parentType;
+      state.parentType = 'reference';
+
+      // Some tags can terminate paragraph without empty line.
+      let terminate = false;
+      for (let i = 0, l = terminatorRules.length; i < l; i++) {
+        if (terminatorRules[i](state, nextLine, endLine, true)) {
+          terminate = true;
+          break
         }
       }
 
-      const pos = state.bMarks[nextLine] + state.tShift[nextLine];
-      const max = state.eMarks[nextLine];
-
-      // max + 1 explicitly includes the newline
-      return state.src.slice(pos, max + 1)
+      state.parentType = oldParentType;
+      if (terminate) {
+        // terminated by another block
+        return -1
+      }
     }
 
-    let str = state.src.slice(pos, max + 1);
+    return state.bMarks[nextLine] + state.tShift[nextLine]
+  }
+
+  function reference (state, startLine, _endLine, silent) {
+    const src = state.src;
+    let pos = state.bMarks[startLine] + state.tShift[startLine];
+    let nextLine = startLine + 1;
 
-    max = str.length;
+    // if it's indented more than 3 spaces, it should be a code block
+    if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
+
+    if (src.charCodeAt(pos) !== 0x5B/* [ */) { return false }
+
+    // Scan the source directly: indexing a string after each appended line
+    // can make V8 copy the accumulated prefix on every continuation.
+    let max = lineEnd(state, startLine);
+
+    let rawLabel = '';
     let labelEnd = -1;
+    let segmentStart = ++pos;
 
-    for (pos = 1; pos < max; pos++) {
-      const ch = str.charCodeAt(pos);
-      if (ch === 0x5B /* [ */) {
-        return false
-      } else if (ch === 0x5D /* ] */) {
+    while (pos < max) {
+      if (rawLabel.length + pos - segmentStart > MAX_LABEL_LENGTH * 2) { return false }
+
+      let ch = src.charCodeAt(pos);
+      if (ch === 0x5B /* [ */) { return false }
+      if (ch === 0x5D /* ] */) {
         labelEnd = pos;
         break
-      } else if (ch === 0x0A /* \n */) {
-        const lineContent = getNextLine(nextLine);
-        if (lineContent !== null) {
-          str += lineContent;
-          max = str.length;
-          nextLine++;
-        }
-      } else if (ch === 0x5C /* \ */) {
-        pos++;
-        if (pos < max && str.charCodeAt(pos) === 0x0A) {
-          const lineContent = getNextLine(nextLine);
-          if (lineContent !== null) {
-            str += lineContent;
-            max = str.length;
-            nextLine++;
-          }
-        }
       }
+      if (ch === 0x5C /* \ */) { ch = src.charCodeAt(++pos); }
+
+      if (ch === 0x0A /* \n */ && pos < max) {
+        const nextPos = getNextLinePos(state, nextLine);
+        if (nextPos < 0) { return false }
+        rawLabel += src.slice(segmentStart, max);
+        pos = segmentStart = nextPos;
+        max = lineEnd(state, nextLine++);
+        continue
+      }
+      pos++;
     }
 
-    if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false }
+    if (labelEnd < 0 || src.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false }
+
+    rawLabel += src.slice(segmentStart, labelEnd);
+
+    if (rawLabel.length > MAX_LABEL_LENGTH && countCodePoints(rawLabel) > MAX_LABEL_LENGTH) {
+      return false
+    }
 
     // [label]:   destination   'title'
     //         ^^^ skip optional whitespace here
-    for (pos = labelEnd + 2; pos < max; pos++) {
-      const ch = str.charCodeAt(pos);
+    pos = labelEnd + 2;
+    while (pos < max) {
+      const ch = src.charCodeAt(pos);
       if (ch === 0x0A) {
-        const lineContent = getNextLine(nextLine);
-        if (lineContent !== null) {
-          str += lineContent;
-          max = str.length;
-          nextLine++;
-        }
-      } else if (isSpace(ch)) ; else {
+        const nextPos = getNextLinePos(state, nextLine);
+        if (nextPos < 0) { break }
+        pos = nextPos;
+        max = lineEnd(state, nextLine++);
+      } else if (isSpace(ch)) {
+        pos++;
+      } else {
         break
       }
     }
 
     // [label]:   destination   'title'
     //            ^^^^^^^^^^^ parse this
-    const destRes = state.md.helpers.parseLinkDestination(str, pos, max);
+    const destRes = state.md.helpers.parseLinkDestination(src, pos, max);
     if (!destRes.ok) { return false }
 
     const href = state.md.normalizeLink(destRes.str);
@@ -54890,76 +55332,77 @@ img.ProseMirror-separator {
 
     // save cursor state, we could require to rollback later
     const destEndPos = pos;
+    const destEndMax = max;
     const destEndLineNo = nextLine;
 
     // [label]:   destination   'title'
     //                       ^^^ skipping those spaces
-    const start = pos;
-    for (; pos < max; pos++) {
-      const ch = str.charCodeAt(pos);
+    while (pos < max) {
+      const ch = src.charCodeAt(pos);
       if (ch === 0x0A) {
-        const lineContent = getNextLine(nextLine);
-        if (lineContent !== null) {
-          str += lineContent;
-          max = str.length;
-          nextLine++;
-        }
-      } else if (isSpace(ch)) ; else {
+        const nextPos = getNextLinePos(state, nextLine);
+        if (nextPos < 0) { break }
+        pos = nextPos;
+        max = lineEnd(state, nextLine++);
+      } else if (isSpace(ch)) {
+        pos++;
+      } else {
         break
       }
     }
 
     // [label]:   destination   'title'
     //                          ^^^^^^^ parse this
-    let titleRes = state.md.helpers.parseLinkTitle(str, pos, max);
+    const titleStart = pos;
+    let titleRes = state.md.helpers.parseLinkTitle(src, pos, max);
     while (titleRes.can_continue) {
-      const lineContent = getNextLine(nextLine);
-      if (lineContent === null) break
-      str += lineContent;
-      pos = max;
-      max = str.length;
-      nextLine++;
-      titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes);
+      const nextPos = getNextLinePos(state, nextLine);
+      if (nextPos < 0) break
+      pos = nextPos;
+      max = lineEnd(state, nextLine++);
+      titleRes = state.md.helpers.parseLinkTitle(src, pos, max, titleRes);
     }
     let title;
 
-    if (pos < max && start !== pos && titleRes.ok) {
+    if (titleStart !== destEndPos && titleRes.ok) {
       title = titleRes.str;
       pos = titleRes.pos;
     } else {
       title = '';
       pos = destEndPos;
+      max = destEndMax;
       nextLine = destEndLineNo;
     }
 
     // skip trailing spaces until the rest of the line
     while (pos < max) {
-      const ch = str.charCodeAt(pos);
+      const ch = src.charCodeAt(pos);
       if (!isSpace(ch)) { break }
       pos++;
     }
 
-    if (pos < max && str.charCodeAt(pos) !== 0x0A) {
+    if (pos < max && src.charCodeAt(pos) !== 0x0A) {
       if (title) {
         // garbage at the end of the line after title,
         // but it could still be a valid reference if we roll back
         title = '';
         pos = destEndPos;
+        max = destEndMax;
         nextLine = destEndLineNo;
         while (pos < max) {
-          const ch = str.charCodeAt(pos);
+          const ch = src.charCodeAt(pos);
           if (!isSpace(ch)) { break }
           pos++;
         }
       }
     }
 
-    if (pos < max && str.charCodeAt(pos) !== 0x0A) {
+    if (pos < max && src.charCodeAt(pos) !== 0x0A) {
       // garbage at the end of the line
       return false
     }
 
-    const label = normalizeReference(str.slice(1, labelEnd));
+    const label = normalizeReference(rawLabel);
     if (!label) {
       // CommonMark 0.20 disallows empty labels
       return false
@@ -55063,13 +55506,6 @@ img.ProseMirror-separator {
   const open_tag = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>';
 
   const close_tag = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>';
-  const comment = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->';
-  const processing = '<[?][\\s\\S]*?[?]>';
-  const declaration = '<![A-Za-z][^>]*>';
-  const cdata = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>';
-
-  const HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment +
-                          '|' + processing + '|' + declaration + '|' + cdata + ')');
   const HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')');
 
   // HTML block
@@ -55484,6 +55920,10 @@ img.ProseMirror-separator {
     this.backticks = {};
     this.backticksScanned = false;
 
+    // Set when html comment / PI / declaration / CDATA has no terminator,
+    // to skip further scans of these constructs
+    this.skipHtmlSpecial = false;
+
     // Counter used to disable inline linkify-it execution
     // inside <a> and markdown links
     this.linkLevel = 0;
@@ -56578,6 +57018,43 @@ img.ProseMirror-separator {
     return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */)
   }
 
+  // Comment, processing instruction, declaration or CDATA: fixed opener,
+  // then everything up to the first terminator. Returns end position or -1.
+  function scanSpecial (state, pos) {
+    const src = state.src;
+    let start;
+    let terminator;
+
+    if (src.startsWith('<!--', pos)) {
+      if (src.startsWith('>', pos + 4)) { return pos + 5 }
+      if (src.startsWith('->', pos + 4)) { return pos + 6 }
+      start = pos + 4;
+      terminator = '-->';
+    } else if (src.startsWith('<![CDATA[', pos)) {
+      start = pos + 9;
+      terminator = ']]>';
+    } else if (src.charCodeAt(pos + 1) === 0x3F/* ? */) {
+      start = pos + 2;
+      terminator = '?>';
+    } else if (isLetter(src.charCodeAt(pos + 2))) {
+      start = pos + 3;
+      terminator = '>';
+    } else {
+      return -1
+    }
+
+    if (state.skipHtmlSpecial) { return -1 }
+
+    const end = src.indexOf(terminator, start);
+    if (end < 0) {
+      // One flag for all constructs to keep code simple. Valid constructs after
+      // an unclosed one in the same paragraph become text, that's acceptable.
+      state.skipHtmlSpecial = true;
+      return -1
+    }
+    return end + terminator.length
+  }
+
   function html_inline (state, silent) {
     if (!state.md.options.html) { return false }
 
@@ -56589,26 +57066,28 @@ img.ProseMirror-separator {
       return false
     }
 
-    // Quick fail on second char
+    let end;
     const ch = state.src.charCodeAt(pos + 1);
-    if (ch !== 0x21/* ! */ &&
-        ch !== 0x3F/* ? */ &&
-        ch !== 0x2F/* / */ &&
-        !isLetter(ch)) {
+
+    if (ch === 0x21/* ! */ || ch === 0x3F/* ? */) {
+      end = scanSpecial(state, pos);
+    } else if (ch === 0x2F/* / */ || isLetter(ch)) {
+      const match = state.src.slice(pos).match(HTML_OPEN_CLOSE_TAG_RE);
+      end = match ? pos + match[0].length : -1;
+    } else {
       return false
     }
 
-    const match = state.src.slice(pos).match(HTML_TAG_RE);
-    if (!match) { return false }
+    if (end < 0) { return false }
 
     if (!silent) {
       const token = state.push('html_inline', '', 0);
-      token.content = match[0];
+      token.content = state.src.slice(pos, end);
 
       if (isLinkOpen(token.content)) state.linkLevel++;
       if (isLinkClose(token.content)) state.linkLevel--;
     }
-    state.pos += match[0].length;
+    state.pos = end;
     return true
   }
 
@@ -59648,7 +60127,7 @@ img.ProseMirror-separator {
       @internal
       */
       atBlank() {
-          return /(^|\n)$/.test(this.out);
+          return !this.out || this.out[this.out.length - 1] == "\n";
       }
       /**
       Ensure the current content ends with a newline.
@@ -59684,7 +60163,7 @@ img.ProseMirror-separator {
           for (let i = 0; i < lines.length; i++) {
               this.write();
               // Escape exclamation marks in front of links
-              if (!escape && lines[i][0] == "[" && /(^|[^\\])\!$/.test(this.out))
+              if (!escape && lines[i][0] == "[" && /(^|[^\\])\!$/.test(this.out.slice(-2)))
                   this.out = this.out.slice(0, this.out.length - 1) + "\\!";
               this.out += escape ? this.esc(lines[i], this.atBlockStart) : lines[i];
               if (i != lines.length - 1)
@@ -60832,7 +61311,7 @@ img.ProseMirror-separator {
   // THIS FILE IS AUTOMATICALLY GENERATED DO NOT EDIT DIRECTLY
   // See update-tlds.js for encoding/decoding format
   // https://data.iana.org/TLD/tlds-alpha-by-domain.txt
-  const encodedTlds = 'aaa1rp3bb0ott3vie4c1le2ogado5udhabi7c0ademy5centure6ountant0s9o1tor4d0s1ult4e0g1ro2tna4f0l1rica5g0akhan5ency5i0g1rbus3force5tel5kdn3l0ibaba4pay4lfinanz6state5y2sace3tom5m0azon4ericanexpress7family11x2fam3ica3sterdam8nalytics7droid5quan4z2o0l2partments8p0le4q0uarelle8r0ab1mco4chi3my2pa2t0e3s0da2ia2sociates9t0hleta5torney7u0ction5di0ble3o3spost5thor3o0s4w0s2x0a2z0ure5ba0by2idu3namex4d1k2r0celona5laycard4s5efoot5gains6seball5ketball8uhaus5yern5b0c1t1va3cg1n2d1e0ats2uty4er2rlin4st0buy5t2f1g1h0arti5i0ble3d1ke2ng0o3o1z2j1lack0friday9ockbuster8g1omberg7ue3m0s1w2n0pparibas9o0ats3ehringer8fa2m1nd2o0k0ing5sch2tik2on4t1utique6x2r0adesco6idgestone9oadway5ker3ther5ussels7s1t1uild0ers6siness6y1zz3v1w1y1z0h3ca0b1fe2l0l1vinklein9m0era3p2non3petown5ital0one8r0avan4ds2e0er0s4s2sa1e1h1ino4t0ering5holic7ba1n1re3c1d1enter4o1rn3f0a1d2g1h0anel2nel4rity4se2t2eap3intai5ristmas6ome4urch5i0priani6rcle4sco3tadel4i0c2y3k1l0aims4eaning6ick2nic1que6othing5ud3ub0med6m1n1o0ach3des3ffee4llege4ogne5m0mbank4unity6pany2re3uter5sec4ndos3struction8ulting7tact3ractors9oking4l1p2rsica5untry4pon0s4rses6pa2r0edit0card4union9icket5own3s1uise0s6u0isinella9v1w1x1y0mru3ou3z2dad1nce3ta1e1ing3sun4y2clk3ds2e0al0er2s3gree4livery5l1oitte5ta3mocrat6ntal2ist5si0gn4v2hl2iamonds6et2gital5rect0ory7scount3ver5h2y2j1k1m1np2o0cs1tor4g1mains5t1wnload7rive4tv2ubai3pont4rban5vag2r2z2earth3t2c0o2deka3u0cation8e1g1mail3erck5nergy4gineer0ing9terprises10pson4quipment8r0icsson6ni3s0q1tate5t1u0rovision8s2vents5xchange6pert3osed4ress5traspace10fage2il1rwinds6th3mily4n0s2rm0ers5shion4t3edex3edback6rrari3ero6i0delity5o2lm2nal1nce1ial7re0stone6mdale6sh0ing5t0ness6j1k1lickr3ghts4r2orist4wers5y2m1o0o0d1tball6rd1ex2sale4um3undation8x2r0ee1senius7l1ogans4ntier7tr2ujitsu5n0d2rniture7tbol5yi3ga0l0lery3o1up4me0s3p1rden4y2b0iz3d0n2e0a1nt0ing5orge5f1g0ee3h1i0ft0s3ves2ing5l0ass3e1obal2o4m0ail3bh2o1x2n1odaddy5ld0point6f2odyear5g0le4p1t1v2p1q1r0ainger5phics5tis4een3ipe3ocery4up4s1t1u0cci3ge2ide2tars5ru3w1y2hair2mburg5ngout5us3bo2dfc0bank7ealth0care8lp1sinki6re1mes5iphop4samitsu7tachi5v2k0t2m1n1ockey4ldings5iday5medepot5goods5s0ense7nda3rse3spital5t0ing5t0els3mail5use3w2r1sbc3t1u0ghes5yatt3undai7ibm2cbc2e1u2d1e0ee3fm2kano4l1m0amat4db2mo0bilien9n0c1dustries8finiti5o2g1k1stitute6urance4e4t0ernational10uit4vestments10o1piranga7q1r0ish4s0maili5t0anbul7t0au2v3jaguar4va3cb2e0ep2tzt3welry6io2ll2m0p2nj2o0bs1urg4t1y2p0morgan6rs3uegos4niper7kaufen5ddi3e0rryhotels6properties14fh2g1h1i0a1ds2m1ndle4tchen5wi3m1n1oeln3matsu5sher5p0mg2n2r0d1ed3uokgroup8w1y0oto4z2la0caixa5mborghini8er3nd0rover6xess5salle5t0ino3robe5w0yer5b1c1ds2ease3clerc5frak4gal2o2xus4gbt3i0dl2fe0insurance9style7ghting6ke2lly3mited4o2ncoln4k2ve1ing5k1lc1p2oan0s3cker3us3l1ndon4tte1o3ve3pl0financial11r1s1t0d0a3u0ndbeck6xe1ury5v1y2ma0drid4if1son4keup4n0agement7go3p1rket0ing3s4riott5shalls7ttel5ba2c0kinsey7d1e0d0ia3et2lbourne7me1orial6n0u2rck0msd7g1h1iami3crosoft7l1ni1t2t0subishi9k1l0b1s2m0a2n1o0bi0le4da2e1i1m1nash3ey2ster5rmon3tgage6scow4to0rcycles9v0ie4p1q1r1s0d2t0n1r2u0seum3ic4v1w1x1y1z2na0b1goya4me2vy3ba2c1e0c1t0bank4flix4work5ustar5w0s2xt0direct7us4f0l2g0o2hk2i0co2ke1on3nja3ssan1y5l1o0kia3rton4w0ruz3tv4p1r0a1w2tt2u1yc2z2obi1server7ffice5kinawa6layan0group9lo3m0ega4ne1g1l0ine5oo2pen3racle3nge4g0anic5igins6saka4tsuka4t2vh3pa0ge2nasonic7ris2s1tners4s1y3y2ccw3e0t2f0izer5g1h0armacy6d1ilips5one2to0graphy6s4ysio5ics1tet2ures6d1n0g1k2oneer5zza4k1l0ace2y0station9umbing5s3m1n0c2ohl2ker3litie5rn2st3r0axi3ess3ime3o0d0uctions8f1gressive8mo2perties3y5tection8u0dential9s1t1ub2w0c2y2qa1pon3uebec3st5racing4dio4e0ad1lestate6tor2y4cipes5d0umbrella9hab3ise0n3t2liance6n0t0als5pair3ort3ublican8st0aurant8view0s5xroth6ich0ardli6oh3l1o1p2o0cks3deo3gers4om3s0vp3u0gby3hr2n2w0e2yukyu6sa0arland6fe0ty4kura4le1on3msclub4ung5ndvik0coromant12ofi4p1rl2s1ve2xo3b0i1s2c0b1haeffler7midt4olarships8ol3ule3warz5ience5ot3d1e0arch3t2cure1ity6ek2lect4ner3rvices6ven3w1x0y3fr2g1h0angrila6rp3ell3ia1ksha5oes2p0ping5uji3w3i0lk2na1gles5te3j1k0i0n2y0pe4l0ing4m0art3ile4n0cf3o0ccer3ial4ftbank4ware6hu2lar2utions7ng1y2y2pa0ce3ort2t3r0l2s1t0ada2ples4r1tebank4farm7c0group6ockholm6rage3e3ream4udio2y3yle4u0cks3pplies3y2ort5rf1gery5zuki5v1watch4iss4x1y0dney4stems6z2tab1ipei4lk2obao4rget4tamotors6r2too4x0i3c0i2d0k2eam2ch0nology8l1masek5nnis4va3f1g1h0d1eater2re6iaa2ckets5enda4ps2res2ol4j0maxx4x2k0maxx5l1m0all4n1o0day3kyo3ols3p1ray3shiba5tal3urs3wn2yota3s3r0ade1ing4ining5vel0ers0insurance16ust3v2t1ube2i1nes3shu4v0s2w1z2ua1bank3s2g1k1nicom3versity8o2ol2ps2s1y1z2va0cations7na1guard7c1e0gas3ntures6risign5mögensberater2ung14sicherung10t2g1i0ajes4deo3g1king4llas4n1p1rgin4sa1ion4va1o3laanderen9n1odka3lvo3te1ing3o2yage5u2wales2mart4ter4ng0gou5tch0es6eather0channel12bcam3er2site5d0ding5ibo2r3f1hoswho6ien2ki2lliamhill9n0dows4e1ners6me2oodside6rk0s2ld3w2s1tc1f3xbox3erox4ihuan4n2xx2yz3yachts4hoo3maxun5ndex5e1odobashi7ga2kohama6u0tube6t1un3za0ppos4ra3ero3ip2m1one3uerich6w2';
+  const encodedTlds = 'aaa1rp3bb0ott3vie4c1le2ogado5udhabi7c0ademy5centure6ountant0s9o1tor4d0s1ult4e0g1ro2tna4f0l1rica5g0akhan5ency5i0g1rbus3force5tel5kdn3l0ibaba4pay4lfinanz6state5y2sace3tom5m0azon4ericanexpress7family11x2fam3ica3sterdam8nalytics7droid5quan4z2o0l2partments8p0le4q0uarelle8r0ab1mco4chi3my2pa2t0e3s0da2ia2sociates9t0hleta5torney7u0ction5di0ble3o3spost5thor3o0s4w0s2x0a2z0ure5ba0by2idu3namex4d1k2r0celona5laycard4s5efoot5gains6seball5ketball8uhaus5yern5b0c1t1va3cg1n2d1e0ats2uty4er2rlin4st0buy5t2f1g1h0arti5i0ble3d1ke2ng0o3o1z2j1lack0friday9ockbuster8g1omberg7ue3m0s1w2n0pparibas9o0ats3ehringer8fa2m1nd2o0k0ing5sch2tik2on4t1utique6x2r0adesco6idgestone9oadway5ker3ther5ussels7s1t1uild0ers6siness6y1zz3v1w1y1z0h3ca0b1fe2l0l1vinklein9m0era3p2non3petown5ital0one8r0avan4ds2e0er0s4s2sa1e1h1ino4t0ering5holic7ba1n1re3c1d1enter4o1rn3f0a1d2g1h0anel2nel4rity4se2t2eap3intai5ristmas6ome4urch5i0priani6rcle4sco3tadel4i0c2y3k1l0aims4eaning6ick2nic1que6othing5ud3ub0med6m1n1o0ach3des3ffee4llege4ogne5m0mbank4unity6pany2re3uter5sec4ndos3struction8ulting7tact3ractors9oking4l1p2rsica5untry4pon0s4rses6pa2r0edit0card4union9icket5own3s1uise0s6u0isinella9v1w1x1y0mru3ou3z2dad1nce3ta1e1ing3sun4y2clk3ds2e0al0er2s3gree4livery5l1oitte5ta3mocrat6ntal2ist5si0gn4v2hl2iamonds6et2gital5rect0ory7scount3ver5h2y2j1k1m1np2o0cs1tor4g1mains5t1wnload7rive4tv2ubai3pont4rban5vag2r2z2earth3t2c0o2deka3u0cation8e1g1mail3erck5nergy4gineer0ing9terprises10pson4quipment8r0icsson6ni3s0q1tate5t1u0rovision8s2vents5xchange6pert3osed4ress5traspace10fage2il1rwinds6th3mily4n0s2rm0ers5shion4t3edex3edback6rrari3ero6i0delity5o2lm2nal1nce1ial7re0stone6mdale6sh0ing5t0ness6j1k1lickr3ghts4r2orist4wers5y2m1o0o0d1tball6rd1ex2sale4um3undation8x2r0ee1senius7l1ogans4ntier7tr2ujitsu5n0d2rniture7tbol5yi3ga0l0lery3o1up4me0s3p1rden4y2b0iz3d0n2e0a1nt0ing5orge5f1g0ee3h1i0ft0s3ves2ing5l0ass3e1obal2o4m0ail3bh2o1x2n1odaddy5ld0point6f2odyear5g0le4p1t1v2p1q1r0ainger5phics5tis4een3ipe3ocery4up4s1t1u0cci3ge2ide2tars5ru3w1y2hair2mburg5ngout5us3bo2dfc0bank7ealth0care8lp1sinki6re1mes5iphop4samitsu7tachi5v2k0t2m1n1ockey4ldings5iday5medepot5goods5s0ense7nda3rse3spital5t0ing5t0els3mail5use3w2r1sbc3t1u0ghes5yatt3undai7ibm2cbc2e1u2d1e0ee3fm2kano4l1m0amat4db2mo0bilien9n0c1dustries8finiti5o2g1k1stitute6urance4e4t0ernational10uit4vestments10o1piranga7q1r0ish4s0maili5t0anbul7t0au2v3jaguar4va3cb2e0ep2tzt3welry6io2ll2m0p2nj2o0bs1urg4t1y2p0morgan6rs3uegos6kaufen5ddi3e0rryhotels6properties14fh2g1h1i0a1ds2m1ndle4tchen5wi3m1n1oeln3matsu5sher5p0mg2n2r0d1ed3uokgroup8w1y0oto4z2la0caixa5mborghini8er3nd0rover6xess5salle5t0ino3robe5w0yer5b1c1ds2ease3clerc5frak4gal2o2xus4gbt3i0dl2fe0insurance9style7ghting6ke2lly3mited4o2ncoln4k2ve1ing5k1lc1p2oan0s3cker3us3l1ndon4tte1o3ve3pl0financial11r1s1t0d0a3u0ndbeck6xe1ury5v1y2ma0drid4if1son4keup4n0agement7go3p1rket0ing3s4riott5shalls7ttel5ba2c0kinsey7d1e0d0ia3et2lbourne7me1orial6n0u2rck0msd7g1h1iami3crosoft7l1ni1t2t0subishi9k1l0b1s2m0a2n1o0bi0le4da2e1i1m1nash3ey2ster5rmon3tgage6scow4to0rcycles9v0ie4p1q1r1s0d2t0n1r2u0seum3ic4v1w1x1y1z2na0b1goya4me2vy3ba2c1e0c1t0bank4flix4work5ustar5w0s2xt0direct7us4f0l2g0o2hk2i0co2ke1on3nja3ssan1y5l1o0kia3rton4w0ruz3tv4p1r0a1w2tt2u1yc2z2obi1server7ffice5kinawa6layan0group9lo3m0ega4ne1g1l0ine5oo2pen3racle3nge4g0anic5igins6saka4tsuka4t2vh3pa0ge2nasonic7ris2s1tners4s1y3y2ccw3e0t2f0izer5g1h0armacy6d1ilips5one2to0graphy6s4ysio5ics1tet2ures6d1n0g1k2oneer5zza4k1l0ace2y0station9umbing5s3m1n0c2ohl2ker3litie5rn2st3r0axi3ess3ime3o0d0uctions8f1gressive8mo2perties3y5tection8u0dential9s1t1ub2w0c2y2qa1pon3uebec3st5racing4dio4e0ad1lestate6tor2y4cipes5d0umbrella9hab3ise0n3t2liance6n0t0als5pair3ort3ublican8st0aurant8view0s5xroth6ich0ardli6oh3l1o1p2o0cks3deo3gers4om3s0vp3u0gby3hr2n2w0e2yukyu6sa0arland6fe0ty4kura4le1on3msclub4ung5ndvik0coromant12ofi4p1rl2s1ve2xo3b0i1s2c0b1haeffler7midt4olarships8ol3ule3warz5ience5ot3d1e0arch3t2cure1ity6ek2lect4ner3rvices6ven3w1x0y3fr2g1h0angrila6rp3ell3ia1ksha5oes2p0ping5uji3w3i0lk2na1gles5te3j1k0i0n2y0pe4l0ing4m0art3ile4n0cf3o0ccer3ial4ftbank4ware6hu2lar2utions7ng1y2y2pa0ce3ort2t3r0l2s1t0ada2ples4r1tebank4farm7c0group6ockholm6rage3e3ream4udio2y3yle4u0cks3pplies3y2ort5rf1gery5zuki5v1watch4iss4x1y0dney4stems6z2tab1ipei4lk2obao4rget4tamotors6r2too4x0i3c0i2d0k2eam2ch0nology8l1masek5nnis4va3f1g1h0d1eater2re6iaa2ckets5enda4ps2res2ol4j0maxx4x2k0maxx5l1m0all4n1o0day3kyo3ols3p1ray3shiba5tal3urs3wn2yota3s3r0ade1ing4ining5vel0ers0insurance16ust3v2t1ube2i1nes3shu4v0s2w1z2ua1bank3s2g1k1nicom3versity8o2ol2ps2s1y1z2va0cations7na1guard7c1e0gas3ntures6risign5mögensberater2ung14sicherung10t2g1i0ajes4deo3g1king4llas4n1p1rgin4sa1ion4va1o3laanderen9n1odka3lvo3te1ing3o2yage5u2wales2mart4ter4ng0gou5tch0es6eather0channel12b0cam3er2site5d0ding5ibo2r3f1hoswho6ien2ki2lliamhill9n0dows4e1ners6me2oodside6rk0s2ld3w2s1tc1f3xbox3erox4ihuan4n2xx2yz3yachts4hoo3maxun5ndex5e1odobashi7ga2kohama6u0tube6t1un3za0ppos4ra3ero3ip2m1one3uerich6w2';
   // Internationalized domain names containing non-ASCII
   const encodedUtlds = 'ελ1υ2бг1ел3дети4ею2католик6ом3мкд2он1сква6онлайн5рг3рус2ф2сайт3рб3укр3қаз3հայ3ישראל5קום3ابوظبي5رامكو5لاردن4بحرين5جزائر5سعودية6عليان5مغرب5مارات5یران5بارت2زار4يتك3ھارت5تونس4سودان3رية5شبكة4عراق2ب2مان4فلسطين6قطر3كاثوليك6وم3مصر2ليسيا5وريتانيا7قع4همراه5پاکستان7ڀارت4कॉम3नेट3भारत0म्3ोत5संगठन5বাংলা5ভারত2ৰত4ਭਾਰਤ4ભારત4ଭାରତ4இந்தியா6லங்கை6சிங்கப்பூர்11భారత్5ಭಾರತ4ഭാരതം5ලංකා4คอม3ไทย3ລາວ3გე2みんな3アマゾン4クラウド4グーグル4コム2ストア3セール3ファッション6ポイント4世界2中信1国1國1文网3亚马逊3企业2佛山2信息2健康2八卦2公司1益2台湾1灣2商城1店1标2嘉里0大酒店5在线2大拿2天主教3娱乐2家電2广东2微博2慈善2我爱你3手机2招聘2政务1府2新加坡2闻2时尚2書籍2机构2淡马锡3游戏2澳門2点看2移动2组织机构4网址1店1站1络2联通2谷歌2购物2通販2集团2電訊盈科4飞利浦3食品2餐厅2香格里拉3港2닷넷1컴2삼성2한국2';
 
@@ -61317,8 +61796,20 @@ img.ProseMirror-separator {
 
   // Note that these two Unicode ones expand into a really big one with Babel
   const ASCII_LETTER = /[a-z]/;
-  const LETTER = /\p{L}/u; // Any Unicode character with letter data type
-  const EMOJI = /\p{Emoji}/u; // Any Unicode emoji character
+  // `\p{}` property escapes need ICU, which some embedded JS runtimes ship
+  // without (e.g. NativeScript's V8). The literal form throws a SyntaxError
+  // at parse time — before any user code can catch it — so build them
+  // dynamically and keep ASCII-range fallbacks for engines without Unicode
+  // property escapes.
+  let LETTER = /[a-z]/i; // Any Unicode character with letter data type
+  let EMOJI = /[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}]|\u{FE0F}/u; // Any Unicode emoji character
+
+  try {
+    LETTER = new RegExp('\\p{L}', 'u');
+    EMOJI = new RegExp('\\p{Emoji}', 'u');
+  } catch {
+    // use ASCII fallbacks
+  }
   const DIGIT = /\d/;
   const SPACE = /\s/;
 
@@ -61782,6 +62273,7 @@ img.ProseMirror-separator {
    * 	className?: Opt<string>,
    * 	attributes?: OptObj<({ [attr: string]: any })>,
    *  ignoreTags?: string[],
+   *  ignoreClasses?: string[],
    * 	render?: OptFn<((ir: IntermediateRepresentation) => any)>
    * }} Opts
    */
@@ -61803,6 +62295,7 @@ img.ProseMirror-separator {
     className: null,
     attributes: null,
     ignoreTags: [],
+    ignoreClasses: [],
     render: null
   };
 
@@ -61834,6 +62327,7 @@ img.ProseMirror-separator {
       this.defaultRender = defaultRender;
     }
     this.ignoreTags = uppercaseIgnoredTags;
+    this.ignoreClasses = o.ignoreClasses.slice();
   }
   Options.prototype = {
     o: defaults,
@@ -61841,6 +62335,28 @@ img.ProseMirror-separator {
      * @type string[]
      */
     ignoreTags: [],
+    /**
+     * @type string[]
+     */
+    ignoreClasses: [],
+    /**
+     * Returns whether a whitespace-separated class attribute contains an
+     * ignored class name.
+     * @param {unknown} classNames
+     * @returns {boolean}
+     */
+    isIgnoredClass(classNames) {
+      if (typeof classNames !== 'string' || this.ignoreClasses.length === 0) {
+        return false;
+      }
+      const classes = classNames.split(/\s+/);
+      for (let i = 0; i < classes.length; i++) {
+        if (this.ignoreClasses.indexOf(classes[i]) >= 0) {
+          return true;
+        }
+      }
+      return false;
+    },
     /**
      * @param {IntermediateRepresentation} ir
      * @returns {any}
@@ -62261,6 +62777,15 @@ img.ProseMirror-separator {
     tt(DomainDotTld, SLASH, Url$1);
     tt(DomainDotTldColonPort, SLASH, Url$1);
 
+    // A query string or fragment may also follow the domain (or port) directly,
+    // without a path slash (e.g. `example.com?q=1`, `example.com#frag`). Mirror
+    // how the `Url` state treats these tokens: `?` is non-accepting (a trailing
+    // `?` is trimmed), `#` is accepting.
+    tt(DomainDotTld, QUERY, UrlNonaccept);
+    tt(DomainDotTld, POUND, Url$1);
+    tt(DomainDotTldColonPort, QUERY, UrlNonaccept);
+    tt(DomainDotTldColonPort, POUND, Url$1);
+
     // Note that domains that begin with schemes are treated slighly differently
     const SchemeColon = tt(Scheme, COLON); // e.g., 'mailto:'
     const SlashSchemeColon = tt(SlashScheme, COLON); // e.g., 'http:'
@@ -62353,6 +62878,18 @@ img.ProseMirror-separator {
     let cursor = 0;
     let multis = [];
     let textTokens = [];
+
+    // Memo of parser states that are known not to lead to any accepting state
+    // when reached at a given cursor position. dead[i] is a Set of states that,
+    // once reached right before tokens[i], can never reach another accepting
+    // state. Because the parser is deterministic, a run that reaches one of
+    // these (state, cursor) pairs can stop there with the same result as
+    // continuing. Without this, inputs where every token can extend a
+    // potential link that never completes (e.g., 'a.a.a.a.…') make each
+    // failed attempt rescan to the end of the input, which is quadratic.
+    // See https://github.com/Hypercontext/linkifyjs/issues/568
+    /** @type {Array<Set<State<MultiToken>> | undefined>} */
+    const dead = [];
     while (cursor < len) {
       let state = start;
       let secondState = null;
@@ -62360,6 +62897,10 @@ img.ProseMirror-separator {
       let multiLength = 0;
       let latestAccepting = null;
       let sinceAccepts = -1;
+      // States reached since the latest accepting state (or since the start
+      // of this attempt), in order. visited[k] is the state reached right
+      // before tokens[cursor - visited.length + k + 1]
+      let visited = [];
       while (cursor < len && !(secondState = state.go(tokens[cursor].t))) {
         // Starting tokens with nowhere to jump to.
         // Consider these to be just plain text
@@ -62369,16 +62910,31 @@ img.ProseMirror-separator {
         // Get the next state
         secondState = null;
         state = nextState;
+        cursor++;
+        multiLength++;
 
         // Keep track of the latest accepting state
         if (state.accepts()) {
           sinceAccepts = 0;
           latestAccepting = state;
-        } else if (sinceAccepts >= 0) {
-          sinceAccepts++;
+          visited = [];
+        } else {
+          if (sinceAccepts >= 0) {
+            sinceAccepts++;
+          }
+          visited.push(state);
+          if (dead[cursor] && dead[cursor].has(state)) {
+            // Already known that no accepting state is reachable from here
+            break;
+          }
         }
-        cursor++;
-        multiLength++;
+      }
+
+      // None of the states visited since the latest accepting state lead to
+      // another accepting state; remember them so later attempts that reach
+      // the same state at the same position can stop early.
+      for (let k = 0, pos = cursor - visited.length + 1; k < visited.length; k++, pos++) {
+        (dead[pos] || (dead[pos] = new Set())).add(visited[k]);
       }
       if (sinceAccepts < 0) {
         // No accepting state was found, part of a regular text token add
@@ -63501,7 +64057,29 @@ img.ProseMirror-separator {
   	}
   }
   //#endregion
+  //#region src/item/ensureLeadingParagraph.ts
+  function ensureLeadingParagraph(content) {
+  	if (!content[0] || content[0].type === "paragraph") return content;
+  	return [{
+  		type: "paragraph",
+  		content: []
+  	}, ...content];
+  }
+  //#endregion
+  //#region src/item/hasEmptyLeadingParagraph.ts
+  function hasEmptyLeadingParagraph(node) {
+  	var _node$content, _first$content;
+  	const first = (_node$content = node.content) === null || _node$content === void 0 ? void 0 : _node$content[0];
+  	return (first === null || first === void 0 ? void 0 : first.type) === "paragraph" && !((_first$content = first.content) === null || _first$content === void 0 ? void 0 : _first$content.length);
+  }
+  //#endregion
   //#region src/item/list-item.ts
+  const EMPTY_ITEM_TEXT = "&nbsp;";
+  const TOP_LEVEL = 1;
+  const isNested = (ctx) => {
+  	var _ctx$level;
+  	return ((_ctx$level = ctx === null || ctx === void 0 ? void 0 : ctx.level) !== null && _ctx$level !== void 0 ? _ctx$level : TOP_LEVEL) > TOP_LEVEL;
+  };
   function isSameLineOrderedListToken(token) {
   	var _token$tokens, _token$tokens2;
   	const nestedToken = (_token$tokens = token.tokens) === null || _token$tokens === void 0 ? void 0 : _token$tokens[0];
@@ -63554,20 +64132,28 @@ img.ProseMirror-separator {
   					content: parseSameLineOrderedListText(token.text || "", helpers)
   				}]
   			};
-  			if (token.tokens.some((t) => t.type === "paragraph")) content = parseBlockChildren(token.tokens);
-  			else {
-  				const firstToken = token.tokens[0];
-  				if (firstToken && firstToken.type === "text" && firstToken.tokens && firstToken.tokens.length > 0) {
-  					content = [{
+  			const [firstToken, ...remainingTokens] = token.tokens;
+  			if (firstToken.type === "heading") {
+  				var _firstToken$tokens;
+  				return {
+  					type: "listItem",
+  					content: [{
   						type: "paragraph",
-  						content: helpers.parseInline(firstToken.tokens)
-  					}];
-  					if (token.tokens.length > 1) {
-  						const additionalContent = parseBlockChildren(token.tokens.slice(1));
-  						content.push(...additionalContent);
-  					}
-  				} else content = parseBlockChildren(token.tokens);
+  						content: helpers.parseInline((_firstToken$tokens = firstToken.tokens) !== null && _firstToken$tokens !== void 0 ? _firstToken$tokens : [])
+  					}, ...remainingTokens.length > 0 ? parseBlockChildren(remainingTokens) : []]
+  				};
   			}
+  			if (token.tokens.some((t) => t.type === "paragraph")) content = parseBlockChildren(token.tokens);
+  			else if (firstToken.type === "text" && firstToken.tokens && firstToken.tokens.length > 0) {
+  				content = [{
+  					type: "paragraph",
+  					content: helpers.parseInline(firstToken.tokens)
+  				}];
+  				if (token.tokens.length > 1) {
+  					const additionalContent = parseBlockChildren(token.tokens.slice(1));
+  					content.push(...additionalContent);
+  				}
+  			} else content = parseBlockChildren(token.tokens);
   		}
   		if (content.length === 0) content = [{
   			type: "paragraph",
@@ -63575,11 +64161,11 @@ img.ProseMirror-separator {
   		}];
   		return {
   			type: "listItem",
-  			content
+  			content: ensureLeadingParagraph(content)
   		};
   	},
   	renderMarkdown: (node, h, ctx) => {
-  		return renderNestedMarkdownContent(node, h, (context) => {
+  		const getPrefix = (context) => {
   			if (context.parentType === "bulletList") return "- ";
   			if (context.parentType === "orderedList") {
   				var _context$meta, _context$meta2;
@@ -63587,7 +64173,11 @@ img.ProseMirror-separator {
   				return getListMarker((_context$meta2 = context.meta) === null || _context$meta2 === void 0 || (_context$meta2 = _context$meta2.parentAttrs) === null || _context$meta2 === void 0 ? void 0 : _context$meta2.type, start - 1 + (context.index || 0), ". ");
   			}
   			return "- ";
-  		}, ctx, { alignNestedToPrefix: (ctx === null || ctx === void 0 ? void 0 : ctx.parentType) === "orderedList" });
+  		};
+  		const output = renderNestedMarkdownContent(node, h, getPrefix, ctx, { alignNestedToPrefix: (ctx === null || ctx === void 0 ? void 0 : ctx.parentType) === "orderedList" });
+  		if (!hasEmptyLeadingParagraph(node) || !isNested(ctx)) return output;
+  		const prefix = getPrefix(ctx);
+  		return `${prefix}${EMPTY_ITEM_TEXT}${output.slice(prefix.length)}`;
   	},
   	addExtensions() {
   		return [createBranchingListDeleteKeymap(this.name, [this.options.bulletListTypeName, this.options.orderedListTypeName])];
@@ -63658,10 +64248,15 @@ img.ProseMirror-separator {
   		const lastItem = listDescendants.at(-1);
   		if (!lastItem) return false;
   		const $lastItemPos = editor.state.doc.resolve($listPos.start() + lastItem.pos + 1);
-  		return editor.chain().cut({
-  			from: $anchor.start() - 1,
-  			to: $anchor.end() + 1
-  		}, $lastItemPos.end()).joinForward().run();
+  		return editor.chain().command(({ tr }) => {
+  			const target = $lastItemPos.end();
+  			tr.delete($anchor.before(), $anchor.after()).insert(target, $anchor.parent);
+  			tr.setSelection(TextSelection.create(tr.doc, target + 1));
+  			return true;
+  		}).command(({ state, dispatch }) => {
+  			joinTextblockBackward(state, dispatch);
+  			return true;
+  		}).run();
   	}
   	if (!isNodeActive(editor.state, name)) return false;
   	if (!isAtStartOfNode(editor.state)) return false;
@@ -63693,11 +64288,9 @@ img.ProseMirror-separator {
   const handleDelete = (editor, name) => {
   	if (!isNodeActive(editor.state, name)) return false;
   	if (!isAtEndOfNode(editor.state, name)) return false;
-  	const { selection } = editor.state;
-  	const { $from, $to } = selection;
-  	if (!selection.empty && $from.sameParent($to)) return false;
+  	if (!editor.state.selection.empty) return false;
   	if (nextListIsDeeper(name, editor.state)) return editor.chain().focus(editor.state.selection.from + 4).lift(name).joinBackward().run();
-  	if (nextListIsHigher(name, editor.state)) return editor.chain().joinForward().joinBackward().run();
+  	if (nextListIsHigher(name, editor.state)) return editor.commands.command(({ state, dispatch }) => joinTextblockForward(state, dispatch));
   	return editor.commands.joinItemForward();
   };
   //#endregion
@@ -64349,7 +64942,7 @@ img.ProseMirror-separator {
   	renderMarkdown: (node, h) => {
   		var _node$attrs;
   		const prefix = `- [${((_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.checked) ? "x" : " "}] `;
-  		return renderNestedMarkdownContent(node, h, prefix);
+  		return renderNestedMarkdownContent(node, h, prefix, void 0, { indentMainContent: true });
   	},
   	addExtensions() {
   		if (!this.options.nested) return [];
@@ -66052,7 +66645,7 @@ img.ProseMirror-separator {
   	const match = Array.from(text.matchAll(regexp)).pop();
   	if (!match || match.input === void 0 || match.index === void 0) return null;
   	const matchPrefix = match.input.slice(Math.max(0, match.index - 1), match.index);
-  	const matchPrefixIsAllowed = new RegExp(`^[${allowedPrefixes === null || allowedPrefixes === void 0 ? void 0 : allowedPrefixes.join("")}\0]?$`).test(matchPrefix);
+  	const matchPrefixIsAllowed = new RegExp(`^[${allowedPrefixes === null || allowedPrefixes === void 0 ? void 0 : allowedPrefixes.map(escapeForRegEx).join("")}\0]?$`).test(matchPrefix);
   	if (allowedPrefixes !== null && !matchPrefixIsAllowed) return null;
   	const from = textFrom + match.index;
   	let to = from + match[0].length;
@@ -69584,8 +70177,8 @@ img.ProseMirror-separator {
     </template>
 `;
 
-  // Based on: https://github.com/microsoft/fast/blob/%40microsoft/fast-foundation_v2.49.5/packages/web-components/fast-foundation/src/select/select.form-associated.ts
   /* eslint-disable max-classes-per-file */
+  // Based on: https://github.com/microsoft/fast/blob/%40microsoft/fast-foundation_v2.49.5/packages/web-components/fast-foundation/src/select/select.form-associated.ts
   // eslint-disable-next-line jsdoc/require-jsdoc
   let Select$1 = class Select extends ListboxElement {
   };
@@ -77047,6 +77640,84 @@ focus outline in that case.
     );
   };
 
+  function classifyScrollEvent({
+    offset,
+    isScrolling,
+    elementMax,
+    holdOffset,
+    scrollOffset,
+    pendingWrite,
+    clampedMaxAtWrite
+  }) {
+    var _a;
+    if (isScrolling && pendingWrite === null && offset === scrollOffset) {
+      return "spurious";
+    }
+    if (pendingWrite !== null && Math.abs(offset - pendingWrite.target) < 1.5) {
+      return "readBack";
+    }
+    if (pendingWrite !== null && !pendingWrite.smooth && elementMax !== null && pendingWrite.target > elementMax + holdOffset + 0.5 && Math.abs(offset - (elementMax + holdOffset)) < 1.5) {
+      return "clampedReadBack";
+    }
+    if (pendingWrite !== null && !pendingWrite.smooth && ((_a = pendingWrite.lowMaxes) == null ? void 0 : _a.some((max) => Math.abs(offset - max) < 1.5))) {
+      return "clampedReadBack";
+    }
+    if (clampedMaxAtWrite !== null && Math.abs(offset - clampedMaxAtWrite) < 1.5) {
+      return "clampedEcho";
+    }
+    return "external";
+  }
+  const isAnimating = (phase) => phase === "smooth" || phase === "smoothFinishing";
+  function externalRetiresCommand({
+    kind,
+    offset,
+    command,
+    target
+  }) {
+    return kind !== "spurious" && kind !== "readBack" && // Our own write, clamped (`clampedReadBack`, #1310): the command is not
+    // retired by it, and reconcile retargets below the new max.
+    kind !== "clampedReadBack" && (command == null ? void 0 : command.index) != null && // Nothing has been written for a command waiting for the tail; these
+    // are the fling's events.
+    command.phase !== "queued" && // A non-smooth write lands at once, so any other scroll event is the
+    // user's, even before reconcile saw the target reached (the target may
+    // keep moving, or iOS ignored the write under a finger). A write the
+    // browser clamped because the sizer hasn't grown yet reads back at the
+    // max, which is also where the fresh target clamps, so the check below
+    // keeps it reconciling (#1294). While a smooth scroll's animation may
+    // still report, its events look like a user's, so it yields only once it
+    // has landed.
+    !isAnimating(command.phase) && !approxEqual(offset, command.lastTargetOffset) && !approxEqual(offset, target()) && // A compensation write's clamped echo (#1258) keeps the command. The
+    // order is deliberate, not tidiness: this clause stays after `target()`
+    // (and `clampedReadBack` before it) because `target()` can rebuild the
+    // measurements, so it must run for exactly the events it always did.
+    kind !== "clampedEcho";
+  }
+  const FLING_WINDOW_MS = 40;
+  function flingSpedUp(samples) {
+    const last = samples[samples.length - 1];
+    if (last === void 0) return false;
+    let j = samples.length - 2;
+    while (j >= 0 && last.t - samples[j].t < FLING_WINDOW_MS) j--;
+    if (j < 0) return false;
+    const mid = samples[j];
+    let k = j - 1;
+    while (k >= 0 && mid.t - samples[k].t < FLING_WINDOW_MS) k--;
+    if (k < 0) return false;
+    const first = samples[k];
+    const recent = (last.offset - mid.offset) / (last.t - mid.t);
+    const before = (mid.offset - first.offset) / (mid.t - first.t);
+    return recent * before >= 0 && Math.abs(recent) >= 2 * Math.abs(before) && Math.abs(recent) - Math.abs(before) >= 0.8;
+  }
+  function flingCaught(samples) {
+    const last = samples[samples.length - 1];
+    if (last === void 0) return false;
+    let j = samples.length - 2;
+    while (j >= 0 && last.t - samples[j].t < FLING_WINDOW_MS) j--;
+    if (j < 0) return false;
+    const from = samples[j];
+    return Math.abs(last.offset - from.offset) / (last.t - from.t) >= 0.05;
+  }
+
   let _isIOSResult;
   const isIOSWebKit = () => {
     if (_isIOSResult !== void 0) return _isIOSResult;
@@ -77055,14 +77726,143 @@ focus outline in that case.
     const mtp = navigator.maxTouchPoints;
     return _isIOSResult = navigator.platform === "MacIntel" && mtp !== void 0 && mtp > 0;
   };
+  let _iosMomentumOverridesWritesResult;
+  const iosMomentumOverridesWrites = () => {
+    if (_iosMomentumOverridesWritesResult !== void 0) {
+      return _iosMomentumOverridesWritesResult;
+    }
+    return _iosMomentumOverridesWritesResult = isIOSWebKit() && typeof CSS !== "undefined" && typeof CSS.supports === "function" && CSS.supports("overflow-anchor: auto");
+  };
+  const momentumOverridesWrites = () => !isIOSWebKit() || iosMomentumOverridesWrites();
+  const touchListenerOptions = {
+    capture: true,
+    passive: true
+  };
+  class IosGesture {
+    constructor(host) {
+      this.host = host;
+      this._touch = null;
+      this.inMotion = () => this._touch !== null && this._touch.phase !== "lateFling";
+      this.dragging = () => {
+        var _a;
+        return ((_a = this._touch) == null ? void 0 : _a.phase) === "down" && this._touch.moved;
+      };
+      this.tail = () => {
+        var _a;
+        return ((_a = this._touch) == null ? void 0 : _a.phase) === "tail" ? this._touch.moved ? "fling" : "tap" : null;
+      };
+      this.onScroll = ({
+        isScrolling,
+        ownReadBack,
+        moved,
+        external
+      }) => {
+        var _a, _b, _c;
+        if (isScrolling && ((_a = this._touch) == null ? void 0 : _a.phase) === "tail") {
+          this._openTail(this._touch.moved || !ownReadBack, false);
+        } else if (((_b = this._touch) == null ? void 0 : _b.phase) === "lateFling") {
+          if (this.host.now() > this._touch.until) {
+            this._touch = null;
+          } else if (external && isScrolling && moved) {
+            this._openTail(true, false);
+          }
+        }
+        if (!ownReadBack && isScrolling && moved && ((_c = this._touch) == null ? void 0 : _c.phase) === "down") {
+          this._touch.moved = true;
+          return true;
+        }
+        return false;
+      };
+      this.touchStart = () => {
+        this.end();
+        this._touch = { phase: "down", moved: false };
+      };
+      this.touchEnd = () => {
+        var _a;
+        const moved = ((_a = this._touch) == null ? void 0 : _a.phase) === "down" && this._touch.moved;
+        this.end();
+        this._openTail(moved, moved);
+      };
+      this.end = () => {
+        var _a;
+        const win = this.host.getWindow();
+        if (((_a = this._touch) == null ? void 0 : _a.phase) === "tail" && win != null) {
+          win.clearTimeout(this._touch.timerId);
+        }
+        this._touch = null;
+      };
+      this.listen = (target) => {
+        const onTouchStart = () => this.touchStart();
+        const onTouchEnd = () => this.touchEnd();
+        target.addEventListener("touchstart", onTouchStart, touchListenerOptions);
+        target.addEventListener("touchend", onTouchEnd, touchListenerOptions);
+        target.addEventListener("touchcancel", onTouchEnd, touchListenerOptions);
+        return () => {
+          target.removeEventListener(
+            "touchstart",
+            onTouchStart,
+            touchListenerOptions
+          );
+          target.removeEventListener("touchend", onTouchEnd, touchListenerOptions);
+          target.removeEventListener(
+            "touchcancel",
+            onTouchEnd,
+            touchListenerOptions
+          );
+          this.end();
+        };
+      };
+      this._openTail = (moved, awaitingFling) => {
+        const win = this.host.getWindow();
+        if (win == null) return;
+        this.end();
+        const tail = {
+          phase: "tail",
+          moved,
+          awaitingFling,
+          // Only fires while this tail is current: `end` clears it otherwise.
+          timerId: win.setTimeout(() => {
+            if (this.host.tailStillMoving()) {
+              this._openTail(tail.moved, tail.awaitingFling);
+              return;
+            }
+            this._touch = tail.awaitingFling ? { phase: "lateFling", until: this.host.now() + 1e3 } : null;
+            this.host.onTailClosed();
+          }, 150)
+        };
+        this._touch = tail;
+      };
+    }
+    get touch() {
+      return this._touch;
+    }
+  }
+
   const getRect = (element) => {
-    const { offsetWidth, offsetHeight } = element;
-    return { width: offsetWidth, height: offsetHeight };
+    const { clientWidth, clientHeight } = element;
+    return { width: clientWidth, height: clientHeight };
+  };
+  const createFrameQueue = (targetWindow) => {
+    const ids = /* @__PURE__ */ new Set();
+    return {
+      schedule: (fn) => {
+        const id = targetWindow.requestAnimationFrame(() => {
+          ids.delete(id);
+          fn();
+        });
+        ids.add(id);
+      },
+      cancel: () => {
+        ids.forEach((id) => targetWindow.cancelAnimationFrame(id));
+        ids.clear();
+      }
+    };
   };
   const defaultKeyExtractor = (index) => index;
   const defaultRangeExtractor = (range) => {
-    const start = Math.max(range.startIndex - range.overscan, 0);
-    const end = Math.min(range.endIndex + range.overscan, range.count - 1);
+    const overscan = range.overscan * Math.max(range.lanes ?? 1, 1);
+    const start = Math.max(range.startIndex - overscan, 0);
+    const end = Math.min(range.endIndex + overscan, range.count - 1);
     const len = end - start + 1;
     const arr = new Array(len);
     for (let i = 0; i < len; i++) {
@@ -77088,23 +77888,17 @@ focus outline in that case.
       return () => {
       };
     }
-    const observer = new targetWindow.ResizeObserver((entries) => {
+    const frames = createFrameQueue(targetWindow);
+    const observer = new targetWindow.ResizeObserver(() => {
       const run = () => {
-        const entry = entries[0];
-        if (entry == null ? void 0 : entry.borderBoxSize) {
-          const box = entry.borderBoxSize[0];
-          if (box) {
-            handler({ width: box.inlineSize, height: box.blockSize });
-            return;
-          }
-        }
         handler(getRect(element));
       };
-      instance.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(run) : run();
+      instance.options.useAnimationFrameWithResizeObserver ? frames.schedule(run) : run();
     });
-    observer.observe(element, { box: "border-box" });
+    observer.observe(element, { box: "content-box" });
     return () => {
       observer.unobserve(element);
+      frames.cancel();
     };
   };
   const addEventListenerOptions = {
@@ -77186,6 +77980,8 @@ focus outline in that case.
     });
   };
   const elementScroll = scrollWithAdjustments;
+  const initialScrollPhase = (behavior, atTarget) => behavior === "smooth" ? atTarget ? "smoothLanded" : "smooth" : "instant";
+  const isSmoothScroll = (state) => (state == null ? void 0 : state.phase) === "smooth" || (state == null ? void 0 : state.phase) === "smoothLanded";
   function isAppendWithTrim(prevCount, nextCount, getPreviousKey, getNextKey) {
     if (nextCount === 0) return false;
     const firstKey = getNextKey(0);
@@ -77227,67 +78023,144 @@ focus outline in that case.
       this.scrollRect = null;
       this.scrollOffset = null;
       this.scrollDirection = null;
-      this.scrollAdjustments = 0;
-      this._iosDeferredAdjustment = 0;
-      this._iosTouching = false;
-      this._iosJustTouchEnded = false;
-      this._iosTouchEndTimerId = null;
-      this._intendedScrollOffset = null;
+      this._holdOffset = 0;
+      this._reportedOverscroll = false;
+      this._iosGesture = new IosGesture({
+        getWindow: () => this.targetWindow,
+        now: () => this.now(),
+        // The end of a fling can move less than a pixel per scroll event, so
+        // events can stop for 150ms while the fling is still running (seen on
+        // an iPhone, 27.0.1). A command waiting for it would then be written
+        // into the fling and overridden. The element having moved since the
+        // last event means it has not ended: wait again. Not while our own
+        // write has yet to report: that moved it.
+        tailStillMoving: () => {
+          const state = this.scrollState;
+          if ((state == null ? void 0 : state.phase) !== "queued" || this.pendingWrite !== null) {
+            return false;
+          }
+          const now = this._readElementOffset();
+          if (now === null || this._lastElementOffset === null || Math.abs(now - this._lastElementOffset) < 1) {
+            return false;
+          }
+          this._lastElementOffset = now;
+          state.samples = [...state.samples ?? [], { t: this.now(), offset: now }];
+          return true;
+        },
+        onTailClosed: () => {
+          const state = this.scrollState;
+          if ((state == null ? void 0 : state.phase) === "queued" && flingCaught(state.samples ?? [])) {
+            this.scrollState = null;
+          }
+          this._flushHoldIfReady(true);
+          this._writeAwaitingCommand();
+          this._retryClampedAdjustment();
+        }
+      });
+      this._lastElementOffset = null;
+      this.pendingWrite = null;
       this._clampedAdjustment = null;
       this.elementsCache = /* @__PURE__ */ new Map();
+      this._resizeBatch = null;
       this.now = () => {
         var _a, _b, _c;
         return ((_c = (_b = (_a = this.targetWindow) == null ? void 0 : _a.performance) == null ? void 0 : _b.now) == null ? void 0 : _c.call(_b)) ?? Date.now();
       };
       this.observer = /* @__PURE__ */ (() => {
         let _ro = null;
+        let _frames = null;
+        let delivering = false;
+        let observeQueued = false;
+        const pendingObservations = /* @__PURE__ */ new Set();
         const get = () => {
           if (_ro) {
             return _ro;
           }
-          if (!this.targetWindow || !this.targetWindow.ResizeObserver) {
+          const targetWindow = this.targetWindow;
+          if (!targetWindow || !targetWindow.ResizeObserver) {
             return null;
           }
-          return _ro = new this.targetWindow.ResizeObserver((entries) => {
-            entries.forEach((entry) => {
-              const run = () => {
-                const node = entry.target;
-                const index = this.indexFromElement(node);
-                if (!node.isConnected) {
-                  this.observer.unobserve(node);
-                  for (const [cacheKey, cachedNode] of this.elementsCache) {
-                    if (cachedNode === node) {
-                      this.elementsCache.delete(cacheKey);
-                      break;
-                    }
-                  }
-                  return;
-                }
-                if (!this.isIndexInRange(index)) return;
-                if (this.shouldMeasureDuringScroll(index)) {
-                  this.resizeItem(
-                    index,
-                    this.options.measureElement(node, entry, this)
-                  );
+          const frames = _frames = createFrameQueue(targetWindow);
+          return _ro = new targetWindow.ResizeObserver((entries) => {
+            const run = () => {
+              const batch = { sync: false };
+              this._resizeBatch = batch;
+              try {
+                entries.forEach(measureEntry);
+              } finally {
+                this._resizeBatch = null;
+                if (batch.notify) {
+                  this.notify(batch.sync);
+                  this._noteClampMax();
+                  this._flushHoldIfReady(true);
+                  this._retryClampedAdjustment();
+                  this.measureElement(null);
                 }
-              };
-              this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(run) : run();
-            });
+              }
+            };
+            if (this.options.useAnimationFrameWithResizeObserver) {
+              frames.schedule(run);
+            } else {
+              delivering = true;
+              try {
+                run();
+              } finally {
+                delivering = false;
+              }
+            }
           });
         };
+        const measureEntry = (entry) => {
+          const node = entry.target;
+          const index = this.indexFromElement(node);
+          if (!node.isConnected) {
+            this.observer.unobserve(node);
+            for (const [cacheKey, cachedNode] of this.elementsCache) {
+              if (cachedNode === node) {
+                this.elementsCache.delete(cacheKey);
+                break;
+              }
+            }
+            return;
+          }
+          if (!this.isIndexInRange(index)) return;
+          if (this.shouldMeasureDuringScroll(index)) {
+            this.resizeItem(index, this.options.measureElement(node, entry, this));
+          }
+        };
         return {
           disconnect: () => {
             var _a;
             (_a = get()) == null ? void 0 : _a.disconnect();
+            _frames == null ? void 0 : _frames.cancel();
+            pendingObservations.clear();
+            observeQueued = false;
             _ro = null;
+            _frames = null;
           },
           observe: (target) => {
-            var _a;
-            return (_a = get()) == null ? void 0 : _a.observe(target, { box: "border-box" });
+            const observer = get();
+            if (!observer) return;
+            if (!delivering) {
+              observer.observe(target, { box: "border-box" });
+              return;
+            }
+            pendingObservations.add(target);
+            if (!observeQueued) {
+              observeQueued = true;
+              _frames == null ? void 0 : _frames.schedule(() => {
+                observeQueued = false;
+                pendingObservations.forEach((node) => {
+                  if (node.isConnected) _ro == null ? void 0 : _ro.observe(node, { box: "border-box" });
+                });
+                pendingObservations.clear();
+              });
+            }
           },
           unobserve: (target) => {
             var _a;
-            return (_a = get()) == null ? void 0 : _a.unobserve(target);
+            pendingObservations.delete(target);
+            (_a = get()) == null ? void 0 : _a.unobserve(target);
           }
         };
       })();
@@ -77367,9 +78240,8 @@ focus outline in that case.
           this.pendingMin = 0;
           this.itemSizeCacheVersion++;
         }
-        let anchorResolved = false;
-        let anchorDelta = 0;
-        if (anchor && this.scrollOffset !== null) {
+        let anchorDelta = null;
+        if (anchor && this.scrollOffset !== null && !this._awaitingCommandReadBack()) {
           const [anchorKey, anchorOffset] = anchor;
           const newMeasurements = this.getMeasurements();
           const { count, getItemKey } = this.options;
@@ -77384,18 +78256,19 @@ focus outline in that case.
               if (!followOnAppend && newOffset !== this.scrollOffset) {
                 anchorDelta = newOffset - this.scrollOffset;
                 this.scrollOffset = newOffset;
-                anchorResolved = true;
               }
             }
           }
         }
-        if (anchorResolved || followOnAppend) {
-          this.pendingScrollAnchor = [
-            anchorResolved ? anchor[0] : null,
-            anchorResolved ? anchor[1] : 0,
-            followOnAppend,
-            anchorDelta
-          ];
+        if (followOnAppend) {
+          this.pendingScrollAnchor = { kind: "follow", behavior: followOnAppend };
+        } else if (anchorDelta !== null) {
+          if (this._canWriteScroll()) {
+            this.pendingScrollAnchor = { kind: "anchor", delta: anchorDelta };
+          } else {
+            this._holdOffset += anchorDelta;
+            this._followOffsetTarget(anchorDelta);
+          }
         }
       };
       this.notify = (sync) => {
@@ -77425,6 +78298,7 @@ focus outline in that case.
         }
       );
       this.cleanup = () => {
+        var _a;
         this.unsubs.filter(Boolean).forEach((d) => d());
         this.unsubs = [];
         this.observer.disconnect();
@@ -77433,12 +78307,14 @@ focus outline in that case.
           this.rafId = null;
         }
         this.scrollState = null;
+        (_a = this._momentumStop) == null ? void 0 : _a.restore();
+        this._momentumStop = null;
         this.isScrolling = false;
         this.scrollDirection = null;
-        this._iosDeferredAdjustment = 0;
-        this._iosTouching = false;
-        this._iosJustTouchEnded = false;
+        this._holdOffset = 0;
+        this._reportedOverscroll = false;
         this._clampedAdjustment = null;
+        this.pendingWrite = null;
         this.scrollElement = null;
         this.targetWindow = null;
       };
@@ -77448,7 +78324,7 @@ focus outline in that case.
         };
       };
       this._willUpdate = () => {
-        var _a, _b;
+        var _a;
         const scrollElement = this.options.enabled ? this.options.getScrollElement() : null;
         if (this.scrollElement !== scrollElement) {
           this.cleanup();
@@ -77473,22 +78349,71 @@ focus outline in that case.
           );
           this.unsubs.push(
             this.options.observeElementOffset(this, (offset, isScrolling) => {
-              if (isScrolling && this._intendedScrollOffset === null && offset === this.scrollOffset) {
-                return;
-              }
-              if (this._intendedScrollOffset !== null && Math.abs(offset - this._intendedScrollOffset) < 1.5) {
-                offset = this._intendedScrollOffset;
+              var _a2, _b, _c, _d;
+              const elementMax = isScrolling ? this._elementMaxScrollOffset() : null;
+              const wasOverscrolled = this._reportedOverscroll;
+              this._reportedOverscroll = offset < 0 || elementMax !== null && offset > elementMax + 1;
+              const elementOffset = offset;
+              this._lastElementOffset = elementOffset;
+              offset = this._toLayoutOffset(offset);
+              const kind = this._classifyScrollEvent(
+                offset,
+                isScrolling,
+                elementMax
+              );
+              if (kind === "spurious") return;
+              if (kind === "readBack") {
+                offset = this.pendingWrite.target;
+              } else if (kind === "clampedReadBack" && ((_a2 = this.scrollState) == null ? void 0 : _a2.index) != null && // Not `elementMax`: an adapter can report the read-back at rest.
+              offset < this.getMaxScrollOffset() - 1.5) {
+                this.scrollState.lastTargetOffset = offset;
+              } else if (externalRetiresCommand({
+                kind,
+                offset,
+                command: this.scrollState,
+                target: () => this.getScrollStateTarget(this.scrollState)
+              })) {
+                this.scrollState = null;
               }
-              this._intendedScrollOffset = null;
+              this.pendingWrite = null;
               if (this._clampedAdjustment !== null && Math.abs(offset - this._clampedAdjustment.maxAtWrite) >= 1.5) {
                 this._clampedAdjustment = null;
               }
-              this.scrollAdjustments = 0;
               const prevOffset = this.getScrollOffset();
+              const prevDirection = this.scrollDirection;
               this.scrollDirection = isScrolling ? prevOffset === offset ? this.scrollDirection : prevOffset < offset ? "forward" : "backward" : null;
               this.scrollOffset = offset;
               this.isScrolling = isScrolling;
-              this._flushIosDeferredIfReady();
+              const queued = this.scrollState;
+              if ((queued == null ? void 0 : queued.phase) === "queued" && kind === "external" && isScrolling) {
+                if (wasOverscrolled || this._reportedOverscroll) {
+                  queued.samples = [];
+                } else {
+                  const t = this.now();
+                  queued.samples = [
+                    ...(queued.samples ?? []).filter(
+                      (sample) => t - sample.t <= 200
+                    ),
+                    { t, offset: elementOffset }
+                  ];
+                  if (prevDirection !== null && this.scrollDirection !== prevDirection || flingSpedUp(queued.samples)) {
+                    this.scrollState = null;
+                  }
+                }
+              }
+              if (this._iosGesture.onScroll({
+                isScrolling,
+                ownReadBack: kind === "readBack",
+                moved: offset !== prevOffset,
+                // Neither our write's read-back nor a frame of our smooth
+                // animation: the user or a fling moved it.
+                external: kind === "external" && ((_b = this.scrollState) == null ? void 0 : _b.phase) !== "smooth" && ((_c = this.scrollState) == null ? void 0 : _c.phase) !== "smoothFinishing"
+              }) && // The user scrolls: a command still waiting for the tail is
+              // theirs to override, like a written one would be.
+              ((_d = this.scrollState) == null ? void 0 : _d.phase) === "queued") {
+                this.scrollState = null;
+              }
+              this._flushHoldIfReady(true);
               if (this.scrollState) {
                 this.scheduleScrollReconcile();
               }
@@ -77496,109 +78421,101 @@ focus outline in that case.
             })
           );
           if ("addEventListener" in this.scrollElement) {
-            const scrollEl = this.scrollElement;
-            const onTouchStart = () => {
-              this._iosTouching = true;
-              this._iosJustTouchEnded = false;
-              if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
-                this.targetWindow.clearTimeout(this._iosTouchEndTimerId);
-                this._iosTouchEndTimerId = null;
-              }
-            };
-            const onTouchEnd = () => {
-              this._iosTouching = false;
-              if (!isIOSWebKit() || this.targetWindow == null) {
-                return;
-              }
-              this._iosJustTouchEnded = true;
-              this._iosTouchEndTimerId = this.targetWindow.setTimeout(() => {
-                this._iosJustTouchEnded = false;
-                this._iosTouchEndTimerId = null;
-                this._flushIosDeferredIfReady();
-              }, 150);
-            };
-            scrollEl.addEventListener(
-              "touchstart",
-              onTouchStart,
-              addEventListenerOptions
+            this.unsubs.push(
+              this._iosGesture.listen(this.scrollElement)
             );
-            scrollEl.addEventListener(
-              "touchend",
-              onTouchEnd,
-              addEventListenerOptions
-            );
-            this.unsubs.push(() => {
-              scrollEl.removeEventListener("touchstart", onTouchStart);
-              scrollEl.removeEventListener("touchend", onTouchEnd);
-              if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
-                this.targetWindow.clearTimeout(this._iosTouchEndTimerId);
-                this._iosTouchEndTimerId = null;
-              }
-            });
           }
-          this._scrollToOffset(this.getScrollOffset(), {
-            adjustments: void 0,
-            behavior: void 0
-          });
+          this._scrollToOffset(this.getScrollOffset());
         }
+        this._noteClampMax();
         const anchor = this.pendingScrollAnchor;
         this.pendingScrollAnchor = null;
         if (anchor && this.scrollElement && this.options.enabled) {
-          const [key, _offset, followOnAppend, anchorDelta] = anchor;
-          if (key !== null && !followOnAppend) {
-            if (isIOSWebKit() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded)) {
-              if (anchorDelta !== 0) {
-                this._iosDeferredAdjustment += anchorDelta;
-              }
-            } else if (((_b = this.scrollState) == null ? void 0 : _b.behavior) === "smooth" && !approxEqual(
-              this.getScrollOffset() - anchorDelta,
+          if (anchor.kind === "anchor") {
+            if (!this._canWriteScroll()) {
+              this._holdOffset += anchor.delta;
+              this._followOffsetTarget(anchor.delta);
+              this.notify(false);
+            } else if (isSmoothScroll(this.scrollState) && !approxEqual(
+              this.getScrollOffset() - anchor.delta,
               this.scrollState.lastTargetOffset
             )) ;
             else {
-              this._scrollToOffset(this.getScrollOffset(), {
-                adjustments: void 0,
-                behavior: void 0
-              });
+              this._followOffsetTarget(anchor.delta);
+              this._scrollToOffset(this.getScrollOffset());
             }
-          }
-          if (followOnAppend) {
-            this.scrollToEnd({ behavior: followOnAppend });
+          } else {
+            this.scrollToEnd({ behavior: anchor.behavior });
           }
         }
+        this._flushHoldIfReady(false);
         this._retryClampedAdjustment();
       };
+      this._classifyScrollEvent = (offset, isScrolling, elementMax) => {
+        var _a;
+        return classifyScrollEvent({
+          offset,
+          isScrolling,
+          elementMax,
+          holdOffset: this._holdOffset,
+          scrollOffset: this.scrollOffset,
+          pendingWrite: this.pendingWrite,
+          clampedMaxAtWrite: ((_a = this._clampedAdjustment) == null ? void 0 : _a.maxAtWrite) ?? null
+        });
+      };
       this._retryClampedAdjustment = () => {
-        if (this._clampedAdjustment === null || !this.scrollElement || !this.options.enabled) {
+        if (this._clampedAdjustment === null || !this.scrollElement || !this.options.enabled || !this._canWriteScroll()) {
           return;
         }
         const { target, maxAtWrite } = this._clampedAdjustment;
         const max = this.getMaxScrollOffset();
         if (max > maxAtWrite + 0.5) {
           this._clampedAdjustment = target > max + 0.5 ? { target, maxAtWrite: max } : null;
-          this._scrollToOffset(target, {
-            adjustments: void 0,
-            behavior: void 0
-          });
+          this._scrollToOffset(target);
         }
       };
-      this._flushIosDeferredIfReady = () => {
-        if (this._iosDeferredAdjustment === 0) return;
-        if (this.isScrolling) return;
-        if (this._iosTouching) return;
-        if (this._iosJustTouchEnded) return;
-        const cur = this.getScrollOffset();
-        const max = this.getMaxScrollOffset();
-        if (cur < 0 || cur > max) return;
-        if (this._iosDeferredAdjustment < 0 && cur >= max - 1) {
-          this._iosDeferredAdjustment = 0;
-          return;
+      this._writeAwaitingCommand = () => {
+        const state = this.scrollState;
+        if (state === null || state.phase !== "queued") return;
+        const { behavior } = state;
+        this.getMeasurements();
+        const offset = this.getScrollStateTarget(state);
+        state.lastTargetOffset = offset;
+        this._clampedAdjustment = null;
+        state.phase = initialScrollPhase(
+          behavior,
+          state.index != null && approxEqual(offset, this.getScrollOffset())
+        );
+        this._scrollToOffset(offset, { behavior });
+        this.scheduleScrollReconcile();
+      };
+      this._readElementOffset = () => {
+        const el = this.scrollElement;
+        if (el == null) return null;
+        const { horizontal, isRtl } = this.options;
+        if (typeof el.scrollTop === "number") {
+          return horizontal ? el.scrollLeft * (isRtl && -1 || 1) : el.scrollTop;
         }
-        const delta = this._iosDeferredAdjustment;
-        this._iosDeferredAdjustment = 0;
-        this._scrollToOffset(cur, {
-          adjustments: this.scrollAdjustments += delta,
-          behavior: void 0
-        });
+        if (typeof el.scrollY === "number") {
+          return horizontal ? el.scrollX : el.scrollY;
+        }
+        return null;
+      };
+      this._canWriteScroll = () => !(isIOSWebKit() && this._iosGesture.inMotion()) && !this._reportedOverscroll;
+      this._flushHoldIfReady = (sync) => {
+        var _a;
+        if (this._holdOffset === 0) return;
+        if (!this.scrollElement || !this.options.enabled) return;
+        if (!this._canWriteScroll()) return;
+        if (((_a = this.scrollState) == null ? void 0 : _a.phase) === "smooth") return;
+        this._holdOffset = 0;
+        if (this.scrollOffset !== null && this.scrollOffset < 0) {
+          this.scrollOffset = 0;
+        }
+        this.notify(sync);
+        const target = this.getCommandWrittenOffset() ?? this.getScrollOffset();
+        this._clampedAdjustment = this._clampedBy(target);
+        this._scrollToOffset(target);
       };
       this.rafId = null;
       this.getSize = () => {
@@ -77844,15 +78761,17 @@ focus outline in that case.
             this.options.overscan,
             this.options.count,
             startIndex,
-            endIndex
+            endIndex,
+            this.options.lanes
           ];
         },
-        (rangeExtractor, overscan, count, startIndex, endIndex) => {
+        (rangeExtractor, overscan, count, startIndex, endIndex, lanes) => {
           return startIndex === null || endIndex === null ? [] : rangeExtractor({
             startIndex,
             endIndex,
             overscan,
-            count
+            count,
+            lanes
           });
         },
         {
@@ -77873,7 +78792,7 @@ focus outline in that case.
       };
       this.shouldMeasureDuringScroll = (index) => {
         var _a;
-        if (!this.scrollState || this.scrollState.behavior !== "smooth") {
+        if (!isSmoothScroll(this.scrollState)) {
           return true;
         }
         const scrollIndex = this.scrollState.index ?? ((_a = this.getVirtualItemForOffset(this.scrollState.lastTargetOffset)) == null ? void 0 : _a.index);
@@ -77912,17 +78831,18 @@ focus outline in that case.
           this.observer.observe(node);
           this.elementsCache.set(key, node);
         }
-        if ((!this.isScrolling || this.scrollState) && this.shouldMeasureDuringScroll(index)) {
+        if (node.isConnected && (!this.isScrolling || this.scrollState) && this.shouldMeasureDuringScroll(index)) {
           this.resizeItem(index, this.options.measureElement(node, void 0, this));
         }
       };
       this.resizeItem = (index, size) => {
         var _a, _b, _c;
         if (!this.isIndexInRange(index)) return;
+        if ((_a = this._resizeBatch) == null ? void 0 : _a.sync) this.getMeasurements();
         let cachedSize;
         let itemStart;
         let key;
-        const flat = (_a = this._singleLaneMeasurements) == null ? void 0 : _a.flat;
+        const flat = (_b = this._singleLaneMeasurements) == null ? void 0 : _b.flat;
         if (this.options.lanes === 1 && flat != null) {
           key = this.options.getItemKey(index);
           itemStart = flat[index * 2];
@@ -77937,15 +78857,15 @@ focus outline in that case.
         const itemSize = this.itemSizeCache.get(key) ?? cachedSize;
         const delta = size - itemSize;
         if (delta !== 0) {
-          const wasAtEnd = this.options.anchorTo === "end" && ((_b = this.scrollState) == null ? void 0 : _b.behavior) !== "smooth" && this.getVirtualDistanceFromEnd() <= this.options.scrollEndThreshold;
-          const prevTotalSize = wasAtEnd ? this.getTotalSize() : 0;
-          const scrollOffsetWithAdj = this.getScrollOffset() + this.scrollAdjustments;
+          const wasAtEnd = this.options.anchorTo === "end" && !isSmoothScroll(this.scrollState) && this.getVirtualDistanceFromEnd() <= this.options.scrollEndThreshold;
+          const prevTotalSize = wasAtEnd ? this._getLayoutTotalSize() : 0;
+          const scrollOffset = this.getScrollOffset();
           const isFirstMeasure = !this.itemSizeCache.has(key);
           const defaultShouldAdjust = isFirstMeasure ? (
             // First measurement: compensate any item whose top sits above the
             // fold — the estimate→actual delta must be corrected regardless of
             // scroll direction, since the whole estimated block was above it.
-            itemStart < scrollOffsetWithAdj
+            itemStart < scrollOffset
           ) : (
             // Re-measurement: only compensate an item that is ENTIRELY above the
             // fold. An item that merely *spans* the fold (top above, bottom
@@ -77954,9 +78874,9 @@ focus outline in that case.
             // delta would drag the viewport downward on every growth (#1218).
             // Also skip during backward scroll to avoid the "items jump while
             // scrolling up" cascade.
-            itemStart + itemSize <= scrollOffsetWithAdj && this.scrollDirection !== "backward"
+            itemStart + itemSize <= scrollOffset && this.scrollDirection !== "backward"
           );
-          const shouldAdjustScroll = ((_c = this.scrollState) == null ? void 0 : _c.behavior) !== "smooth" && (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(
+          const shouldAdjustScroll = !isSmoothScroll(this.scrollState) && (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(
             // The callback expects a VirtualItem; build one lazily only
             // when the consumer actually supplied a custom predicate.
             this.measurementsCache[index] ?? {
@@ -77976,25 +78896,40 @@ focus outline in that case.
           this.itemSizeCache.set(key, size);
           this.itemSizeCacheVersion++;
           let adjustedSync = false;
-          if (wasAtEnd) {
-            adjustedSync = this.applyScrollAdjustment(
-              this.getTotalSize() - prevTotalSize
-            );
-          } else if (shouldAdjustScroll) {
-            adjustedSync = this.applyScrollAdjustment(delta);
+          if (!this._awaitingCommandReadBack()) {
+            if (wasAtEnd) {
+              adjustedSync = this.applyScrollAdjustment(
+                this._getLayoutTotalSize() - prevTotalSize
+              );
+            } else if (shouldAdjustScroll) {
+              adjustedSync = this.applyScrollAdjustment(delta);
+            }
+          }
+          if (this._resizeBatch) {
+            this._resizeBatch.notify = true;
+            (_c = this._resizeBatch).sync || (_c.sync = adjustedSync);
+            return;
           }
           this.notify(adjustedSync);
+          this._noteClampMax();
+          this._flushHoldIfReady(true);
           this._retryClampedAdjustment();
         }
       };
       this.getVirtualItems = memo(
-        () => [this.getVirtualIndexes(), this.getMeasurements()],
-        (indexes, measurements) => {
+        () => [this.getVirtualIndexes(), this.getMeasurements(), this._holdOffset],
+        (indexes, measurements, hold) => {
           const virtualItems = [];
           for (let k = 0, len = indexes.length; k < len; k++) {
             const i = indexes[k];
             const measurement = measurements[i];
-            virtualItems.push(measurement);
+            virtualItems.push(
+              hold === 0 ? measurement : {
+                ...measurement,
+                start: measurement.start - hold,
+                end: measurement.end - hold
+              }
+            );
           }
           return virtualItems;
         },
@@ -78019,18 +78954,89 @@ focus outline in that case.
         );
         return notUndefined(measurements[idx]);
       };
-      this.getMaxScrollOffset = () => {
-        if (!this.scrollElement) return 0;
-        if ("scrollHeight" in this.scrollElement) {
-          return this.options.horizontal ? this.scrollElement.scrollWidth - this.scrollElement.clientWidth : this.scrollElement.scrollHeight - this.scrollElement.clientHeight;
-        } else {
-          const doc = this.scrollElement.document.documentElement;
-          return this.options.horizontal ? doc.scrollWidth - this.scrollElement.innerWidth : doc.scrollHeight - this.scrollElement.innerHeight;
+      this._noteClampMax = () => {
+        if (!this._awaitingCommandReadBack()) return;
+        const elementMax = this._elementMaxScrollOffset();
+        if (elementMax === null) return;
+        const write = this.pendingWrite;
+        const max = Math.max(elementMax, 0) + this._holdOffset;
+        if (max >= write.target) return;
+        const lowMaxes = write.lowMaxes ?? (write.lowMaxes = []);
+        if (lowMaxes[lowMaxes.length - 1] !== max) lowMaxes.push(max);
+      };
+      this.getMaxScrollOffset = () => (this._elementMaxScrollOffset() ?? 0) + this._holdOffset;
+      this._toLayoutOffset = (elementOffset) => {
+        var _a;
+        let offset = elementOffset + this._holdOffset;
+        if (((_a = this.pendingScrollAnchor) == null ? void 0 : _a.kind) === "anchor") {
+          offset += this.pendingScrollAnchor.delta;
+        }
+        return offset;
+      };
+      this._elementMaxScrollOffset = () => {
+        const el = this.scrollElement;
+        if (el === null) return null;
+        if ("scrollHeight" in el) {
+          return this.options.horizontal ? el.scrollWidth - el.clientWidth : el.scrollHeight - el.clientHeight;
+        }
+        if ("document" in el) {
+          const doc = el.document.documentElement;
+          return this.options.horizontal ? doc.scrollWidth - el.innerWidth : doc.scrollHeight - el.innerHeight;
+        }
+        return null;
+      };
+      this._momentumStop = null;
+      this._stopMomentum = (done) => {
+        const el = this.scrollElement;
+        const win = this.targetWindow;
+        if (el === null || win === null) return;
+        const scroller = "document" in el ? el.document.scrollingElement : el;
+        if (!(scroller == null ? void 0 : scroller.style)) return;
+        if (this._momentumStop) {
+          this._momentumStop.done = done;
+          return;
         }
+        const { style } = scroller;
+        const property = this.options.horizontal ? "overflow-x" : "overflow-y";
+        const value = style.getPropertyValue(property);
+        const priority = style.getPropertyPriority(property);
+        const crossSize = () => this.options.horizontal ? scroller.clientHeight : scroller.clientWidth;
+        const crossSizeBefore = crossSize();
+        style.setProperty(property, "hidden", "important");
+        if (crossSize() !== crossSizeBefore) {
+          style.setProperty(property, value, priority);
+          return;
+        }
+        const stop = {
+          // False when the app replaced the hidden value: the fling may not
+          // have stopped.
+          restore: () => {
+            if (style.getPropertyValue(property) !== "hidden" || style.getPropertyPriority(property) !== "important") {
+              return false;
+            }
+            style.setProperty(property, value, priority);
+            return true;
+          },
+          done
+        };
+        this._momentumStop = stop;
+        win.requestAnimationFrame(
+          () => win.requestAnimationFrame(() => {
+            if (this._momentumStop !== stop) return;
+            this._momentumStop = null;
+            if (stop.restore()) stop.done();
+          })
+        );
+      };
+      this._clampedBy = (target) => {
+        const elementMax = this._elementMaxScrollOffset();
+        if (elementMax === null) return null;
+        const maxAtWrite = elementMax + this._holdOffset;
+        return target > maxAtWrite + 0.5 ? { target, maxAtWrite } : null;
       };
       this.getVirtualDistanceFromEnd = () => {
         return Math.max(
-          this.getTotalSize() - this.getSize() - this.getScrollOffset(),
+          this._getLayoutTotalSize() + this.options.scrollMargin - this.getSize() - this.getScrollOffset(),
           0
         );
       };
@@ -78071,7 +79077,9 @@ focus outline in that case.
           }
         }
         if (align === "end" && index === this.options.count - 1) {
-          return [this.getMaxScrollOffset(), align];
+          const maxOffset = this.getMaxScrollOffset();
+          const toOffset2 = maxOffset - this.options.paddingEnd + this.options.scrollPaddingEnd;
+          return [Math.max(Math.min(toOffset2, maxOffset), 0), align];
         }
         const toOffset = align === "end" ? item.end + this.options.scrollPaddingEnd : item.start - this.options.scrollPaddingStart;
         return [
@@ -78080,70 +79088,58 @@ focus outline in that case.
         ];
       };
       this.scrollToOffset = (toOffset, { align = "start", behavior = "auto" } = {}) => {
-        this._iosDeferredAdjustment = 0;
-        const offset = this.getOffsetForAlignment(toOffset, align);
-        const now = this.now();
-        this.scrollState = {
-          index: null,
-          align,
+        this._startScroll(
+          { index: null, align },
+          this.getOffsetForAlignment(toOffset, align),
           behavior,
-          startedAt: now,
-          lastTargetOffset: offset,
-          stableFrames: 0
-        };
-        this._scrollToOffset(offset, { adjustments: void 0, behavior });
-        this.scheduleScrollReconcile();
+          "absolute"
+        );
       };
       this.scrollToIndex = (index, {
         align: initialAlign = "auto",
         behavior = "auto"
       } = {}) => {
-        this._iosDeferredAdjustment = 0;
         index = Math.max(0, Math.min(index, this.options.count - 1));
         const offsetInfo = this.getOffsetForIndex(index, initialAlign);
-        if (!offsetInfo) {
-          return;
-        }
+        if (!offsetInfo) return;
         const [offset, align] = offsetInfo;
-        const now = this.now();
-        this.scrollState = {
-          index,
-          align,
-          behavior,
-          startedAt: now,
-          lastTargetOffset: offset,
-          stableFrames: 0
-        };
-        this._scrollToOffset(offset, { adjustments: void 0, behavior });
-        this.scheduleScrollReconcile();
+        this._startScroll({ index, align }, offset, behavior, "absolute");
       };
       this.scrollBy = (delta, { behavior = "auto" } = {}) => {
-        const offset = this.getScrollOffset() + delta;
-        const now = this.now();
-        this.scrollState = {
-          index: null,
-          align: "start",
+        const offset = this.getOffsetForAlignment(
+          (this.getCommandWrittenOffset() ?? this.getScrollOffset()) + delta,
+          "start"
+        );
+        this._startScroll(
+          { index: null, align: "start" },
+          offset,
           behavior,
-          startedAt: now,
-          lastTargetOffset: offset,
-          stableFrames: 0
-        };
-        this._scrollToOffset(offset, { adjustments: void 0, behavior });
-        this.scheduleScrollReconcile();
+          "relative"
+        );
       };
       this.scrollToEnd = ({ behavior = "auto" } = {}) => {
         if (this.options.count > 0) {
-          this.scrollToIndex(this.options.count - 1, {
-            align: "end",
-            behavior
-          });
+          this._startScroll(
+            { index: this.options.count - 1, align: "end", toEnd: true },
+            Math.max(this.getMaxScrollOffset(), 0),
+            behavior,
+            "absolute"
+          );
           return;
         }
         this.scrollToOffset(Math.max(this.getTotalSize() - this.getSize(), 0), {
           behavior
         });
       };
-      this.getTotalSize = () => {
+      this.cancelScroll = () => {
+        if (this.rafId != null && this.targetWindow) {
+          this.targetWindow.cancelAnimationFrame(this.rafId);
+          this.rafId = null;
+        }
+        this.scrollState = null;
+      };
+      this.getTotalSize = () => Math.max(this._getLayoutTotalSize() - this._holdOffset, 0);
+      this._getLayoutTotalSize = () => {
         var _a, _b;
         const measurements = this.getMeasurements();
         let end;
@@ -78195,9 +79191,28 @@ focus outline in that case.
       this._scrollToOffset = (offset, {
         adjustments,
         behavior
-      }) => {
-        this._intendedScrollOffset = offset + (adjustments ?? 0);
-        this.options.scrollToFn(offset, { behavior, adjustments }, this);
+      } = {}) => {
+        const write = {
+          target: offset + (adjustments ?? 0),
+          smooth: behavior === "smooth"
+        };
+        this.pendingWrite = write;
+        this.options.scrollToFn(
+          offset - this._holdOffset,
+          { behavior, adjustments },
+          this
+        );
+        return write;
+      };
+      this.getCommandWrittenOffset = () => this.scrollState !== null && this.pendingWrite !== null && !this.pendingWrite.smooth ? this.pendingWrite.target : null;
+      this._awaitingCommandReadBack = () => {
+        const writtenOffset = this.getCommandWrittenOffset();
+        return !(isIOSWebKit() && this._iosGesture.dragging()) && writtenOffset !== null && !approxEqual(writtenOffset, this.getScrollOffset());
+      };
+      this._followOffsetTarget = (delta) => {
+        if (this.scrollState !== null && this.scrollState.index == null) {
+          this.scrollState.lastTargetOffset += delta;
+        }
       };
       this.measure = () => {
         this.pendingMin = null;
@@ -78208,6 +79223,14 @@ focus outline in that case.
       };
       this.setOptions(opts);
     }
+    /**
+     * @deprecated Always 0: a scroll correction is folded into `scrollOffset`
+     * at once, so there is never an outstanding adjustment to add to it. Read
+     * `scrollOffset` alone.
+     */
+    get scrollAdjustments() {
+      return 0;
+    }
     // Returns `true` when it performed a synchronous `scrollTop` write this
     // tick, `false` when the delta was zero or the write was deferred (iOS).
     // `resizeItem` uses that to decide whether the follow-up `notify` must be
@@ -78217,22 +79240,21 @@ focus outline in that case.
       if (this.options.debug) {
         console.info("correction", delta);
       }
-      if (isIOSWebKit() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded)) {
-        this._iosDeferredAdjustment += delta;
-        return false;
+      this._followOffsetTarget(delta);
+      if (!this._canWriteScroll()) {
+        this._holdOffset += delta;
+        if (this.scrollOffset !== null) this.scrollOffset += delta;
+        return true;
       } else {
-        const target = this.getScrollOffset() + this.scrollAdjustments + delta;
-        const el = this.scrollElement;
-        const maxAtWrite = el !== null && ("scrollHeight" in el || "document" in el) ? this.getMaxScrollOffset() : null;
-        this._clampedAdjustment = maxAtWrite !== null && target > maxAtWrite + 0.5 ? { target, maxAtWrite } : null;
-        this._scrollToOffset(this.getScrollOffset(), {
-          adjustments: this.scrollAdjustments += delta,
+        const offset = this.getScrollOffset();
+        this._clampedAdjustment = this._clampedBy(offset + delta);
+        const write = this._scrollToOffset(offset, {
+          adjustments: delta,
           behavior
         });
         if (this.scrollOffset !== null) {
-          this.scrollOffset += this.scrollAdjustments;
+          if (this.pendingWrite === write) this.scrollOffset += delta;
           if (this.scrollOffset < 0) this.scrollOffset = 0;
-          this.scrollAdjustments = 0;
         }
         return true;
       }
@@ -78248,6 +79270,10 @@ focus outline in that case.
         this.reconcileScroll();
       });
     }
+    getScrollStateTarget(state) {
+      const offsetInfo = state.toEnd ? [Math.max(this.getMaxScrollOffset(), 0)] : state.index != null ? this.getOffsetForIndex(state.index, state.align) : void 0;
+      return offsetInfo ? offsetInfo[0] : state.lastTargetOffset;
+    }
     reconcileScroll() {
       if (!this.scrollState) return;
       const el = this.scrollElement;
@@ -78257,18 +79283,24 @@ focus outline in that case.
         this.scrollState = null;
         return;
       }
-      const offsetInfo = this.scrollState.index != null ? this.getOffsetForIndex(this.scrollState.index, this.scrollState.align) : void 0;
-      const targetOffset = offsetInfo ? offsetInfo[0] : this.scrollState.lastTargetOffset;
-      const STABLE_FRAMES = 1;
+      if (this.scrollState.phase === "queued") {
+        this.scheduleScrollReconcile();
+        return;
+      }
+      this.getMeasurements();
+      const targetOffset = this.getScrollStateTarget(this.scrollState);
+      const STABLE_FRAMES = this.scrollState.index == null ? 1 : this.options.useAnimationFrameWithResizeObserver ? 3 : 2;
       const targetChanged = targetOffset !== this.scrollState.lastTargetOffset;
       if (!targetChanged && approxEqual(targetOffset, this.getScrollOffset())) {
+        if (this.scrollState.phase === "smooth") {
+          this.scrollState.phase = "smoothLanded";
+        } else if (this.scrollState.phase === "smoothFinishing") {
+          this.scrollState.phase = "instant";
+        }
         this.scrollState.stableFrames++;
         if (this.scrollState.stableFrames >= STABLE_FRAMES) {
           if (this.getScrollOffset() !== targetOffset) {
-            this._scrollToOffset(targetOffset, {
-              adjustments: void 0,
-              behavior: "auto"
-            });
+            this._scrollToOffset(targetOffset, { behavior: "auto" });
           }
           this.scrollState = null;
           return;
@@ -78278,19 +79310,81 @@ focus outline in that case.
         if (targetChanged) {
           const viewport = this.getSize() || 600;
           const distance = Math.abs(targetOffset - this.getScrollOffset());
-          const keepSmooth = this.scrollState.behavior === "smooth" && distance > viewport;
+          const keepSmooth = isSmoothScroll(this.scrollState) && distance > viewport;
           this.scrollState.lastTargetOffset = targetOffset;
-          if (!keepSmooth) {
-            this.scrollState.behavior = "auto";
+          if (keepSmooth) {
+            this.scrollState.phase = "smooth";
+          } else if (this.scrollState.phase === "smooth") {
+            this.scrollState.phase = "smoothFinishing";
+          } else if (this.scrollState.phase === "smoothLanded") {
+            this.scrollState.phase = "instant";
           }
           this._scrollToOffset(targetOffset, {
-            adjustments: void 0,
             behavior: keepSmooth ? "smooth" : "auto"
           });
         }
       }
       this.scheduleScrollReconcile();
     }
+    // Every scroll command starts here: it becomes the in-flight command,
+    // writes its first target and leaves reconcile to retarget and retire it.
+    //
+    // Targets are layout offsets. A held correction is not dropped by a
+    // command: the write lands the element `_holdOffset` short of the target,
+    // under the rows exposed shifted by the same amount, and the flush moves
+    // both together once a write is possible.
+    //
+    // An index or end target that is already at its offset starts a smooth
+    // scroll as landed; an offset target never does, so its first scroll
+    // event is read as the user's (see the scroll handler in `_willUpdate`).
+    _startScroll(target, offset, behavior, kind) {
+      this.pendingScrollAnchor = null;
+      this._clampedAdjustment = null;
+      const tail = this._iosGesture.tail();
+      if (kind === "absolute" && tail !== null) {
+        if (tail === "fling" && momentumOverridesWrites()) {
+          this._stopMomentum(() => {
+            const state = this.scrollState;
+            if ((state == null ? void 0 : state.phase) !== "queued" || // A finger came down: it owns the scroll until it lifts.
+            this._iosGesture.tail() !== "fling" || // In a bounce WebKit can drop the write (#1287): the tail
+            // decides, as without the stop. (Not `flingCaught`: our stop
+            // also ends the fling at speed, so a slow frame would read as
+            // a catch and the tail would drop the command.)
+            this._reportedOverscroll) {
+              return;
+            }
+            this._iosGesture.end();
+            this._flushHoldIfReady(true);
+            this._writeAwaitingCommand();
+          });
+          this.scrollState = {
+            ...target,
+            startedAt: this.now(),
+            lastTargetOffset: offset,
+            stableFrames: 0,
+            phase: "queued",
+            behavior,
+            samples: []
+          };
+          this.scheduleScrollReconcile();
+          return;
+        }
+        this._iosGesture.end();
+      }
+      this.scrollState = {
+        ...target,
+        startedAt: this.now(),
+        lastTargetOffset: offset,
+        stableFrames: 0,
+        behavior,
+        phase: initialScrollPhase(
+          behavior,
+          target.index != null && approxEqual(offset, this.getScrollOffset())
+        )
+      };
+      this._scrollToOffset(offset, { behavior });
+      this.scheduleScrollReconcile();
+    }
   };
   const findNearestBinarySearch = (low, high, getCurrentValue, value) => {
     while (low <= high) {