@payloadcms/richtext-lexical 0.1.0-beta.0

package/dist/field/features/Link/plugins/autoLink/index.js

@@ -0,0 +1,230 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createLinkMatcherWithRegExp: function() {
+        return createLinkMatcherWithRegExp;
+    },
+    AutoLinkPlugin: function() {
+        return AutoLinkPlugin;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const _react = require("react");
+const _invariant = require("../../../../lexical/utils/invariant");
+const _AutoLinkNode = require("../../nodes/AutoLinkNode");
+const _LinkNode = require("../../nodes/LinkNode");
+function createLinkMatcherWithRegExp(regExp, urlTransformer = (text)=>text) {
+    return (text)=>{
+        const match = regExp.exec(text);
+        if (match === null) return null;
+        return {
+            index: match.index,
+            length: match[0].length,
+            text: match[0],
+            url: urlTransformer(text)
+        };
+    };
+}
+function findFirstMatch(text, matchers) {
+    for(let i = 0; i < matchers.length; i++){
+        const match = matchers[i](text);
+        if (match != null) {
+            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 ((0, _lexical.$isElementNode)(previousNode)) {
+        previousNode = previousNode.getLastDescendant();
+    }
+    return previousNode === null || (0, _lexical.$isLineBreakNode)(previousNode) || (0, _lexical.$isTextNode)(previousNode) && endsWithSeparator(previousNode.getTextContent());
+}
+function isNextNodeValid(node) {
+    let nextNode = node.getNextSibling();
+    if ((0, _lexical.$isElementNode)(nextNode)) {
+        nextNode = nextNode.getFirstDescendant();
+    }
+    return nextNode === null || (0, _lexical.$isLineBreakNode)(nextNode) || (0, _lexical.$isTextNode)(nextNode) && startsWithSeparator(nextNode.getTextContent());
+}
+function isContentAroundIsValid(matchStart, matchEnd, text, node) {
+    const contentBeforeIsValid = matchStart > 0 ? isSeparator(text[matchStart - 1]) : isPreviousNodeValid(node);
+    if (!contentBeforeIsValid) {
+        return false;
+    }
+    const contentAfterIsValid = matchEnd < text.length ? isSeparator(text[matchEnd]) : isNextNodeValid(node);
+    return contentAfterIsValid;
+}
+function handleLinkCreation(node, matchers, onChange) {
+    const nodeText = node.getTextContent();
+    let text = nodeText;
+    let invalidMatchEnd = 0;
+    let remainingTextNode = node;
+    let match;
+    while((match = findFirstMatch(text, matchers)) != null && match !== null){
+        const matchStart = match.index;
+        const matchLength = match.length;
+        const matchEnd = matchStart + matchLength;
+        const isValid = isContentAroundIsValid(invalidMatchEnd + matchStart, invalidMatchEnd + matchEnd, nodeText, node);
+        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 fields = {
+                linkType: 'custom',
+                url: match.url,
+                ...match.attributes
+            };
+            const linkNode = (0, _AutoLinkNode.$createAutoLinkNode)({
+                fields
+            });
+            const textNode = (0, _lexical.$createTextNode)(match.text);
+            textNode.setFormat(linkTextNode.getFormat());
+            textNode.setDetail(linkTextNode.getDetail());
+            linkNode.append(textNode);
+            linkTextNode.replace(linkNode);
+            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 (!(0, _lexical.$isTextNode)(child) || !child.isSimpleText()) {
+            replaceWithChildren(linkNode);
+            onChange(null, linkNode.getFields()?.url ?? null);
+            return;
+        }
+    }
+    // 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.getFields()?.url ?? null);
+        return;
+    }
+    // Check neighbors
+    if (!isPreviousNodeValid(linkNode) || !isNextNodeValid(linkNode)) {
+        replaceWithChildren(linkNode);
+        onChange(null, linkNode.getFields()?.url ?? null);
+        return;
+    }
+    const url = linkNode.getFields()?.url;
+    if (url !== match?.url) {
+        const flds = linkNode.getFields();
+        flds.url = match?.url;
+        linkNode.setFields(flds);
+        onChange(match.url, url ?? null);
+    }
+}
+// Bad neighbours 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 ((0, _AutoLinkNode.$isAutoLinkNode)(previousSibling) && !startsWithSeparator(text)) {
+        previousSibling.append(textNode);
+        handleLinkEdit(previousSibling, matchers, onChange);
+        onChange(null, previousSibling.getFields()?.url ?? null);
+    }
+    if ((0, _AutoLinkNode.$isAutoLinkNode)(nextSibling) && !endsWithSeparator(text)) {
+        replaceWithChildren(nextSibling);
+        handleLinkEdit(nextSibling, matchers, onChange);
+        onChange(null, nextSibling.getFields()?.url ?? null);
+    }
+}
+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 useAutoLink(editor, matchers, onChange) {
+    (0, _react.useEffect)(()=>{
+        if (!editor.hasNodes([
+            _AutoLinkNode.AutoLinkNode
+        ])) {
+            (0, _invariant.invariant)(false, 'LexicalAutoLinkPlugin: AutoLinkNode not registered on editor');
+        }
+        const onChangeWrapped = (url, prevUrl)=>{
+            if (onChange != null) {
+                onChange(url, prevUrl);
+            }
+        };
+        return (0, _utils.mergeRegister)(editor.registerNodeTransform(_lexical.TextNode, (textNode)=>{
+            const parent = textNode.getParentOrThrow();
+            const previous = textNode.getPreviousSibling();
+            if ((0, _AutoLinkNode.$isAutoLinkNode)(parent)) {
+                handleLinkEdit(parent, matchers, onChangeWrapped);
+            } else if (!(0, _LinkNode.$isLinkNode)(parent)) {
+                if (textNode.isSimpleText() && (startsWithSeparator(textNode.getTextContent()) || !(0, _AutoLinkNode.$isAutoLinkNode)(previous))) {
+                    handleLinkCreation(textNode, matchers, onChangeWrapped);
+                }
+                handleBadNeighbors(textNode, matchers, onChangeWrapped);
+            }
+        }));
+    }, [
+        editor,
+        matchers,
+        onChange
+    ]);
+}
+const URL_REGEX = /((https?:\/\/(www\.)?)|(www\.))[-\w@:%.+~#=]{1,256}\.[a-zA-Z\d()]{1,6}\b([-\w()@:%+.~#?&/=]*)/;
+const EMAIL_REGEX = /(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\])|(([a-zA-Z\-\d]+\.)+[a-zA-Z]{2,}))/;
+const MATCHERS = [
+    createLinkMatcherWithRegExp(URL_REGEX, (text)=>{
+        return text.startsWith('http') ? text : `https://${text}`;
+    }),
+    createLinkMatcherWithRegExp(EMAIL_REGEX, (text)=>{
+        return `mailto:${text}`;
+    })
+];
+function AutoLinkPlugin() {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    useAutoLink(editor, MATCHERS);
+    return null;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/features/Link/plugins/autoLink/index.tsx"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { ElementNode, LexicalEditor, LexicalNode } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { mergeRegister } from '@lexical/utils'\nimport { $createTextNode, $isElementNode, $isLineBreakNode, $isTextNode, TextNode } from 'lexical'\nimport { useEffect } from 'react'\n\nimport { invariant } from '../../../../lexical/utils/invariant'\nimport { $createAutoLinkNode, $isAutoLinkNode, AutoLinkNode } from '../../nodes/AutoLinkNode'\nimport { $isLinkNode, type LinkFields } from '../../nodes/LinkNode'\n\ntype ChangeHandler = (url: null | string, prevUrl: null | string) => void\n\ninterface LinkMatcherResult {\n  fields?: LinkFields\n  index: number\n  length: number\n  text: string\n  url: string\n}\n\nexport type LinkMatcher = (text: string) => LinkMatcherResult | null\n\nexport function createLinkMatcherWithRegExp(\n  regExp: RegExp,\n  urlTransformer: (text: string) => string = (text) => text,\n) {\n  return (text: string) => {\n    const match = regExp.exec(text)\n    if (match === null) return null\n    return {\n      index: match.index,\n      length: match[0].length,\n      text: match[0],\n      url: urlTransformer(text),\n    }\n  }\n}\n\nfunction findFirstMatch(text: string, matchers: LinkMatcher[]): LinkMatcherResult | null {\n  for (let i = 0; i < matchers.length; i++) {\n    const match = matchers[i](text)\n\n    if (match != null) {\n      return match\n    }\n  }\n\n  return null\n}\n\nconst PUNCTUATION_OR_SPACE = /[.,;\\s]/\n\nfunction isSeparator(char: string): boolean {\n  return PUNCTUATION_OR_SPACE.test(char)\n}\n\nfunction endsWithSeparator(textContent: string): boolean {\n  return isSeparator(textContent[textContent.length - 1])\n}\n\nfunction startsWithSeparator(textContent: string): boolean {\n  return isSeparator(textContent[0])\n}\n\nfunction isPreviousNodeValid(node: LexicalNode): boolean {\n  let previousNode = node.getPreviousSibling()\n  if ($isElementNode(previousNode)) {\n    previousNode = previousNode.getLastDescendant()\n  }\n  return (\n    previousNode === null ||\n    $isLineBreakNode(previousNode) ||\n    ($isTextNode(previousNode) && endsWithSeparator(previousNode.getTextContent()))\n  )\n}\n\nfunction isNextNodeValid(node: LexicalNode): boolean {\n  let nextNode = node.getNextSibling()\n  if ($isElementNode(nextNode)) {\n    nextNode = nextNode.getFirstDescendant()\n  }\n  return (\n    nextNode === null ||\n    $isLineBreakNode(nextNode) ||\n    ($isTextNode(nextNode) && startsWithSeparator(nextNode.getTextContent()))\n  )\n}\n\nfunction isContentAroundIsValid(\n  matchStart: number,\n  matchEnd: number,\n  text: string,\n  node: TextNode,\n): boolean {\n  const contentBeforeIsValid =\n    matchStart > 0 ? isSeparator(text[matchStart - 1]) : isPreviousNodeValid(node)\n  if (!contentBeforeIsValid) {\n    return false\n  }\n\n  const contentAfterIsValid =\n    matchEnd < text.length ? isSeparator(text[matchEnd]) : isNextNodeValid(node)\n  return contentAfterIsValid\n}\n\nfunction handleLinkCreation(\n  node: TextNode,\n  matchers: LinkMatcher[],\n  onChange: ChangeHandler,\n): void {\n  const nodeText = node.getTextContent()\n  let text = nodeText\n  let invalidMatchEnd = 0\n  let remainingTextNode = node\n  let match\n\n  while ((match = findFirstMatch(text, matchers)) != null && match !== null) {\n    const matchStart: number = match.index\n    const matchLength: number = match.length\n    const matchEnd = matchStart + matchLength\n    const isValid = isContentAroundIsValid(\n      invalidMatchEnd + matchStart,\n      invalidMatchEnd + matchEnd,\n      nodeText,\n      node,\n    )\n\n    if (isValid) {\n      let linkTextNode\n      if (invalidMatchEnd + matchStart === 0) {\n        ;[linkTextNode, remainingTextNode] = remainingTextNode.splitText(\n          invalidMatchEnd + matchLength,\n        )\n      } else {\n        ;[, linkTextNode, remainingTextNode] = remainingTextNode.splitText(\n          invalidMatchEnd + matchStart,\n          invalidMatchEnd + matchStart + matchLength,\n        )\n      }\n      const fields: LinkFields = {\n        linkType: 'custom',\n        url: match.url,\n        ...match.attributes,\n      }\n\n      const linkNode = $createAutoLinkNode({ fields })\n      const textNode = $createTextNode(match.text)\n      textNode.setFormat(linkTextNode.getFormat())\n      textNode.setDetail(linkTextNode.getDetail())\n      linkNode.append(textNode)\n      linkTextNode.replace(linkNode)\n      onChange(match.url, null)\n      invalidMatchEnd = 0\n    } else {\n      invalidMatchEnd += matchEnd\n    }\n\n    text = text.substring(matchEnd)\n  }\n}\n\nfunction handleLinkEdit(\n  linkNode: AutoLinkNode,\n  matchers: LinkMatcher[],\n  onChange: ChangeHandler,\n): void {\n  // Check children are simple text\n  const children = linkNode.getChildren()\n  const childrenLength = children.length\n  for (let i = 0; i < childrenLength; i++) {\n    const child = children[i]\n    if (!$isTextNode(child) || !child.isSimpleText()) {\n      replaceWithChildren(linkNode)\n      onChange(null, linkNode.getFields()?.url ?? null)\n      return\n    }\n  }\n\n  // Check text content fully matches\n  const text = linkNode.getTextContent()\n  const match = findFirstMatch(text, matchers)\n  if (match === null || match.text !== text) {\n    replaceWithChildren(linkNode)\n    onChange(null, linkNode.getFields()?.url ?? null)\n    return\n  }\n\n  // Check neighbors\n  if (!isPreviousNodeValid(linkNode) || !isNextNodeValid(linkNode)) {\n    replaceWithChildren(linkNode)\n    onChange(null, linkNode.getFields()?.url ?? null)\n    return\n  }\n\n  const url = linkNode.getFields()?.url\n  if (url !== match?.url) {\n    const flds = linkNode.getFields()\n    flds.url = match?.url\n    linkNode.setFields(flds)\n    onChange(match.url, url ?? null)\n  }\n}\n\n// Bad neighbours are edits in neighbor nodes that make AutoLinks incompatible.\n// Given the creation preconditions, these can only be simple text nodes.\nfunction handleBadNeighbors(\n  textNode: TextNode,\n  matchers: LinkMatcher[],\n  onChange: ChangeHandler,\n): void {\n  const previousSibling = textNode.getPreviousSibling()\n  const nextSibling = textNode.getNextSibling()\n  const text = textNode.getTextContent()\n\n  if ($isAutoLinkNode(previousSibling) && !startsWithSeparator(text)) {\n    previousSibling.append(textNode)\n    handleLinkEdit(previousSibling, matchers, onChange)\n    onChange(null, previousSibling.getFields()?.url ?? null)\n  }\n\n  if ($isAutoLinkNode(nextSibling) && !endsWithSeparator(text)) {\n    replaceWithChildren(nextSibling)\n    handleLinkEdit(nextSibling, matchers, onChange)\n    onChange(null, nextSibling.getFields()?.url ?? null)\n  }\n}\n\nfunction replaceWithChildren(node: ElementNode): LexicalNode[] {\n  const children = node.getChildren()\n  const childrenLength = children.length\n\n  for (let j = childrenLength - 1; j >= 0; j--) {\n    node.insertAfter(children[j])\n  }\n\n  node.remove()\n  return children.map((child) => child.getLatest())\n}\n\nfunction useAutoLink(\n  editor: LexicalEditor,\n  matchers: LinkMatcher[],\n  onChange?: ChangeHandler,\n): void {\n  useEffect(() => {\n    if (!editor.hasNodes([AutoLinkNode])) {\n      invariant(false, 'LexicalAutoLinkPlugin: AutoLinkNode not registered on editor')\n    }\n\n    const onChangeWrapped = (url: null | string, prevUrl: null | string): void => {\n      if (onChange != null) {\n        onChange(url, prevUrl)\n      }\n    }\n\n    return mergeRegister(\n      editor.registerNodeTransform(TextNode, (textNode: TextNode) => {\n        const parent = textNode.getParentOrThrow()\n        const previous = textNode.getPreviousSibling()\n        if ($isAutoLinkNode(parent)) {\n          handleLinkEdit(parent, matchers, onChangeWrapped)\n        } else if (!$isLinkNode(parent)) {\n          if (\n            textNode.isSimpleText() &&\n            (startsWithSeparator(textNode.getTextContent()) || !$isAutoLinkNode(previous))\n          ) {\n            handleLinkCreation(textNode, matchers, onChangeWrapped)\n          }\n\n          handleBadNeighbors(textNode, matchers, onChangeWrapped)\n        }\n      }),\n    )\n  }, [editor, matchers, onChange])\n}\n\nconst URL_REGEX =\n  /((https?:\\/\\/(www\\.)?)|(www\\.))[-\\w@:%.+~#=]{1,256}\\.[a-zA-Z\\d()]{1,6}\\b([-\\w()@:%+.~#?&/=]*)/\n\nconst EMAIL_REGEX =\n  /(([^<>()[\\]\\\\.,;:\\s@\"]+(\\.[^<>()[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\])|(([a-zA-Z\\-\\d]+\\.)+[a-zA-Z]{2,}))/\n\nconst MATCHERS = [\n  createLinkMatcherWithRegExp(URL_REGEX, (text) => {\n    return text.startsWith('http') ? text : `https://${text}`\n  }),\n  createLinkMatcherWithRegExp(EMAIL_REGEX, (text) => {\n    return `mailto:${text}`\n  }),\n]\n\nexport function AutoLinkPlugin(): JSX.Element | null {\n  const [editor] = useLexicalComposerContext()\n\n  useAutoLink(editor, MATCHERS)\n\n  return null\n}\n"],"names":["createLinkMatcherWithRegExp","AutoLinkPlugin","regExp","urlTransformer","text","match","exec","index","length","url","findFirstMatch","matchers","i","PUNCTUATION_OR_SPACE","isSeparator","char","test","endsWithSeparator","textContent","startsWithSeparator","isPreviousNodeValid","node","previousNode","getPreviousSibling","$isElementNode","getLastDescendant","$isLineBreakNode","$isTextNode","getTextContent","isNextNodeValid","nextNode","getNextSibling","getFirstDescendant","isContentAroundIsValid","matchStart","matchEnd","contentBeforeIsValid","contentAfterIsValid","handleLinkCreation","onChange","nodeText","invalidMatchEnd","remainingTextNode","matchLength","isValid","linkTextNode","splitText","fields","linkType","attributes","linkNode","$createAutoLinkNode","textNode","$createTextNode","setFormat","getFormat","setDetail","getDetail","append","replace","substring","handleLinkEdit","children","getChildren","childrenLength","child","isSimpleText","replaceWithChildren","getFields","flds","setFields","handleBadNeighbors","previousSibling","nextSibling","$isAutoLinkNode","j","insertAfter","remove","map","getLatest","useAutoLink","editor","useEffect","hasNodes","AutoLinkNode","invariant","onChangeWrapped","prevUrl","mergeRegister","registerNodeTransform","TextNode","parent","getParentOrThrow","previous","$isLinkNode","URL_REGEX","EMAIL_REGEX","MATCHERS","startsWith","useLexicalComposerContext"],"mappings":"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"}

