@ni/nimble-components 32.9.1 → 32.9.2

package/dist/all-components-bundle.js

@@ -29953,6 +29953,7 @@ so this becomes the fallback color for the slot */ ''}
           this.options = options;
           this.isOpen = isOpen;
           this.open = 0;
+          this.localPreserveWS = false;
           let topNode = options.topNode, topContext;
           let topOptions = wsOptionsFor(null, options.preserveWhitespace, 0) | (isOpen ? OPT_OPEN_LEFT : 0);
           if (topNode)
@@ -29979,11 +29980,12 @@ so this becomes the fallback color for the slot */ ''}
       }
       addTextNode(dom, marks) {
           let value = dom.nodeValue;
-          let top = this.top;
-          if (top.options & OPT_PRESERVE_WS_FULL ||
+          let top = this.top, preserveWS = (top.options & OPT_PRESERVE_WS_FULL) ? "full"
+              : this.localPreserveWS || (top.options & OPT_PRESERVE_WS) > 0;
+          if (preserveWS === "full" ||
               top.inlineContext(dom) ||
               /[^ \t\r\n\u000c]/.test(value)) {
-              if (!(top.options & OPT_PRESERVE_WS)) {
+              if (!preserveWS) {
                   value = value.replace(/[ \t\r\n\u000c]+/g, " ");
                   // If this starts with whitespace, and there is no node before it, or
                   // a hard break, or a text node that ends with whitespace, strip the
@@ -29997,7 +29999,7 @@ so this becomes the fallback color for the slot */ ''}
                           value = value.slice(1);
                   }
               }
-              else if (!(top.options & OPT_PRESERVE_WS_FULL)) {
+              else if (preserveWS !== "full") {
                   value = value.replace(/\r?\n|\r/g, " ");
               }
               else {
@@ -30014,12 +30016,15 @@ so this becomes the fallback color for the slot */ ''}
       // Try to find a handler for the given tag and use that to parse. If
       // none is found, the element's content nodes are added directly.
       addElement(dom, marks, matchAfter) {
+          let outerWS = this.localPreserveWS, top = this.top;
+          if (dom.tagName == "PRE" || /pre/.test(dom.style && dom.style.whiteSpace))
+              this.localPreserveWS = true;
           let name = dom.nodeName.toLowerCase(), ruleID;
           if (listTags.hasOwnProperty(name) && this.parser.normalizeLists)
               normalizeList(dom);
           let rule = (this.options.ruleFromNode && this.options.ruleFromNode(dom)) ||
               (ruleID = this.parser.matchTag(dom, this, matchAfter));
-          if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
+          out: if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
               this.findInside(dom);
               this.ignoreFallback(dom, marks);
           }
@@ -30028,7 +30033,7 @@ so this becomes the fallback color for the slot */ ''}
                   this.open = Math.max(0, this.open - 1);
               else if (rule && rule.skip.nodeType)
                   dom = rule.skip;
-              let sync, top = this.top, oldNeedsBlock = this.needsBlock;
+              let sync, oldNeedsBlock = this.needsBlock;
               if (blockTags.hasOwnProperty(name)) {
                   if (top.content.length && top.content[0].isInline && this.open) {
                       this.open--;
@@ -30040,7 +30045,7 @@ so this becomes the fallback color for the slot */ ''}
               }
               else if (!dom.firstChild) {
                   this.leafFallback(dom, marks);
-                  return;
+                  break out;
               }
               let innerMarks = rule && rule.skip ? marks : this.readStyles(dom, marks);
               if (innerMarks)
@@ -30054,6 +30059,7 @@ so this becomes the fallback color for the slot */ ''}
               if (innerMarks)
                   this.addElementByRule(dom, rule, innerMarks, rule.consuming === false ? ruleID : undefined);
           }
