@lexical/react 0.12.1 → 0.12.3

package/LexicalAutoEmbedPlugin.d.ts

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-import type { LexicalNode } from 'lexical';
+import type { CommandListenerPriority, LexicalNode } from 'lexical';
 import { MenuOption, MenuRenderFn } from '@lexical/react/LexicalNodeMenuPlugin';
 import { LexicalCommand, LexicalEditor } from 'lexical';
 export type EmbedMatchResult<TEmbedMatchResult = unknown> = {
@@ -33,6 +33,7 @@ type LexicalAutoEmbedPluginProps<TEmbedConfig extends EmbedConfig> = {
     onOpenEmbedModalForConfig: (embedConfig: TEmbedConfig) => void;
     getMenuOptions: (activeEmbedConfig: TEmbedConfig, embedFn: () => void, dismissFn: () => void) => Array<AutoEmbedOption>;
     menuRenderFn: MenuRenderFn<AutoEmbedOption>;
+    menuCommandPriority?: CommandListenerPriority;
 };
-export declare function LexicalAutoEmbedPlugin<TEmbedConfig extends EmbedConfig>({ embedConfigs, onOpenEmbedModalForConfig, getMenuOptions, menuRenderFn, }: LexicalAutoEmbedPluginProps<TEmbedConfig>): JSX.Element | null;
+export declare function LexicalAutoEmbedPlugin<TEmbedConfig extends EmbedConfig>({ embedConfigs, onOpenEmbedModalForConfig, getMenuOptions, menuRenderFn, menuCommandPriority, }: LexicalAutoEmbedPluginProps<TEmbedConfig>): JSX.Element | null;
 export {};

package/LexicalAutoEmbedPlugin.dev.js

@@ -28,13 +28,13 @@ class AutoEmbedOption extends LexicalNodeMenuPlugin.MenuOption {
     this.title = title;
     this.onSelect = options.onSelect.bind(this);
   }
-
 }
 function LexicalAutoEmbedPlugin({
   embedConfigs,
   onOpenEmbedModalForConfig,
   getMenuOptions,
-  menuRenderFn
+  menuRenderFn,
+  menuCommandPriority = lexical.COMMAND_PRIORITY_LOW
 }) {
   const [editor] = LexicalComposerContext.useLexicalComposerContext();
   const [nodeKey, setNodeKey] = React.useState(null);
@@ -46,12 +46,10 @@ function LexicalAutoEmbedPlugin({
   const checkIfLinkNodeIsEmbeddable = React.useCallback(key => {
     editor.getEditorState().read(async () => {
       const linkNode = lexical.$getNodeByKey(key);
-
       if (link.$isLinkNode(linkNode)) {
         for (let i = 0; i < embedConfigs.length; i++) {
           const embedConfig = embedConfigs[i];
           const urlMatch = await Promise.resolve(embedConfig.parseUrl(linkNode.__url));
-
           if (urlMatch != null) {
             setActiveEmbedConfig(embedConfig);
             setNodeKey(linkNode.getKey());
@@ -73,7 +71,6 @@ function LexicalAutoEmbedPlugin({
         }
       }
     };
-
     return utils.mergeRegister(...[link.LinkNode, link.AutoLinkNode].map(Klass => editor.registerMutationListener(Klass, (...args) => listener(...args))));
   }, [checkIfLinkNodeIsEmbeddable, editor, embedConfigs, nodeKey, reset]);
   React.useEffect(() => {
@@ -81,12 +78,10 @@ function LexicalAutoEmbedPlugin({
       const embedConfig = embedConfigs.find(({
         type
       }) => type === embedConfigType);
-
       if (embedConfig) {
         onOpenEmbedModalForConfig(embedConfig);
         return true;
       }
-
       return false;
     }, lexical.COMMAND_PRIORITY_EDITOR);
   }, [editor, embedConfigs, onOpenEmbedModalForConfig]);
@@ -94,25 +89,19 @@ function LexicalAutoEmbedPlugin({
     if (activeEmbedConfig != null && nodeKey != null) {
       const linkNode = editor.getEditorState().read(() => {
         const node = lexical.$getNodeByKey(nodeKey);
-
         if (link.$isLinkNode(node)) {
           return node;
         }
-
         return null;
       });
-
       if (link.$isLinkNode(linkNode)) {
         const result = await Promise.resolve(activeEmbedConfig.parseUrl(linkNode.__url));
-
         if (result != null) {
           editor.update(() => {
             if (!lexical.$getSelection()) {
               linkNode.selectEnd();
             }
-
             activeEmbedConfig.insertNode(editor, result);
-
             if (linkNode.isAttached()) {
               linkNode.remove();
             }
@@ -135,7 +124,8 @@ function LexicalAutoEmbedPlugin({
     onClose: reset,
     onSelectOption: onSelectOption,
     options: options,
-    menuRenderFn: menuRenderFn
+    menuRenderFn: menuRenderFn,
+    commandPriority: menuCommandPriority
   }) : null;
 }
 

package/LexicalAutoEmbedPlugin.prod.js

@@ -5,6 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 'use strict';var e=require("@lexical/link"),k=require("@lexical/react/LexicalComposerContext"),l=require("@lexical/react/LexicalNodeMenuPlugin"),q=require("@lexical/utils"),r=require("lexical"),z=require("react");let A=r.createCommand("INSERT_EMBED_COMMAND");class B extends l.MenuOption{constructor(f,n){super(f);this.title=f;this.onSelect=n.onSelect.bind(this)}}exports.AutoEmbedOption=B;exports.INSERT_EMBED_COMMAND=A;
-exports.LexicalAutoEmbedPlugin=function({embedConfigs:f,onOpenEmbedModalForConfig:n,getMenuOptions:t,menuRenderFn:C}){let [c]=k.useLexicalComposerContext(),[g,u]=z.useState(null),[h,v]=z.useState(null),m=z.useCallback(()=>{u(null);v(null)},[]),w=z.useCallback(b=>{c.getEditorState().read(async()=>{const a=r.$getNodeByKey(b);if(e.$isLinkNode(a))for(let d=0;d<f.length;d++){const p=f[d];null!=await Promise.resolve(p.parseUrl(a.__url))&&(v(p),u(a.getKey()))}})},[c,f]);z.useEffect(()=>{let b=(a,{updateTags:d,
-dirtyLeaves:p})=>{for(const [x,D]of a)"created"===D&&d.has("paste")&&3>=p.size?w(x):x===g&&m()};return q.mergeRegister(...[e.LinkNode,e.AutoLinkNode].map(a=>c.registerMutationListener(a,(...d)=>b(...d))))},[w,c,f,g,m]);z.useEffect(()=>c.registerCommand(A,b=>{let a=f.find(({type:d})=>d===b);return a?(n(a),!0):!1},r.COMMAND_PRIORITY_EDITOR),[c,f,n]);let y=z.useCallback(async()=>{if(null!=h&&null!=g){const b=c.getEditorState().read(()=>{const a=r.$getNodeByKey(g);return e.$isLinkNode(a)?a:null});if(e.$isLinkNode(b)){const a=
-await Promise.resolve(h.parseUrl(b.__url));null!=a&&c.update(()=>{r.$getSelection()||b.selectEnd();h.insertNode(c,a);b.isAttached()&&b.remove()})}}},[h,c,g]),E=z.useMemo(()=>null!=h&&null!=g?t(h,y,m):[],[h,y,t,g,m]),F=z.useCallback((b,a,d)=>{c.update(()=>{b.onSelect(a);d()})},[c]);return null!=g?z.createElement(l.LexicalNodeMenuPlugin,{nodeKey:g,onClose:m,onSelectOption:F,options:E,menuRenderFn:C}):null};exports.URL_MATCHER=/((https?:\/\/(www\.)?)|(www\.))[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)/
+exports.LexicalAutoEmbedPlugin=function({embedConfigs:f,onOpenEmbedModalForConfig:n,getMenuOptions:t,menuRenderFn:C,menuCommandPriority:D=r.COMMAND_PRIORITY_LOW}){let [c]=k.useLexicalComposerContext(),[g,u]=z.useState(null),[h,v]=z.useState(null),m=z.useCallback(()=>{u(null);v(null)},[]),w=z.useCallback(b=>{c.getEditorState().read(async()=>{const a=r.$getNodeByKey(b);if(e.$isLinkNode(a))for(let d=0;d<f.length;d++){const p=f[d];null!=await Promise.resolve(p.parseUrl(a.__url))&&(v(p),u(a.getKey()))}})},
+[c,f]);z.useEffect(()=>{let b=(a,{updateTags:d,dirtyLeaves:p})=>{for(const [x,E]of a)"created"===E&&d.has("paste")&&3>=p.size?w(x):x===g&&m()};return q.mergeRegister(...[e.LinkNode,e.AutoLinkNode].map(a=>c.registerMutationListener(a,(...d)=>b(...d))))},[w,c,f,g,m]);z.useEffect(()=>c.registerCommand(A,b=>{let a=f.find(({type:d})=>d===b);return a?(n(a),!0):!1},r.COMMAND_PRIORITY_EDITOR),[c,f,n]);let y=z.useCallback(async()=>{if(null!=h&&null!=g){const b=c.getEditorState().read(()=>{const a=r.$getNodeByKey(g);
+return e.$isLinkNode(a)?a:null});if(e.$isLinkNode(b)){const a=await Promise.resolve(h.parseUrl(b.__url));null!=a&&c.update(()=>{r.$getSelection()||b.selectEnd();h.insertNode(c,a);b.isAttached()&&b.remove()})}}},[h,c,g]),F=z.useMemo(()=>null!=h&&null!=g?t(h,y,m):[],[h,y,t,g,m]),G=z.useCallback((b,a,d)=>{c.update(()=>{b.onSelect(a);d()})},[c]);return null!=g?z.createElement(l.LexicalNodeMenuPlugin,{nodeKey:g,onClose:m,onSelectOption:G,options:F,menuRenderFn:C,commandPriority:D}):null};
+exports.URL_MATCHER=/((https?:\/\/(www\.)?)|(www\.))[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)/

package/LexicalAutoFocusPlugin.dev.js

@@ -28,7 +28,6 @@ function AutoFocusPlugin({
       // of this plugin, which should preserve focus too.
       const activeElement = document.activeElement;
       const rootElement = editor.getRootElement();
-
       if (rootElement !== null && (activeElement === null || !rootElement.contains(activeElement))) {
         // Note: preventScroll won't work in Webkit.
         rootElement.focus({

package/LexicalAutoLinkPlugin.dev.js

@@ -27,194 +27,251 @@ function createLinkMatcherWithRegExp(regExp, urlTransformer = text => text) {
       index: match.index,
       length: match[0].length,
       text: match[0],
-      url: urlTransformer(text)
+      url: urlTransformer(match[0])
     };
   };
 }
-
 function findFirstMatch(text, matchers) {
   for (let i = 0; i < matchers.length; i++) {
     const match = matchers[i](text);
-
     if (match) {
       return match;
     }
   }
-
   return null;
 }
-
 const PUNCTUATION_OR_SPACE = /[.,;\s]/;
-
 function isSeparator(char) {
   return PUNCTUATION_OR_SPACE.test(char);
 }
-
 function endsWithSeparator(textContent) {
   return isSeparator(textContent[textContent.length - 1]);
 }
-
 function startsWithSeparator(textContent) {
   return isSeparator(textContent[0]);
 }
-
 function isPreviousNodeValid(node) {
   let previousNode = node.getPreviousSibling();
-
   if (lexical.$isElementNode(previousNode)) {
     previousNode = previousNode.getLastDescendant();
   }
-
   return previousNode === null || lexical.$isLineBreakNode(previousNode) || lexical.$isTextNode(previousNode) && endsWithSeparator(previousNode.getTextContent());
 }
-
 function isNextNodeValid(node) {
   let nextNode = node.getNextSibling();
-
   if (lexical.$isElementNode(nextNode)) {
     nextNode = nextNode.getFirstDescendant();
   }
-
   return nextNode === null || lexical.$isLineBreakNode(nextNode) || lexical.$isTextNode(nextNode) && startsWithSeparator(nextNode.getTextContent());
 }
-
-function isContentAroundIsValid(matchStart, matchEnd, text, node) {
-  const contentBeforeIsValid = matchStart > 0 ? isSeparator(text[matchStart - 1]) : isPreviousNodeValid(node);
-
+function isContentAroundIsValid(matchStart, matchEnd, text, nodes) {
+  const contentBeforeIsValid = matchStart > 0 ? isSeparator(text[matchStart - 1]) : isPreviousNodeValid(nodes[0]);
   if (!contentBeforeIsValid) {
     return false;
   }
-
-  const contentAfterIsValid = matchEnd < text.length ? isSeparator(text[matchEnd]) : isNextNodeValid(node);
+  const contentAfterIsValid = matchEnd < text.length ? isSeparator(text[matchEnd]) : isNextNodeValid(nodes[nodes.length - 1]);
   return contentAfterIsValid;
 }
-
-function handleLinkCreation(node, matchers, onChange) {
-  const nodeText = node.getTextContent();
-  let text = nodeText;
-  let invalidMatchEnd = 0;
-  let remainingTextNode = node;
+function extractMatchingNodes(nodes, startIndex, endIndex) {
+  const unmodifiedBeforeNodes = [];
+  const matchingNodes = [];
+  const unmodifiedAfterNodes = [];
+  let matchingOffset = 0;
+  let currentOffset = 0;
+  const currentNodes = [...nodes];
+  while (currentNodes.length > 0) {
+    const currentNode = currentNodes[0];
+    const currentNodeText = currentNode.getTextContent();
+    const currentNodeLength = currentNodeText.length;
+    const currentNodeStart = currentOffset;
+    const currentNodeEnd = currentOffset + currentNodeLength;
+    if (currentNodeEnd <= startIndex) {
+      unmodifiedBeforeNodes.push(currentNode);
+      matchingOffset += currentNodeLength;
+    } else if (currentNodeStart >= endIndex) {
+      unmodifiedAfterNodes.push(currentNode);
+    } else {
+      matchingNodes.push(currentNode);
+    }
+    currentOffset += currentNodeLength;
+    currentNodes.shift();
+  }
+  return [matchingOffset, unmodifiedBeforeNodes, matchingNodes, unmodifiedAfterNodes];
+}
+function createAutoLinkNode(nodes, startIndex, endIndex, match) {
+  const linkNode = link.$createAutoLinkNode(match.url, match.attributes);
+  if (nodes.length === 1) {
+    let remainingTextNode = nodes[0];
+    let linkTextNode;
+    if (startIndex === 0) {
+      [linkTextNode, remainingTextNode] = remainingTextNode.splitText(endIndex);
+    } else {
+      [, linkTextNode, remainingTextNode] = remainingTextNode.splitText(startIndex, endIndex);
+    }
+    const textNode = lexical.$createTextNode(match.text);
+    textNode.setFormat(linkTextNode.getFormat());
+    textNode.setDetail(linkTextNode.getDetail());
+    linkNode.append(textNode);
+    linkTextNode.replace(linkNode);
+    return remainingTextNode;
+  } else if (nodes.length > 1) {
+    const firstTextNode = nodes[0];
+    let offset = firstTextNode.getTextContent().length;
+    let firstLinkTextNode;
+    if (startIndex === 0) {
+      firstLinkTextNode = firstTextNode;
+    } else {
+      [, firstLinkTextNode] = firstTextNode.splitText(startIndex);
+    }
+    const linkNodes = [];
+    let remainingTextNode;
+    for (let i = 1; i < nodes.length; i++) {
+      const currentNode = nodes[i];
+      const currentNodeText = currentNode.getTextContent();
+      const currentNodeLength = currentNodeText.length;
+      const currentNodeStart = offset;
+      const currentNodeEnd = offset + currentNodeLength;
+      if (currentNodeStart < endIndex) {
+        if (currentNodeEnd <= endIndex) {
+          linkNodes.push(currentNode);
+        } else {
+          const [linkTextNode, endNode] = currentNode.splitText(endIndex - currentNodeStart);
+          linkNodes.push(linkTextNode);
+          remainingTextNode = endNode;
+        }
+      }
+      offset += currentNodeLength;
+    }
+    const selection = lexical.$getSelection();
+    const selectedTextNode = selection ? selection.getNodes().find(lexical.$isTextNode) : undefined;
+    const textNode = lexical.$createTextNode(firstLinkTextNode.getTextContent());
+    textNode.setFormat(firstLinkTextNode.getFormat());
+    textNode.setDetail(firstLinkTextNode.getDetail());
+    linkNode.append(textNode, ...linkNodes);
+    // it does not preserve caret position if caret was at the first text node
+    // so we need to restore caret position
+    if (selectedTextNode && selectedTextNode === firstLinkTextNode) {
+      if (lexical.$isRangeSelection(selection)) {
+        textNode.select(selection.anchor.offset, selection.focus.offset);
+      } else if (lexical.$isNodeSelection(selection)) {
+        textNode.select(0, textNode.getTextContent().length);
+      }
+    }
+    firstLinkTextNode.replace(linkNode);
+    return remainingTextNode;
+  }
+  return undefined;
+}
+function handleLinkCreation(nodes, matchers, onChange) {
+  let currentNodes = [...nodes];
+  let text = currentNodes.map(node => node.getTextContent()).join('');
   let match;
-
+  let invalidMatchEnd = 0;
   while ((match = findFirstMatch(text, matchers)) && match !== null) {
     const matchStart = match.index;
     const matchLength = match.length;
     const matchEnd = matchStart + matchLength;
-    const isValid = isContentAroundIsValid(invalidMatchEnd + matchStart, invalidMatchEnd + matchEnd, nodeText, node);
-
+    const isValid = isContentAroundIsValid(invalidMatchEnd + matchStart, invalidMatchEnd + matchEnd, text, currentNodes);
     if (isValid) {
-      let linkTextNode;
-
-      if (invalidMatchEnd + matchStart === 0) {
-        [linkTextNode, remainingTextNode] = remainingTextNode.splitText(invalidMatchEnd + matchLength);
-      } else {
-        [, linkTextNode, remainingTextNode] = remainingTextNode.splitText(invalidMatchEnd + matchStart, invalidMatchEnd + matchStart + matchLength);
-      }
-
-      const linkNode = link.$createAutoLinkNode(match.url, match.attributes);
-      const textNode = lexical.$createTextNode(match.text);
-      textNode.setFormat(linkTextNode.getFormat());
-      textNode.setDetail(linkTextNode.getDetail());
-      linkNode.append(textNode);
-      linkTextNode.replace(linkNode);
+      const [matchingOffset,, matchingNodes, unmodifiedAfterNodes] = extractMatchingNodes(currentNodes, invalidMatchEnd + matchStart, invalidMatchEnd + matchEnd);
+      const actualMatchStart = invalidMatchEnd + matchStart - matchingOffset;
+      const actualMatchEnd = invalidMatchEnd + matchEnd - matchingOffset;
+      const remainingTextNode = createAutoLinkNode(matchingNodes, actualMatchStart, actualMatchEnd, match);
+      currentNodes = remainingTextNode ? [remainingTextNode, ...unmodifiedAfterNodes] : unmodifiedAfterNodes;
       onChange(match.url, null);
       invalidMatchEnd = 0;
     } else {
       invalidMatchEnd += matchEnd;
     }
-
     text = text.substring(matchEnd);
   }
 }
-
 function handleLinkEdit(linkNode, matchers, onChange) {
   // Check children are simple text
   const children = linkNode.getChildren();
   const childrenLength = children.length;
-
   for (let i = 0; i < childrenLength; i++) {
     const child = children[i];
-
     if (!lexical.$isTextNode(child) || !child.isSimpleText()) {
       replaceWithChildren(linkNode);
       onChange(null, linkNode.getURL());
       return;
     }
-  } // Check text content fully matches
-
+  }
 
+  // Check text content fully matches
   const text = linkNode.getTextContent();
   const match = findFirstMatch(text, matchers);
-
   if (match === null || match.text !== text) {
     replaceWithChildren(linkNode);
     onChange(null, linkNode.getURL());
     return;
-  } // Check neighbors
-
+  }
 
+  // Check neighbors
   if (!isPreviousNodeValid(linkNode) || !isNextNodeValid(linkNode)) {
     replaceWithChildren(linkNode);
     onChange(null, linkNode.getURL());
     return;
   }
-
   const url = linkNode.getURL();
-
   if (url !== match.url) {
     linkNode.setURL(match.url);
     onChange(match.url, url);
   }
-
   if (match.attributes) {
     const rel = linkNode.getRel();
-
     if (rel !== match.attributes.rel) {
       linkNode.setRel(match.attributes.rel || null);
       onChange(match.attributes.rel || null, rel);
     }
-
     const target = linkNode.getTarget();
-
     if (target !== match.attributes.target) {
       linkNode.setTarget(match.attributes.target || null);
       onChange(match.attributes.target || null, target);
     }
   }
-} // Bad neighbours are edits in neighbor nodes that make AutoLinks incompatible.
-// Given the creation preconditions, these can only be simple text nodes.
-
+}
 
+// Bad neighbors are edits in neighbor nodes that make AutoLinks incompatible.
+// Given the creation preconditions, these can only be simple text nodes.
 function handleBadNeighbors(textNode, matchers, onChange) {
   const previousSibling = textNode.getPreviousSibling();
   const nextSibling = textNode.getNextSibling();
   const text = textNode.getTextContent();
-
   if (link.$isAutoLinkNode(previousSibling) && !startsWithSeparator(text)) {
     previousSibling.append(textNode);
     handleLinkEdit(previousSibling, matchers, onChange);
     onChange(null, previousSibling.getURL());
   }
-
   if (link.$isAutoLinkNode(nextSibling) && !endsWithSeparator(text)) {
     replaceWithChildren(nextSibling);
     handleLinkEdit(nextSibling, matchers, onChange);
     onChange(null, nextSibling.getURL());
   }
 }
-
 function replaceWithChildren(node) {
   const children = node.getChildren();
   const childrenLength = children.length;
-
   for (let j = childrenLength - 1; j >= 0; j--) {
     node.insertAfter(children[j]);
   }
-
   node.remove();
   return children.map(child => child.getLatest());
 }
-
+function getTextNodesToMatch(textNode) {
+  // check if next siblings are simple text nodes till a node contains a space separator
+  const textNodesToMatch = [textNode];
+  let nextSibling = textNode.getNextSibling();
+  while (nextSibling !== null && lexical.$isTextNode(nextSibling) && nextSibling.isSimpleText()) {
+    textNodesToMatch.push(nextSibling);
+    if (/[\s]/.test(nextSibling.getTextContent())) {
+      break;
+    }
+    nextSibling = nextSibling.getNextSibling();
+  }
+  return textNodesToMatch;
+}
 function useAutoLink(editor, matchers, onChange) {
   react.useEffect(() => {
     if (!editor.hasNodes([link.AutoLinkNode])) {
@@ -222,30 +279,26 @@ function useAutoLink(editor, matchers, onChange) {
         throw Error(`LexicalAutoLinkPlugin: AutoLinkNode not registered on editor`);
       }
     }
-
     const onChangeWrapped = (url, prevUrl) => {
       if (onChange) {
         onChange(url, prevUrl);
       }
     };
-
     return utils.mergeRegister(editor.registerNodeTransform(lexical.TextNode, textNode => {
       const parent = textNode.getParentOrThrow();
       const previous = textNode.getPreviousSibling();
-
       if (link.$isAutoLinkNode(parent)) {
         handleLinkEdit(parent, matchers, onChangeWrapped);
       } else if (!link.$isLinkNode(parent)) {
         if (textNode.isSimpleText() && (startsWithSeparator(textNode.getTextContent()) || !link.$isAutoLinkNode(previous))) {
-          handleLinkCreation(textNode, matchers, onChangeWrapped);
+          const textNodesToMatch = getTextNodesToMatch(textNode);
+          handleLinkCreation(textNodesToMatch, matchers, onChangeWrapped);
         }
-
         handleBadNeighbors(textNode, matchers, onChangeWrapped);
       }
     }));
   }, [editor, matchers, onChange]);
 }
-
 function AutoLinkPlugin({
   matchers,
   onChange

package/LexicalAutoLinkPlugin.prod.js

@@ -4,10 +4,14 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-'use strict';var h=require("@lexical/link"),n=require("@lexical/react/LexicalComposerContext"),p=require("@lexical/utils"),u=require("lexical"),w=require("react");function A(a){let b=new URLSearchParams;b.append("code",a);for(let c=1;c<arguments.length;c++)b.append("v",arguments[c]);throw Error(`Minified Lexical error #${a}; visit https://lexical.dev/docs/error?${b} for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}
-function B(a,b){for(let c=0;c<b.length;c++){let d=b[c](a);if(d)return d}return null}let C=/[.,;\s]/;function E(a){a=a.getPreviousSibling();u.$isElementNode(a)&&(a=a.getLastDescendant());var b;!(b=null===a||u.$isLineBreakNode(a))&&(b=u.$isTextNode(a))&&(a=a.getTextContent(),b=C.test(a[a.length-1]));return b}function F(a){a=a.getNextSibling();u.$isElementNode(a)&&(a=a.getFirstDescendant());return null===a||u.$isLineBreakNode(a)||u.$isTextNode(a)&&C.test(a.getTextContent()[0])}
-function G(a,b,c){var d=a.getChildren();let e=d.length;for(let f=0;f<e;f++){let l=d[f];if(!u.$isTextNode(l)||!l.isSimpleText()){H(a);c(null,a.getURL());return}}d=a.getTextContent();b=B(d,b);null===b||b.text!==d?(H(a),c(null,a.getURL())):E(a)&&F(a)?(d=a.getURL(),d!==b.url&&(a.setURL(b.url),c(b.url,d)),b.attributes&&(d=a.getRel(),d!==b.attributes.rel&&(a.setRel(b.attributes.rel||null),c(b.attributes.rel||null,d)),d=a.getTarget(),d!==b.attributes.target&&(a.setTarget(b.attributes.target||null),c(b.attributes.target||
-null,d)))):(H(a),c(null,a.getURL()))}function H(a){let b=a.getChildren();var c=b.length;for(--c;0<=c;c--)a.insertAfter(b[c]);a.remove();return b.map(d=>d.getLatest())}
-function I(a,b,c){w.useEffect(()=>{a.hasNodes([h.AutoLinkNode])||A(77);let d=(e,f)=>{c&&c(e,f)};return p.mergeRegister(a.registerNodeTransform(u.TextNode,e=>{var f=e.getParentOrThrow(),l=e.getPreviousSibling();if(h.$isAutoLinkNode(f))G(f,b,d);else if(!h.$isLinkNode(f)){if(e.isSimpleText()&&(C.test(e.getTextContent()[0])||!h.$isAutoLinkNode(l))){l=f=e.getTextContent();let m=0,v=e;for(var g;(g=B(l,b))&&null!==g;){let r=g.index,x=g.length,y=r+x;var t=m+r,q=m+y,z=f,D=e;if((0<t?C.test(z[t-1]):E(D))&&(q<
-z.length?C.test(z[q]):F(D))){var k=void 0;0===m+r?[k,v]=v.splitText(m+x):[,k,v]=v.splitText(m+r,m+r+x);t=h.$createAutoLinkNode(g.url,g.attributes);q=u.$createTextNode(g.text);q.setFormat(k.getFormat());q.setDetail(k.getDetail());t.append(q);k.replace(t);c&&c(g.url,null);m=0}else m+=y;l=l.substring(y)}}f=e.getPreviousSibling();g=e.getNextSibling();k=e.getTextContent();h.$isAutoLinkNode(f)&&!C.test(k[0])&&(f.append(e),G(f,b,d),e=f.getURL(),c&&c(null,e));h.$isAutoLinkNode(g)&&!C.test(k[k.length-1])&&
-(H(g),G(g,b,d),e=g.getURL(),c&&c(null,e))}}))},[a,b,c])}exports.AutoLinkPlugin=function({matchers:a,onChange:b}){let [c]=n.useLexicalComposerContext();I(c,a,b);return null};exports.createLinkMatcherWithRegExp=function(a,b=c=>c){return c=>{let d=a.exec(c);return null===d?null:{index:d.index,length:d[0].length,text:d[0],url:b(c)}}}
+'use strict';var k=require("@lexical/link"),n=require("@lexical/react/LexicalComposerContext"),p=require("@lexical/utils"),r=require("lexical"),t=require("react");function u(a){let c=new URLSearchParams;c.append("code",a);for(let b=1;b<arguments.length;b++)c.append("v",arguments[b]);throw Error(`Minified Lexical error #${a}; visit https://lexical.dev/docs/error?${c} for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}
+function v(a,c){for(let b=0;b<c.length;b++){let d=c[b](a);if(d)return d}return null}let w=/[.,;\s]/;function x(a){a=a.getPreviousSibling();r.$isElementNode(a)&&(a=a.getLastDescendant());var c;!(c=null===a||r.$isLineBreakNode(a))&&(c=r.$isTextNode(a))&&(a=a.getTextContent(),c=w.test(a[a.length-1]));return c}function y(a){a=a.getNextSibling();r.$isElementNode(a)&&(a=a.getFirstDescendant());return null===a||r.$isLineBreakNode(a)||r.$isTextNode(a)&&w.test(a.getTextContent()[0])}
+function z(a,c,b,d){return(0<a?w.test(b[a-1]):x(d[0]))?c<b.length?w.test(b[c]):y(d[d.length-1]):!1}function A(a,c,b){let d=[],f=[],e=[],g=0,h=0;for(a=[...a];0<a.length;){let l=a[0],m=l.getTextContent().length,q=h;h+m<=c?(d.push(l),g+=m):q>=b?e.push(l):f.push(l);h+=m;a.shift()}return[g,d,f,e]}
+function B(a,c,b,d){let f=k.$createAutoLinkNode(d.url,d.attributes);if(1===a.length){var e=a[0];0===c?[h,e]=e.splitText(b):[,h,e]=e.splitText(c,b);var g=r.$createTextNode(d.text);g.setFormat(h.getFormat());g.setDetail(h.getDetail());f.append(g);h.replace(f);return e}if(1<a.length){d=a[0];var h=d.getTextContent().length;0===c?e=d:[,e]=d.splitText(c);c=[];for(d=1;d<a.length;d++){let l=a[d],m=l.getTextContent().length,q=h,E=h+m;if(q<b)if(E<=b)c.push(l);else{let [F,G]=l.splitText(b-q);c.push(F);g=G}h+=
+m}a=(b=r.$getSelection())?b.getNodes().find(r.$isTextNode):void 0;h=r.$createTextNode(e.getTextContent());h.setFormat(e.getFormat());h.setDetail(e.getDetail());f.append(h,...c);a&&a===e&&(r.$isRangeSelection(b)?h.select(b.anchor.offset,b.focus.offset):r.$isNodeSelection(b)&&h.select(0,h.getTextContent().length));e.replace(f);return g}}
+function C(a,c,b){var d=[...a];a=d.map(g=>g.getTextContent()).join("");let f,e=0;for(;(f=v(a,c))&&null!==f;){let g=f.index,h=g+f.length;if(z(e+g,e+h,a,d)){let [l,,m,q]=A(d,e+g,e+h);d=(d=B(m,e+g-l,e+h-l,f))?[d,...q]:q;b(f.url,null);e=0}else e+=h;a=a.substring(h)}}
+function D(a,c,b){var d=a.getChildren();let f=d.length;for(let e=0;e<f;e++){let g=d[e];if(!r.$isTextNode(g)||!g.isSimpleText()){H(a);b(null,a.getURL());return}}d=a.getTextContent();c=v(d,c);null===c||c.text!==d?(H(a),b(null,a.getURL())):x(a)&&y(a)?(d=a.getURL(),d!==c.url&&(a.setURL(c.url),b(c.url,d)),c.attributes&&(d=a.getRel(),d!==c.attributes.rel&&(a.setRel(c.attributes.rel||null),b(c.attributes.rel||null,d)),d=a.getTarget(),d!==c.attributes.target&&(a.setTarget(c.attributes.target||null),b(c.attributes.target||
+null,d)))):(H(a),b(null,a.getURL()))}function H(a){let c=a.getChildren();var b=c.length;for(--b;0<=b;b--)a.insertAfter(c[b]);a.remove();return c.map(d=>d.getLatest())}
+function I(a,c,b){t.useEffect(()=>{a.hasNodes([k.AutoLinkNode])||u(77);let d=(f,e)=>{b&&b(f,e)};return p.mergeRegister(a.registerNodeTransform(r.TextNode,f=>{var e=f.getParentOrThrow(),g=f.getPreviousSibling();if(k.$isAutoLinkNode(e))D(e,c,d);else if(!k.$isLinkNode(e)){if(f.isSimpleText()&&(w.test(f.getTextContent()[0])||!k.$isAutoLinkNode(g))){e=[f];for(g=f.getNextSibling();null!==g&&r.$isTextNode(g)&&g.isSimpleText();){e.push(g);if(/[\s]/.test(g.getTextContent()))break;g=g.getNextSibling()}C(e,
+c,d)}let h=f.getPreviousSibling();e=f.getNextSibling();g=f.getTextContent();k.$isAutoLinkNode(h)&&!w.test(g[0])&&(h.append(f),D(h,c,d),f=h.getURL(),b&&b(null,f));k.$isAutoLinkNode(e)&&!w.test(g[g.length-1])&&(H(e),D(e,c,d),f=e.getURL(),b&&b(null,f))}}))},[a,c,b])}exports.AutoLinkPlugin=function({matchers:a,onChange:c}){let [b]=n.useLexicalComposerContext();I(b,a,c);return null};
+exports.createLinkMatcherWithRegExp=function(a,c=b=>b){return b=>{b=a.exec(b);return null===b?null:{index:b.index,length:b[0].length,text:b[0],url:c(b[0])}}}

package/LexicalBlockWithAlignableContents.dev.js

@@ -33,28 +33,23 @@ function BlockWithAlignableContents({
     if (isSelected && lexical.$isNodeSelection(lexical.$getSelection())) {
       event.preventDefault();
       const node = lexical.$getNodeByKey(nodeKey);
-
       if (lexical.$isDecoratorNode(node)) {
         node.remove();
       }
     }
-
     return false;
   }, [isSelected, nodeKey]);
   React.useEffect(() => {
     return utils.mergeRegister(editor.registerCommand(lexical.FORMAT_ELEMENT_COMMAND, formatType => {
       if (isSelected) {
         const selection = lexical.$getSelection();
-
         if (lexical.$isNodeSelection(selection)) {
           const node = lexical.$getNodeByKey(nodeKey);
-
           if (LexicalDecoratorBlockNode.$isDecoratorBlockNode(node)) {
             node.setFormat(formatType);
           }
         } else if (lexical.$isRangeSelection(selection)) {
           const nodes = selection.getNodes();
-
           for (const node of nodes) {
             if (LexicalDecoratorBlockNode.$isDecoratorBlockNode(node)) {
               node.setFormat(formatType);
@@ -64,23 +59,18 @@ function BlockWithAlignableContents({
             }
           }
         }
-
         return true;
       }
-
       return false;
     }, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.CLICK_COMMAND, event => {
       if (event.target === ref.current) {
         event.preventDefault();
-
         if (!event.shiftKey) {
           clearSelection();
         }
-
         setSelected(!isSelected);
         return true;
       }
-
       return false;
     }, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_DELETE_COMMAND, onDelete, lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(lexical.KEY_BACKSPACE_COMMAND, onDelete, lexical.COMMAND_PRIORITY_LOW));
   }, [clearSelection, editor, isSelected, nodeKey, onDelete, setSelected]);