package/dist/field/features/Link/plugins/floatingLinkEditor/LinkEditor/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { LexicalCommand } from 'lexical';
+import type { LinkFeatureProps } from '../../..';
+import type { LinkPayload } from '../types';
+export declare const TOGGLE_LINK_WITH_MODAL_COMMAND: LexicalCommand<LinkPayload | null>;
+export declare function LinkEditor({ anchorElem, fields: customFieldSchema, }: {
+    anchorElem: HTMLElement;
+} & LinkFeatureProps): JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/Link/plugins/floatingLinkEditor/LinkEditor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/features/Link/plugins/floatingLinkEditor/LinkEditor/index.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AA4B7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAS3C,eAAO,MAAM,8BAA8B,EAAE,cAAc,CAAC,WAAW,GAAG,IAAI,CAE7E,CAAA;AAED,wBAAgB,UAAU,CAAC,EACzB,UAAU,EACV,MAAM,EAAE,iBAAiB,GAC1B,EAAE;IAAE,UAAU,EAAE,WAAW,CAAA;CAAE,GAAG,gBAAgB,GAAG,GAAG,CAAC,OAAO,CA+Q9D"}

package/dist/field/features/Link/plugins/floatingLinkEditor/LinkEditor/index.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TOGGLE_LINK_WITH_MODAL_COMMAND: function() {
+        return TOGGLE_LINK_WITH_MODAL_COMMAND;
+    },
+    LinkEditor: function() {
+        return LinkEditor;
+    }
+});
+const _modal = require("@faceless-ui/modal");
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const _elements = require("payload/components/elements");
+const _forms = require("payload/components/forms");
+const _utilities = require("payload/components/utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacti18next = require("react-i18next");
+const _EditorConfigProvider = require("../../../../../lexical/config/EditorConfigProvider");
+const _getSelectedNode = require("../../../../../lexical/utils/getSelectedNode");
+const _setFloatingElemPositionForLinkEditor = require("../../../../../lexical/utils/setFloatingElemPositionForLinkEditor");
+const _drawer = require("../../../drawer");
+const _LinkNode = require("../../../nodes/LinkNode");
+const _utilities1 = require("../utilities");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const TOGGLE_LINK_WITH_MODAL_COMMAND = (0, _lexical.createCommand)('TOGGLE_LINK_WITH_MODAL_COMMAND');
+function LinkEditor({ anchorElem, fields: customFieldSchema }) {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const editorRef = (0, _react.useRef)(null);
+    const [linkUrl, setLinkUrl] = (0, _react.useState)('');
+    const [linkLabel, setLinkLabel] = (0, _react.useState)('');
+    const { uuid } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    const config = (0, _utilities.useConfig)();
+    const { user } = (0, _utilities.useAuth)();
+    const { code: locale } = (0, _utilities.useLocale)();
+    const { i18n, t } = (0, _reacti18next.useTranslation)([
+        'fields',
+        'upload',
+        'general'
+    ]);
+    const { getDocPreferences } = (0, _utilities.useDocumentInfo)();
+    const [initialState, setInitialState] = (0, _react.useState)({});
+    const [fieldSchema] = (0, _react.useState)(()=>{
+        const fields = (0, _utilities1.transformExtraFields)(customFieldSchema, config, i18n);
+        return fields;
+    });
+    const { closeModal, toggleModal } = (0, _modal.useModal)();
+    const editDepth = (0, _utilities.useEditDepth)();
+    const [isLink, setIsLink] = (0, _react.useState)(false);
+    const drawerSlug = (0, _elements.formatDrawerSlug)({
+        depth: editDepth,
+        slug: `lexical-rich-text-link-` + uuid
+    });
+    const updateLinkEditor = (0, _react.useCallback)(async ()=>{
+        const selection = (0, _lexical.$getSelection)();
+        let selectedNodeDomRect = null;
+        // Handle the data displayed in the floating link editor & drawer when you click on a link node
+        if ((0, _lexical.$isRangeSelection)(selection)) {
+            const node = (0, _getSelectedNode.getSelectedNode)(selection);
+            selectedNodeDomRect = editor.getElementByKey(node.getKey())?.getBoundingClientRect();
+            const linkParent = (0, _utils.$findMatchingParent)(node, _LinkNode.$isLinkNode);
+            if (linkParent == null) {
+                setIsLink(false);
+                setLinkUrl('');
+                setLinkLabel('');
+                return;
+            }
+            // Initial state:
+            const data = {
+                fields: {
+                    doc: undefined,
+                    linkType: undefined,
+                    newTab: undefined,
+                    nofollow: undefined,
+                    sponsored: undefined,
+                    url: '',
+                    ...linkParent.getFields()
+                },
+                text: linkParent.getTextContent()
+            };
+            if (linkParent.getFields()?.linkType === 'custom') {
+                setLinkUrl(linkParent.getFields()?.url ?? '');
+                setLinkLabel('');
+            } else {
+                // internal link
+                setLinkUrl(`/admin/collections/${linkParent.getFields()?.doc?.relationTo}/${linkParent.getFields()?.doc?.value}`);
+                setLinkLabel(`relation to ${linkParent.getFields()?.doc?.relationTo}: ${linkParent.getFields()?.doc?.value}`);
+            }
+            // Set initial state of the drawer. This will basically pre-fill the drawer fields with the
+            // values saved in the link node you clicked on.
+            const preferences = await getDocPreferences();
+            const state = await (0, _utilities.buildStateFromSchema)({
+                data,
+                fieldSchema,
+                locale,
+                operation: 'create',
+                preferences,
+                t,
+                user: user ?? undefined
+            });
+            setInitialState(state);
+            setIsLink(true);
+        }
+        const editorElem = editorRef.current;
+        const nativeSelection = window.getSelection();
+        const { activeElement } = document;
+        if (editorElem === null) {
+            return;
+        }
+        const rootElement = editor.getRootElement();
+        if (selection !== null && nativeSelection !== null && rootElement !== null && rootElement.contains(nativeSelection.anchorNode) && editor.isEditable()) {
+            if (!selectedNodeDomRect) {
+                // Get the DOM rect of the selected node using the native selection. This sometimes produces the wrong
+                // result, which is why we use lexical's selection preferably.
+                selectedNodeDomRect = nativeSelection.getRangeAt(0).getBoundingClientRect();
+            }
+            if (selectedNodeDomRect != null) {
+                selectedNodeDomRect.y += 40;
+                (0, _setFloatingElemPositionForLinkEditor.setFloatingElemPositionForLinkEditor)(selectedNodeDomRect, editorElem, anchorElem);
+            }
+        } else if (activeElement == null || activeElement.className !== 'link-input') {
+            if (rootElement !== null) {
+                (0, _setFloatingElemPositionForLinkEditor.setFloatingElemPositionForLinkEditor)(null, editorElem, anchorElem);
+            }
+            setLinkUrl('');
+            setLinkLabel('');
+        }
+        return true;
+    }, [
+        anchorElem,
+        editor,
+        fieldSchema
+    ]);
+    (0, _react.useEffect)(()=>{
+        return (0, _utils.mergeRegister)(editor.registerCommand(TOGGLE_LINK_WITH_MODAL_COMMAND, (payload)=>{
+            editor.dispatchCommand(_LinkNode.TOGGLE_LINK_COMMAND, payload);
+            // Now, open the modal
+            updateLinkEditor().then(()=>{
+                toggleModal(drawerSlug);
+            }).catch((error)=>{
+                throw error;
+            });
+            return true;
+        }, _lexical.COMMAND_PRIORITY_LOW));
+    }, [
+        editor,
+        updateLinkEditor,
+        toggleModal,
+        drawerSlug
+    ]);
+    (0, _react.useEffect)(()=>{
+        if (!isLink && editorRef) {
+            editorRef.current.style.opacity = '0';
+            editorRef.current.style.transform = 'translate(-10000px, -10000px)';
+        }
+    }, [
+        isLink
+    ]);
+    (0, _react.useEffect)(()=>{
+        const scrollerElem = anchorElem.parentElement;
+        const update = ()=>{
+            editor.getEditorState().read(()=>{
+                void updateLinkEditor();
+            });
+        };
+        window.addEventListener('resize', update);
+        if (scrollerElem != null) {
+            scrollerElem.addEventListener('scroll', update);
+        }
+        return ()=>{
+            window.removeEventListener('resize', update);
+            if (scrollerElem != null) {
+                scrollerElem.removeEventListener('scroll', update);
+            }
+        };
+    }, [
+        anchorElem.parentElement,
+        editor,
+        updateLinkEditor
+    ]);
+    (0, _react.useEffect)(()=>{
+        return (0, _utils.mergeRegister)(editor.registerUpdateListener(({ editorState })=>{
+            editorState.read(()=>{
+                void updateLinkEditor();
+            });
+        }), editor.registerCommand(_lexical.SELECTION_CHANGE_COMMAND, ()=>{
+            void updateLinkEditor();
+            return true;
+        }, _lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(_lexical.KEY_ESCAPE_COMMAND, ()=>{
+            if (isLink) {
+                setIsLink(false);
+                return true;
+            }
+            return false;
+        }, _lexical.COMMAND_PRIORITY_HIGH));
+    }, [
+        editor,
+        updateLinkEditor,
+        setIsLink,
+        isLink
+    ]);
+    (0, _react.useEffect)(()=>{
+        editor.getEditorState().read(()=>{
+            void updateLinkEditor();
+        });
+    }, [
+        editor,
+        updateLinkEditor
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/ _react.default.createElement("div", {
+        className: "link-editor",
+        ref: editorRef
+    }, /*#__PURE__*/ _react.default.createElement("div", {
+        className: "link-input"
+    }, /*#__PURE__*/ _react.default.createElement("a", {
+        href: linkUrl,
+        rel: "noopener noreferrer",
+        target: "_blank"
+    }, linkLabel != null && linkLabel.length > 0 ? linkLabel : linkUrl), /*#__PURE__*/ _react.default.createElement("button", {
+        "aria-label": "Edit link",
+        className: "link-edit",
+        onClick: ()=>{
+            toggleModal(drawerSlug);
+        },
+        onMouseDown: (event)=>{
+            event.preventDefault();
+        },
+        tabIndex: 0,
+        type: "button"
+    }), /*#__PURE__*/ _react.default.createElement("button", {
+        "aria-label": "Remove link",
+        className: "link-trash",
+        onClick: ()=>{
+            editor.dispatchCommand(_LinkNode.TOGGLE_LINK_COMMAND, null);
+        },
+        onMouseDown: (event)=>{
+            event.preventDefault();
+        },
+        tabIndex: 0,
+        type: "button"
+    }))), /*#__PURE__*/ _react.default.createElement(_drawer.LinkDrawer, {
+        drawerSlug: drawerSlug,
+        fieldSchema: fieldSchema,
+        handleModalSubmit: (fields)=>{
+            closeModal(drawerSlug);
+            const data = (0, _forms.reduceFieldsToValues)(fields, true);
+            const newLinkPayload = data;
+            editor.dispatchCommand(_LinkNode.TOGGLE_LINK_COMMAND, newLinkPayload);
+        },
+        initialState: initialState
+    }));
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../../src/field/features/Link/plugins/floatingLinkEditor/LinkEditor/index.tsx"],"sourcesContent":["import type { LexicalCommand } from 'lexical'\nimport type { Fields } from 'payload/types'\n\nimport { useModal } from '@faceless-ui/modal'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { $findMatchingParent, mergeRegister } from '@lexical/utils'\nimport {\n  $getSelection,\n  $isRangeSelection,\n  COMMAND_PRIORITY_HIGH,\n  COMMAND_PRIORITY_LOW,\n  KEY_ESCAPE_COMMAND,\n  SELECTION_CHANGE_COMMAND,\n  createCommand,\n} from 'lexical'\nimport { formatDrawerSlug } from 'payload/components/elements'\nimport { reduceFieldsToValues } from 'payload/components/forms'\nimport {\n  buildStateFromSchema,\n  useAuth,\n  useConfig,\n  useDocumentInfo,\n  useEditDepth,\n  useLocale,\n} from 'payload/components/utilities'\nimport React, { useCallback, useEffect, useRef, useState } from 'react'\nimport { useTranslation } from 'react-i18next'\n\nimport type { LinkFeatureProps } from '../../..'\nimport type { LinkNode } from '../../../nodes/LinkNode'\nimport type { LinkPayload } from '../types'\n\nimport { useEditorConfigContext } from '../../../../../lexical/config/EditorConfigProvider'\nimport { getSelectedNode } from '../../../../../lexical/utils/getSelectedNode'\nimport { setFloatingElemPositionForLinkEditor } from '../../../../../lexical/utils/setFloatingElemPositionForLinkEditor'\nimport { LinkDrawer } from '../../../drawer'\nimport { $isLinkNode, TOGGLE_LINK_COMMAND } from '../../../nodes/LinkNode'\nimport { transformExtraFields } from '../utilities'\n\nexport const TOGGLE_LINK_WITH_MODAL_COMMAND: LexicalCommand<LinkPayload | null> = createCommand(\n  'TOGGLE_LINK_WITH_MODAL_COMMAND',\n)\n\nexport function LinkEditor({\n  anchorElem,\n  fields: customFieldSchema,\n}: { anchorElem: HTMLElement } & LinkFeatureProps): JSX.Element {\n  const [editor] = useLexicalComposerContext()\n\n  const editorRef = useRef<HTMLDivElement | null>(null)\n  const [linkUrl, setLinkUrl] = useState('')\n  const [linkLabel, setLinkLabel] = useState('')\n\n  const { uuid } = useEditorConfigContext()\n\n  const config = useConfig()\n\n  const { user } = useAuth()\n  const { code: locale } = useLocale()\n  const { i18n, t } = useTranslation(['fields', 'upload', 'general'])\n\n  const { getDocPreferences } = useDocumentInfo()\n\n  const [initialState, setInitialState] = useState<Fields>({})\n\n  const [fieldSchema] = useState(() => {\n    const fields = transformExtraFields(customFieldSchema, config, i18n)\n\n    return fields\n  })\n\n  const { closeModal, toggleModal } = useModal()\n  const editDepth = useEditDepth()\n  const [isLink, setIsLink] = useState(false)\n\n  const drawerSlug = formatDrawerSlug({\n    depth: editDepth,\n    slug: `lexical-rich-text-link-` + uuid,\n  })\n\n  const updateLinkEditor = useCallback(async () => {\n    const selection = $getSelection()\n    let selectedNodeDomRect: DOMRect | undefined = null\n\n    // Handle the data displayed in the floating link editor & drawer when you click on a link node\n    if ($isRangeSelection(selection)) {\n      const node = getSelectedNode(selection)\n      selectedNodeDomRect = editor.getElementByKey(node.getKey())?.getBoundingClientRect()\n      const linkParent: LinkNode = $findMatchingParent(node, $isLinkNode) as LinkNode\n      if (linkParent == null) {\n        setIsLink(false)\n        setLinkUrl('')\n        setLinkLabel('')\n        return\n      }\n\n      // Initial state:\n      const data: LinkPayload = {\n        fields: {\n          doc: undefined,\n          linkType: undefined,\n          newTab: undefined,\n          nofollow: undefined,\n          sponsored: undefined,\n          url: '',\n          ...linkParent.getFields(),\n        },\n        text: linkParent.getTextContent(),\n      }\n\n      if (linkParent.getFields()?.linkType === 'custom') {\n        setLinkUrl(linkParent.getFields()?.url ?? '')\n        setLinkLabel('')\n      } else {\n        // internal link\n        setLinkUrl(\n          `/admin/collections/${linkParent.getFields()?.doc?.relationTo}/${linkParent.getFields()\n            ?.doc?.value}`,\n        )\n        setLinkLabel(\n          `relation to ${linkParent.getFields()?.doc?.relationTo}: ${linkParent.getFields()?.doc\n            ?.value}`,\n        )\n      }\n\n      // Set initial state of the drawer. This will basically pre-fill the drawer fields with the\n      // values saved in the link node you clicked on.\n      const preferences = await getDocPreferences()\n      const state = await buildStateFromSchema({\n        data,\n        fieldSchema,\n        locale,\n        operation: 'create',\n        preferences,\n        t,\n        user: user ?? undefined,\n      })\n      setInitialState(state)\n      setIsLink(true)\n    }\n\n    const editorElem = editorRef.current\n    const nativeSelection = window.getSelection()\n    const { activeElement } = document\n\n    if (editorElem === null) {\n      return\n    }\n\n    const rootElement = editor.getRootElement()\n\n    if (\n      selection !== null &&\n      nativeSelection !== null &&\n      rootElement !== null &&\n      rootElement.contains(nativeSelection.anchorNode) &&\n      editor.isEditable()\n    ) {\n      if (!selectedNodeDomRect) {\n        // Get the DOM rect of the selected node using the native selection. This sometimes produces the wrong\n        // result, which is why we use lexical's selection preferably.\n        selectedNodeDomRect = nativeSelection.getRangeAt(0).getBoundingClientRect()\n      }\n\n      if (selectedNodeDomRect != null) {\n        selectedNodeDomRect.y += 40\n        setFloatingElemPositionForLinkEditor(selectedNodeDomRect, editorElem, anchorElem)\n      }\n    } else if (activeElement == null || activeElement.className !== 'link-input') {\n      if (rootElement !== null) {\n        setFloatingElemPositionForLinkEditor(null, editorElem, anchorElem)\n      }\n      setLinkUrl('')\n      setLinkLabel('')\n    }\n\n    return true\n  }, [anchorElem, editor, fieldSchema])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerCommand(\n        TOGGLE_LINK_WITH_MODAL_COMMAND,\n        (payload: LinkPayload) => {\n          editor.dispatchCommand(TOGGLE_LINK_COMMAND, payload)\n\n          // Now, open the modal\n          updateLinkEditor()\n            .then(() => {\n              toggleModal(drawerSlug)\n            })\n            .catch((error) => {\n              throw error\n            })\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n    )\n  }, [editor, updateLinkEditor, toggleModal, drawerSlug])\n\n  useEffect(() => {\n    if (!isLink && editorRef) {\n      editorRef.current.style.opacity = '0'\n      editorRef.current.style.transform = 'translate(-10000px, -10000px)'\n    }\n  }, [isLink])\n\n  useEffect(() => {\n    const scrollerElem = anchorElem.parentElement\n\n    const update = (): void => {\n      editor.getEditorState().read(() => {\n        void updateLinkEditor()\n      })\n    }\n\n    window.addEventListener('resize', update)\n\n    if (scrollerElem != null) {\n      scrollerElem.addEventListener('scroll', update)\n    }\n\n    return () => {\n      window.removeEventListener('resize', update)\n\n      if (scrollerElem != null) {\n        scrollerElem.removeEventListener('scroll', update)\n      }\n    }\n  }, [anchorElem.parentElement, editor, updateLinkEditor])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerUpdateListener(({ editorState }) => {\n        editorState.read(() => {\n          void updateLinkEditor()\n        })\n      }),\n\n      editor.registerCommand(\n        SELECTION_CHANGE_COMMAND,\n        () => {\n          void updateLinkEditor()\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n      editor.registerCommand(\n        KEY_ESCAPE_COMMAND,\n        () => {\n          if (isLink) {\n            setIsLink(false)\n            return true\n          }\n          return false\n        },\n        COMMAND_PRIORITY_HIGH,\n      ),\n    )\n  }, [editor, updateLinkEditor, setIsLink, isLink])\n\n  useEffect(() => {\n    editor.getEditorState().read(() => {\n      void updateLinkEditor()\n    })\n  }, [editor, updateLinkEditor])\n\n  return (\n    <React.Fragment>\n      <div className=\"link-editor\" ref={editorRef}>\n        <div className=\"link-input\">\n          <a href={linkUrl} rel=\"noopener noreferrer\" target=\"_blank\">\n            {linkLabel != null && linkLabel.length > 0 ? linkLabel : linkUrl}\n          </a>\n          <button\n            aria-label=\"Edit link\"\n            className=\"link-edit\"\n            onClick={() => {\n              toggleModal(drawerSlug)\n            }}\n            onMouseDown={(event) => {\n              event.preventDefault()\n            }}\n            tabIndex={0}\n            type=\"button\"\n          />\n          <button\n            aria-label=\"Remove link\"\n            className=\"link-trash\"\n            onClick={() => {\n              editor.dispatchCommand(TOGGLE_LINK_COMMAND, null)\n            }}\n            onMouseDown={(event) => {\n              event.preventDefault()\n            }}\n            tabIndex={0}\n            type=\"button\"\n          />\n        </div>\n      </div>\n      <LinkDrawer\n        drawerSlug={drawerSlug}\n        fieldSchema={fieldSchema}\n        handleModalSubmit={(fields: Fields) => {\n          closeModal(drawerSlug)\n\n          const data = reduceFieldsToValues(fields, true)\n\n          const newLinkPayload: LinkPayload = data as LinkPayload\n\n          editor.dispatchCommand(TOGGLE_LINK_COMMAND, newLinkPayload)\n        }}\n        initialState={initialState}\n      />\n    </React.Fragment>\n  )\n}\n"],"names":["TOGGLE_LINK_WITH_MODAL_COMMAND","LinkEditor","createCommand","anchorElem","fields","customFieldSchema","editor","useLexicalComposerContext","editorRef","useRef","linkUrl","setLinkUrl","useState","linkLabel","setLinkLabel","uuid","useEditorConfigContext","config","useConfig","user","useAuth","code","locale","useLocale","i18n","t","useTranslation","getDocPreferences","useDocumentInfo","initialState","setInitialState","fieldSchema","transformExtraFields","closeModal","toggleModal","useModal","editDepth","useEditDepth","isLink","setIsLink","drawerSlug","formatDrawerSlug","depth","slug","updateLinkEditor","useCallback","selection","$getSelection","selectedNodeDomRect","$isRangeSelection","node","getSelectedNode","getElementByKey","getKey","getBoundingClientRect","linkParent","$findMatchingParent","$isLinkNode","data","doc","undefined","linkType","newTab","nofollow","sponsored","url","getFields","text","getTextContent","relationTo","value","preferences","state","buildStateFromSchema","operation","editorElem","current","nativeSelection","window","getSelection","activeElement","document","rootElement","getRootElement","contains","anchorNode","isEditable","getRangeAt","y","setFloatingElemPositionForLinkEditor","className","useEffect","mergeRegister","registerCommand","payload","dispatchCommand","TOGGLE_LINK_COMMAND","then","catch","error","COMMAND_PRIORITY_LOW","style","opacity","transform","scrollerElem","parentElement","update","getEditorState","read","addEventListener","removeEventListener","registerUpdateListener","editorState","SELECTION_CHANGE_COMMAND","KEY_ESCAPE_COMMAND","COMMAND_PRIORITY_HIGH","React","Fragment","div","ref","a","href","rel","target","length","button","aria-label","onClick","onMouseDown","event","preventDefault","tabIndex","type","LinkDrawer","handleModalSubmit","reduceFieldsToValues","newLinkPayload"],"mappings":"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"}

package/dist/field/features/Link/plugins/floatingLinkEditor/index.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { LinkFeatureProps } from '../..';
+import './index.scss';
+export declare const FloatingLinkEditorPlugin: React.FC<{
+    anchorElem?: HTMLElement;
+} & LinkFeatureProps>;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/Link/plugins/floatingLinkEditor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/Link/plugins/floatingLinkEditor/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAA;AAG7C,OAAO,cAAc,CAAA;AAErB,eAAO,MAAM,wBAAwB,EAAE,KAAK,CAAC,EAAE,CAC7C;IACE,UAAU,CAAC,EAAE,WAAW,CAAA;CACzB,GAAG,gBAAgB,CAGrB,CAAA"}