+          this.localPreserveWS = outerWS;
       }
       // Called for leaf DOM nodes that would otherwise be ignored
       leafFallback(dom, marks) {
@@ -30244,14 +30250,18 @@ so this becomes the fallback color for the slot */ ''}
       finish() {
           this.open = 0;
           this.closeExtra(this.isOpen);
-          return this.nodes[0].finish(this.isOpen || this.options.topOpen);
+          return this.nodes[0].finish(!!(this.isOpen || this.options.topOpen));
       }
       sync(to) {
-          for (let i = this.open; i >= 0; i--)
+          for (let i = this.open; i >= 0; i--) {
               if (this.nodes[i] == to) {
                   this.open = i;
                   return true;
               }
+              else if (this.localPreserveWS) {
+                  this.nodes[i].options |= OPT_PRESERVE_WS;
+              }
+          }
           return false;
       }
       get currentPos() {
@@ -34161,11 +34171,12 @@ so this becomes the fallback color for the slot */ ''}
       for (let cur = node, sawBlock = false;;) {
           if (cur == view.dom)
               break;
-          let desc = view.docView.nearestDesc(cur, true);
+          let desc = view.docView.nearestDesc(cur, true), rect;
           if (!desc)
               return null;
-          if (desc.dom.nodeType == 1 && (desc.node.isBlock && desc.parent || !desc.contentDOM)) {
-              let rect = desc.dom.getBoundingClientRect();
+          if (desc.dom.nodeType == 1 && (desc.node.isBlock && desc.parent || !desc.contentDOM) &&
+              // Ignore elements with zero-size bounding rectangles
+              ((rect = desc.dom.getBoundingClientRect()).width || rect.height)) {
               if (desc.node.isBlock && desc.parent) {
                   // Only apply the horizontal test to the innermost block. Vertical for any parent.
                   if (!sawBlock && rect.left > coords.left || rect.top > coords.top)
@@ -36807,7 +36818,7 @@ so this becomes the fallback color for the slot */ ''}
           this.lastIOSEnterFallbackTimeout = -1;
           this.lastFocus = 0;
           this.lastTouch = 0;
-          this.lastAndroidDelete = 0;
+          this.lastChromeDelete = 0;
           this.composing = false;
           this.compositionNode = null;
           this.composingTimeout = -1;
@@ -38784,11 +38795,11 @@ so this becomes the fallback color for the slot */ ''}
               view.domObserver.suppressSelectionUpdates(); // #820
           return;
       }
-      // Chrome Android will occasionally, during composition, delete the
+      // Chrome will occasionally, during composition, delete the
       // entire composition and then immediately insert it again. This is
       // used to detect that situation.
-      if (chrome && android && change.endB == change.start)
-          view.input.lastAndroidDelete = Date.now();
+      if (chrome && change.endB == change.start)
+          view.input.lastChromeDelete = Date.now();
       // This tries to detect Android virtual keyboard
       // enter-and-pick-suggestion action. That sometimes (see issue
       // #1059) first fires a DOM mutation, before moving the selection to
@@ -38839,13 +38850,13 @@ so this becomes the fallback color for the slot */ ''}
           tr = view.state.tr.replace(chFrom, chTo, parse.doc.slice(change.start - parse.from, change.endB - parse.from));
       if (parse.sel) {
           let sel = resolveSelection(view, tr.doc, parse.sel);
-          // Chrome Android will sometimes, during composition, report the
+          // Chrome will sometimes, during composition, report the
           // selection in the wrong place. If it looks like that is
           // happening, don't update the selection.
           // Edge just doesn't move the cursor forward when you start typing
           // in an empty block or between br nodes.
-          if (sel && !(chrome && android && view.composing && sel.empty &&
-              (change.start != change.endB || view.input.lastAndroidDelete < Date.now() - 100) &&
+          if (sel && !(chrome && view.composing && sel.empty &&
+              (change.start != change.endB || view.input.lastChromeDelete < Date.now() - 100) &&
               (sel.head == chFrom || sel.head == tr.mapping.map(chTo) - 1) ||
               ie$1 && sel.empty && sel.head == chFrom))
               tr.setSelection(sel);
@@ -40341,28 +40352,44 @@ so this becomes the fallback color for the slot */ ''}
   function wrapInList$1(listType, attrs = null) {
       return function (state, dispatch) {
           let { $from, $to } = state.selection;
-          let range = $from.blockRange($to), doJoin = false, outerRange = range;
+          let range = $from.blockRange($to);
           if (!range)
               return false;
-          // This is at the top of an existing list item
-          if (range.depth >= 2 && $from.node(range.depth - 1).type.compatibleContent(listType) && range.startIndex == 0) {
-              // Don't do anything if this is the top of the list
-              if ($from.index(range.depth - 1) == 0)
-                  return false;
-              let $insert = state.doc.resolve(range.start - 2);
-              outerRange = new NodeRange($insert, $insert, range.depth);
-              if (range.endIndex < range.parent.childCount)
-                  range = new NodeRange($from, state.doc.resolve($to.end(range.depth)), range.depth);
-              doJoin = true;
-          }
-          let wrap = findWrapping(outerRange, listType, attrs, range);
-          if (!wrap)
+          let tr = dispatch ? state.tr : null;
+          if (!wrapRangeInList(tr, range, listType, attrs))
               return false;
           if (dispatch)
-              dispatch(doWrapInList(state.tr, range, wrap, doJoin, listType).scrollIntoView());
+              dispatch(tr.scrollIntoView());
           return true;
       };
   }
+  /**
+  Try to wrap the given node range in a list of the given type.
+  Return `true` when this is possible, `false` otherwise. When `tr`
+  is non-null, the wrapping is added to that transaction. When it is
+  `null`, the function only queries whether the wrapping is
+  possible.
+  */
+  function wrapRangeInList(tr, range, listType, attrs = null) {
+      let doJoin = false, outerRange = range, doc = range.$from.doc;
+      // This is at the top of an existing list item
+      if (range.depth >= 2 && range.$from.node(range.depth - 1).type.compatibleContent(listType) && range.startIndex == 0) {
+          // Don't do anything if this is the top of the list
+          if (range.$from.index(range.depth - 1) == 0)
+              return false;
+          let $insert = doc.resolve(range.start - 2);
+          outerRange = new NodeRange($insert, $insert, range.depth);
+          if (range.endIndex < range.parent.childCount)
+              range = new NodeRange(range.$from, doc.resolve(range.$to.end(range.depth)), range.depth);
+          doJoin = true;
+      }
+      let wrap = findWrapping(outerRange, listType, attrs, range);
+      if (!wrap)
+          return false;
+      if (tr)
+          doWrapInList(tr, range, wrap, doJoin, listType);
+      return true;
+  }
   function doWrapInList(tr, range, wrappers, joinBefore, listType) {
       let content = Fragment.empty;
       for (let i = wrappers.length - 1; i >= 0; i--)
@@ -41460,6 +41487,8 @@ so this becomes the fallback color for the slot */ ''}
       const success = handlers.every(handler => handler !== null);
       return success;
   }
+  // When dragging across editors, must get another editor instance to delete selection content.
+  let tiptapDragFromOtherEditor = null;
   const createClipboardPasteEvent = (text) => {
       var _a;
       const event = new ClipboardEvent('paste', {
@@ -41522,11 +41551,21 @@ so this becomes the fallback color for the slot */ ''}
                       dragSourceElement = ((_a = view.dom.parentElement) === null || _a === void 0 ? void 0 : _a.contains(event.target))
                           ? view.dom.parentElement
                           : null;
+                      if (dragSourceElement) {
+                          tiptapDragFromOtherEditor = editor;
+                      }
+                  };
+                  const handleDragend = () => {
+                      if (tiptapDragFromOtherEditor) {
+                          tiptapDragFromOtherEditor = null;
+                      }
                   };
                   window.addEventListener('dragstart', handleDragstart);
+                  window.addEventListener('dragend', handleDragend);
                   return {
                       destroy() {
                           window.removeEventListener('dragstart', handleDragstart);
+                          window.removeEventListener('dragend', handleDragend);
                       },
                   };
               },
@@ -41535,6 +41574,18 @@ so this becomes the fallback color for the slot */ ''}
                       drop: (view, event) => {
                           isDroppedFromProseMirror = dragSourceElement === view.dom.parentElement;
                           dropEvent = event;
+                          if (!isDroppedFromProseMirror) {
+                              const dragFromOtherEditor = tiptapDragFromOtherEditor;
+                              if (dragFromOtherEditor) {
+                                  // setTimeout to avoid the wrong content after drop, timeout arg can't be empty or 0
+                                  setTimeout(() => {
+                                      const selection = dragFromOtherEditor.state.selection;
+                                      if (selection) {
+                                          dragFromOtherEditor.commands.deleteRange({ from: selection.from, to: selection.to });
+                                      }
+                                  }, 10);
+                              }
+                          }
                           return false;
                       },
                       paste: (_view, event) => {
@@ -42293,30 +42344,13 @@ so this becomes the fallback color for the slot */ ''}
       return TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
   }
 
-  function isiOS() {
-      return [
-          'iPad Simulator',
-          'iPhone Simulator',
-          'iPod Simulator',
-          'iPad',
-          'iPhone',
-          'iPod',
-      ].includes(navigator.platform)
-          // iPad on iOS 13 detection
-          || (navigator.userAgent.includes('Mac') && 'ontouchend' in document);
-  }
-
   const focus = (position = null, options = {}) => ({ editor, view, tr, dispatch, }) => {
       options = {
           scrollIntoView: true,
           ...options,
       };
       const delayedFocus = () => {
-          // focus within `requestAnimationFrame` breaks focus on iOS
-          // so we have to call this
-          if (isiOS()) {
-              view.dom.focus();
-          }
+          view.dom.focus();
           // For React we have to focus asynchronously. Otherwise wild things happen.
           // see: https://github.com/ueberdosis/tiptap/issues/1520
           requestAnimationFrame(() => {
@@ -42647,6 +42681,19 @@ so this becomes the fallback color for the slot */ ''}
       return joinTextblockForward$1(state, dispatch);
   };
 
+  function isiOS() {
+      return [
+          'iPad Simulator',
+          'iPhone Simulator',
+          'iPod Simulator',
+          'iPad',
+          'iPhone',
+          'iPod',
+      ].includes(navigator.platform)
+          // iPad on iOS 13 detection
+          || (navigator.userAgent.includes('Mac') && 'ontouchend' in document);
+  }
+
   function isMacOS() {
       return typeof navigator !== 'undefined'
           ? /Mac/.test(navigator.platform)
@@ -42857,11 +42904,12 @@ so this becomes the fallback color for the slot */ ''}
       return true;
   };
 
-  const selectAll = () => ({ tr, commands }) => {
-      return commands.setTextSelection({
-          from: 0,
-          to: tr.doc.content.size,
-      });
+  const selectAll = () => ({ tr, dispatch }) => {
+      if (dispatch) {
+          const selection = new AllSelection(tr.doc);
+          tr.setSelection(selection);
+      }
+      return true;
   };
 
   const selectNodeBackward = () => ({ state, dispatch }) => {
@@ -56143,8 +56191,8 @@ img.ProseMirror-separator {
       this.values = values;
     }
 
-    if ( RopeSequence ) Leaf.__proto__ = RopeSequence;
-    Leaf.prototype = Object.create( RopeSequence && RopeSequence.prototype );
+    Leaf.__proto__ = RopeSequence;
+    Leaf.prototype = Object.create( RopeSequence.prototype );
     Leaf.prototype.constructor = Leaf;
 
     var prototypeAccessors = { length: { configurable: true },depth: { configurable: true } };
@@ -56204,8 +56252,8 @@ img.ProseMirror-separator {
       this.depth = Math.max(left.depth, right.depth) + 1;
     }
 
-    if ( RopeSequence ) Append.__proto__ = RopeSequence;
-    Append.prototype = Object.create( RopeSequence && RopeSequence.prototype );
+    Append.__proto__ = RopeSequence;
+    Append.prototype = Object.create( RopeSequence.prototype );
     Append.prototype.constructor = Append;
 
     Append.prototype.flatten = function flatten () {
@@ -57165,6 +57213,8 @@ img.ProseMirror-separator {
   // A valid web domain token
   const WORD = 'WORD'; // only contains a-z
   const UWORD = 'UWORD'; // contains letters other than a-z, used for IDN
+  const ASCIINUMERICAL = 'ASCIINUMERICAL'; // contains a-z, 0-9
+  const ALPHANUMERICAL = 'ALPHANUMERICAL'; // contains numbers and letters other than a-z, used for IDN
 
   // Special case of word
   const LOCALHOST = 'LOCALHOST';
@@ -57192,7 +57242,7 @@ img.ProseMirror-separator {
   const WS = 'WS';
 
   // New line (unix style)
-  const NL$1 = 'NL'; // \n
+  const NL = 'NL'; // \n
 
   // Opening/closing bracket classes
   // TODO: Rename OPEN -> LEFT and CLOSE -> RIGHT in v5 to fit with Unicode names
@@ -57252,6 +57302,8 @@ img.ProseMirror-separator {
   	__proto__: null,
   	WORD: WORD,
   	UWORD: UWORD,
+  	ASCIINUMERICAL: ASCIINUMERICAL,
+  	ALPHANUMERICAL: ALPHANUMERICAL,
   	LOCALHOST: LOCALHOST,
   	TLD: TLD,
   	UTLD: UTLD,
@@ -57259,7 +57311,7 @@ img.ProseMirror-separator {
   	SLASH_SCHEME: SLASH_SCHEME,
   	NUM: NUM,
   	WS: WS,
-  	NL: NL$1,
+  	NL: NL,
   	OPENBRACE: OPENBRACE,
   	CLOSEBRACE: CLOSEBRACE,
   	OPENBRACKET: OPENBRACKET,
@@ -57316,9 +57368,11 @@ img.ProseMirror-separator {
   	The scanner provides an interface that takes a string of text as input, and
   	outputs an array of tokens instances that can be used for easy URL parsing.
   */
-  const NL = '\n'; // New line character
+  const CR = '\r'; // carriage-return character
+  const LF = '\n'; // line-feed character
   const EMOJI_VARIATION = '\ufe0f'; // Variation selector, follows heart and others
   const EMOJI_JOINER = '\u200d'; // zero-width joiner
+  const OBJECT_REPLACEMENT = '\ufffc'; // whitespace placeholder that sometimes appears in rich text editors
 
   let tlds = null,
     utlds = null; // don't change so only have to be computed once
@@ -57404,49 +57458,73 @@ img.ProseMirror-separator {
       [numeric]: true
     });
     tr(Num, DIGIT, Num);
+    const Asciinumeric = tr(Num, ASCII_LETTER, ASCIINUMERICAL, {
+      [asciinumeric]: true
+    });
+    const Alphanumeric = tr(Num, LETTER, ALPHANUMERICAL, {
+      [alphanumeric$1]: true
+    });
 
     // State which emits a word token
     const Word = tr(Start, ASCII_LETTER, WORD, {
       [ascii]: true
     });
+    tr(Word, DIGIT, Asciinumeric);
     tr(Word, ASCII_LETTER, Word);
+    tr(Asciinumeric, DIGIT, Asciinumeric);
+    tr(Asciinumeric, ASCII_LETTER, Asciinumeric);
 
     // Same as previous, but specific to non-fsm.ascii alphabet words
     const UWord = tr(Start, LETTER, UWORD, {
       [alpha]: true
     });
     tr(UWord, ASCII_LETTER); // Non-accepting
+    tr(UWord, DIGIT, Alphanumeric);
     tr(UWord, LETTER, UWord);
+    tr(Alphanumeric, DIGIT, Alphanumeric);
+    tr(Alphanumeric, ASCII_LETTER); // Non-accepting
+    tr(Alphanumeric, LETTER, Alphanumeric); // Non-accepting
 
     // Whitespace jumps
     // Tokens of only non-newline whitespace are arbitrarily long
     // If any whitespace except newline, more whitespace!
-    const Ws = tr(Start, SPACE, WS, {
+    const Nl = tt(Start, LF, NL, {
+      [whitespace]: true
+    });
+    const Cr = tt(Start, CR, WS, {
       [whitespace]: true
     });
-    tt(Start, NL, NL$1, {
+    const Ws = tr(Start, SPACE, WS, {
       [whitespace]: true
     });
-    tt(Ws, NL); // non-accepting state to avoid mixing whitespaces
+    tt(Start, OBJECT_REPLACEMENT, Ws);
+    tt(Cr, LF, Nl); // \r\n
+    tt(Cr, OBJECT_REPLACEMENT, Ws);
+    tr(Cr, SPACE, Ws);
+    tt(Ws, CR); // non-accepting state to avoid mixing whitespaces
+    tt(Ws, LF); // non-accepting state to avoid mixing whitespaces
     tr(Ws, SPACE, Ws);
+    tt(Ws, OBJECT_REPLACEMENT, Ws);
 
     // Emoji tokens. They are not grouped by the scanner except in cases where a
     // zero-width joiner is present
     const Emoji = tr(Start, EMOJI, EMOJI$1, {
       [emoji]: true
     });
+    tt(Emoji, '#'); // no transition, emoji regex seems to match #
     tr(Emoji, EMOJI, Emoji);
     tt(Emoji, EMOJI_VARIATION, Emoji);
     // tt(Start, EMOJI_VARIATION, Emoji); // This one is sketchy
 
     const EmojiJoiner = tt(Emoji, EMOJI_JOINER);
+    tt(EmojiJoiner, '#');
     tr(EmojiJoiner, EMOJI, Emoji);
     // tt(EmojiJoiner, EMOJI_VARIATION, Emoji); // also sketchy
 
     // Generates states for top-level domains
     // Note that this is most accurate when tlds are in alphabetical order
-    const wordjr = [[ASCII_LETTER, Word]];
-    const uwordjr = [[ASCII_LETTER, null], [LETTER, UWord]];
+    const wordjr = [[ASCII_LETTER, Word], [DIGIT, Asciinumeric]];
+    const uwordjr = [[ASCII_LETTER, null], [LETTER, UWord], [DIGIT, Alphanumeric]];
     for (let i = 0; i < tlds.length; i++) {
       fastts(Start, tlds[i], TLD, WORD, wordjr);
     }
@@ -58135,7 +58213,7 @@ img.ProseMirror-separator {
     // Types of tokens that can follow a URL and be part of the query string
     // but cannot be the very last characters
     // Characters that cannot appear in the URL at all should be excluded
-    const qsNonAccepting = [APOSTROPHE, COLON, COMMA, DOT, EXCLAMATION, QUERY, QUOTE, SEMI, OPENANGLEBRACKET, CLOSEANGLEBRACKET, OPENBRACE, CLOSEBRACE, CLOSEBRACKET, OPENBRACKET, OPENPAREN, CLOSEPAREN, FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN, LEFTCORNERBRACKET, RIGHTCORNERBRACKET, LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET, FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN];
+    const qsNonAccepting = [COLON, COMMA, DOT, EXCLAMATION, PERCENT, QUERY, QUOTE, SEMI, OPENANGLEBRACKET, CLOSEANGLEBRACKET, OPENBRACE, CLOSEBRACE, CLOSEBRACKET, OPENBRACKET, OPENPAREN, CLOSEPAREN, FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN, LEFTCORNERBRACKET, RIGHTCORNERBRACKET, LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET, FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN];
 
     // For addresses without the mailto prefix
     // Tokens allowed in the localpart of the email
@@ -58180,6 +58258,7 @@ img.ProseMirror-separator {
 
     // Hyphen can jump back to a domain name
     const EmailDomainHyphen = tt(EmailDomain, HYPHEN); // parsed string starts with local email info + @ with a potential domain name
+    tt(EmailDomainHyphen, HYPHEN, EmailDomainHyphen);
     ta(EmailDomainHyphen, groups.domain, EmailDomain);
     ta(Email$1, groups.domain, EmailDomain);
     tt(Email$1, DOT, EmailDomainDot);
@@ -58194,6 +58273,7 @@ img.ProseMirror-separator {
     // (but not TLDs)
     const DomainHyphen = tt(Domain, HYPHEN); // domain followed by hyphen
     const DomainDot = tt(Domain, DOT); // domain followed by DOT
+    tt(DomainHyphen, HYPHEN, DomainHyphen);
     ta(DomainHyphen, groups.domain, Domain);
     ta(DomainDot, localpartAccepting, Localpart);
     ta(DomainDot, groups.domain, Domain);
@@ -58244,6 +58324,7 @@ img.ProseMirror-separator {
     // Force URL with scheme prefix followed by anything sane
     ta(SchemeColon, groups.domain, Url$1);
     tt(SchemeColon, SLASH, Url$1);
+    tt(SchemeColon, QUERY, Url$1);
     ta(UriPrefix, groups.domain, Url$1);
     ta(UriPrefix, qsAccepting, Url$1);
     tt(UriPrefix, SLASH, Url$1);
@@ -58292,7 +58373,7 @@ img.ProseMirror-separator {
       tt(UrlOpenSyms, CLOSE, Url$1);
     }
     tt(Start, LOCALHOST, DomainDotTld); // localhost is a valid URL state
-    tt(Start, NL$1, Nl); // single new line
+    tt(Start, NL, Nl); // single new line
 
     return {
       start: Start,
@@ -58447,7 +58528,7 @@ img.ProseMirror-separator {
    * Detect URLs with the following additional protocol. Anything with format
    * "protocol://..." will be considered a link. If `optionalSlashSlash` is set to
    * `true`, anything with format "protocol:..." will be considered a link.
-   * @param {string} protocol
+   * @param {string} scheme
    * @param {boolean} [optionalSlashSlash]
    */
   function registerCustomProtocol(scheme, optionalSlashSlash = false) {
@@ -58841,9 +58922,25 @@ img.ProseMirror-separator {
       addCommands() {
           return {
               setLink: attributes => ({ chain }) => {
+                  const { href } = attributes;
+                  if (!this.options.isAllowedUri(href, {
+                      defaultValidate: url => !!isAllowedUri(url, this.options.protocols),
+                      protocols: this.options.protocols,
+                      defaultProtocol: this.options.defaultProtocol,
+                  })) {
+                      return false;
+                  }
                   return chain().setMark(this.name, attributes).setMeta('preventAutolink', true).run();
               },
               toggleLink: attributes => ({ chain }) => {
+                  const { href } = attributes;
+                  if (!this.options.isAllowedUri(href, {
+                      defaultValidate: url => !!isAllowedUri(url, this.options.protocols),
+                      protocols: this.options.protocols,
+                      defaultProtocol: this.options.defaultProtocol,
+                  })) {
+                      return false;
+                  }
                   return chain()
                       .toggleMark(this.name, attributes, { extendEmptyMarkRange: true })
                       .setMeta('preventAutolink', true)
@@ -58959,13 +59056,15 @@ img.ProseMirror-separator {
 
   function findSuggestionMatch(config) {
       var _a;
-      const { char, allowSpaces, allowedPrefixes, startOfLine, $position, } = config;
+      const { char, allowSpaces: allowSpacesOption, allowToIncludeChar, allowedPrefixes, startOfLine, $position, } = config;
+      const allowSpaces = allowSpacesOption && !allowToIncludeChar;
       const escapedChar = escapeForRegEx(char);
       const suffix = new RegExp(`\\s${escapedChar}$`);
       const prefix = startOfLine ? '^' : '';
+      const finalEscapedChar = allowToIncludeChar ? '' : escapedChar;
       const regexp = allowSpaces
-          ? new RegExp(`${prefix}${escapedChar}.*?(?=\\s${escapedChar}|$)`, 'gm')
-          : new RegExp(`${prefix}(?:^)?${escapedChar}[^\\s${escapedChar}]*`, 'gm');
+          ? new RegExp(`${prefix}${escapedChar}.*?(?=\\s${finalEscapedChar}|$)`, 'gm')
+          : new RegExp(`${prefix}(?:^)?${escapedChar}[^\\s${finalEscapedChar}]*`, 'gm');
       const text = ((_a = $position.nodeBefore) === null || _a === void 0 ? void 0 : _a.isText) && $position.nodeBefore.text;
       if (!text) {
           return null;
@@ -59010,7 +59109,7 @@ img.ProseMirror-separator {
    * This utility allows you to create suggestions.
    * @see https://tiptap.dev/api/utilities/suggestion
    */
-  function Suggestion({ pluginKey = SuggestionPluginKey, editor, char = '@', allowSpaces = false, allowedPrefixes = [' '], startOfLine = false, decorationTag = 'span', decorationClass = 'suggestion', command = () => null, items = () => [], render = () => ({}), allow = () => true, findSuggestionMatch: findSuggestionMatch$1 = findSuggestionMatch, }) {
+  function Suggestion({ pluginKey = SuggestionPluginKey, editor, char = '@', allowSpaces = false, allowToIncludeChar = false, allowedPrefixes = [' '], startOfLine = false, decorationTag = 'span', decorationClass = 'suggestion', command = () => null, items = () => [], render = () => ({}), allow = () => true, findSuggestionMatch: findSuggestionMatch$1 = findSuggestionMatch, }) {
       let props;
       const renderer = render === null || render === void 0 ? void 0 : render();
       const plugin = new Plugin({
@@ -59127,6 +59226,7 @@ img.ProseMirror-separator {
                       const match = findSuggestionMatch$1({
                           char,
                           allowSpaces,
+                          allowToIncludeChar,
                           allowedPrefixes,
                           startOfLine,
                           $position: selection.$from,
@@ -68290,20 +68390,12 @@ focus outline in that case.
         const size = this.getSize();
         const scrollOffset = this.getScrollOffset();
         if (align === "auto") {
-          if (toOffset <= scrollOffset) {
-            align = "start";
-          } else if (toOffset >= scrollOffset + size) {
+          if (toOffset >= scrollOffset + size) {
             align = "end";
-          } else {
-            align = "start";
           }
         }
-        if (align === "start") {
-          toOffset = toOffset;
-        } else if (align === "end") {
-          toOffset = toOffset - size;
-        } else if (align === "center") {
-          toOffset = toOffset - size / 2;
+        if (align === "end") {
+          toOffset -= size;
         }
         const scrollSizeProp = this.options.horizontal ? "scrollWidth" : "scrollHeight";
         const scrollSize = this.scrollElement ? "document" in this.scrollElement ? this.scrollElement.document.documentElement[scrollSizeProp] : this.scrollElement[scrollSizeProp] : 0;
@@ -68327,8 +68419,27 @@ focus outline in that case.
             return [scrollOffset, align];
           }
         }
-        const toOffset = align === "end" ? item.end + this.options.scrollPaddingEnd : item.start - this.options.scrollPaddingStart;
-        return [this.getOffsetForAlignment(toOffset, align), align];
+        const centerOffset = item.start - this.options.scrollPaddingStart + (item.size - size) / 2;
+        switch (align) {
+          case "center":
+            return [this.getOffsetForAlignment(centerOffset, align), align];
+          case "end":
+            return [
+              this.getOffsetForAlignment(
+                item.end + this.options.scrollPaddingEnd,
+                align
+              ),
+              align
+            ];
+          default:
+            return [
+              this.getOffsetForAlignment(
+                item.start - this.options.scrollPaddingStart,
+                align
+              ),
+              align
+            ];
+        }
       };
       this.isDynamicMode = () => this.elementsCache.size > 0;
       this.cancelScrollToIndex = () => {