@payloadcms/richtext-lexical 3.71.0-internal-debug.80dab4c → 3.71.0-internal.27e1e08

package/dist/exports/cssEntry.js

@@ -2,5 +2,4 @@
 // These will then be bundled into one CSS file by our bundler.
 export * from './client/index.js';
 export * from './server/rsc.js';
-
 //# sourceMappingURL=cssEntry.js.map

package/dist/exports/cssEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/exports/cssEntry.ts"],"sourcesContent":["// The purpose of this file is to export all modules that may contain SCSS.\n// These will then be bundled into one CSS file by our bundler.\n\nexport * from './client/index.js'\nexport * from './server/rsc.js'\n"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,+DAA+D;AAE/D,cAAc,oBAAmB;AACjC,cAAc,kBAAiB"}
+{"version":3,"file":"cssEntry.js","names":[],"sources":["../../src/exports/cssEntry.ts"],"sourcesContent":["// The purpose of this file is to export all modules that may contain SCSS.\n// These will then be bundled into one CSS file by our bundler.\n\nexport * from './client/index.js'\nexport * from './server/rsc.js'\n"],"mappings":"AAAA;AACA;AAEA,cAAc;AACd,cAAc","ignoreList":[]}

package/dist/exports/html/index.js

@@ -11,5 +11,4 @@ export { TextHTMLConverter } from '../../features/converters/lexicalToHtml/sync/
 export { UploadHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/upload.js';
 export { defaultHTMLConverters } from '../../features/converters/lexicalToHtml/sync/defaultConverters.js';
 export { convertLexicalToHTML } from '../../features/converters/lexicalToHtml/sync/index.js';
-
 //# sourceMappingURL=index.js.map

package/dist/exports/html/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/exports/html/index.ts"],"sourcesContent":["export type {\n  ProvidedCSS,\n  SerializedLexicalNodeWithParent,\n} from '../../features/converters/lexicalToHtml/shared/types.js'\nexport { BlockquoteHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/blockquote.js'\nexport { HeadingHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/heading.js'\nexport { HorizontalRuleHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/horizontalRule.js'\nexport { LinebreakHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/linebreak.js'\nexport { LinkHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/link.js'\nexport { ListHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/list.js'\nexport { ParagraphHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/paragraph.js'\nexport { TabHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/tab.js'\nexport { TableHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/table.js'\n\nexport { TextHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/text.js'\n\nexport { UploadHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/upload.js'\nexport { defaultHTMLConverters } from '../../features/converters/lexicalToHtml/sync/defaultConverters.js'\nexport { convertLexicalToHTML } from '../../features/converters/lexicalToHtml/sync/index.js'\n\nexport type {\n  HTMLConverter,\n  HTMLConverters,\n  HTMLConvertersFunction,\n} from '../../features/converters/lexicalToHtml/sync/types.js'\n"],"names":["BlockquoteHTMLConverter","HeadingHTMLConverter","HorizontalRuleHTMLConverter","LinebreakHTMLConverter","LinkHTMLConverter","ListHTMLConverter","ParagraphHTMLConverter","TabHTMLConverter","TableHTMLConverter","TextHTMLConverter","UploadHTMLConverter","defaultHTMLConverters","convertLexicalToHTML"],"mappings":"AAIA,SAASA,uBAAuB,QAAQ,wEAAuE;AAC/G,SAASC,oBAAoB,QAAQ,qEAAoE;AACzG,SAASC,2BAA2B,QAAQ,4EAA2E;AACvH,SAASC,sBAAsB,QAAQ,uEAAsE;AAC7G,SAASC,iBAAiB,QAAQ,kEAAiE;AACnG,SAASC,iBAAiB,QAAQ,kEAAiE;AACnG,SAASC,sBAAsB,QAAQ,uEAAsE;AAC7G,SAASC,gBAAgB,QAAQ,iEAAgE;AACjG,SAASC,kBAAkB,QAAQ,mEAAkE;AAErG,SAASC,iBAAiB,QAAQ,kEAAiE;AAEnG,SAASC,mBAAmB,QAAQ,oEAAmE;AACvG,SAASC,qBAAqB,QAAQ,oEAAmE;AACzG,SAASC,oBAAoB,QAAQ,wDAAuD"}
+{"version":3,"file":"index.js","names":["BlockquoteHTMLConverter","HeadingHTMLConverter","HorizontalRuleHTMLConverter","LinebreakHTMLConverter","LinkHTMLConverter","ListHTMLConverter","ParagraphHTMLConverter","TabHTMLConverter","TableHTMLConverter","TextHTMLConverter","UploadHTMLConverter","defaultHTMLConverters","convertLexicalToHTML"],"sources":["../../../src/exports/html/index.ts"],"sourcesContent":["export type {\n  ProvidedCSS,\n  SerializedLexicalNodeWithParent,\n} from '../../features/converters/lexicalToHtml/shared/types.js'\nexport { BlockquoteHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/blockquote.js'\nexport { HeadingHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/heading.js'\nexport { HorizontalRuleHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/horizontalRule.js'\nexport { LinebreakHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/linebreak.js'\nexport { LinkHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/link.js'\nexport { ListHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/list.js'\nexport { ParagraphHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/paragraph.js'\nexport { TabHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/tab.js'\nexport { TableHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/table.js'\n\nexport { TextHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/text.js'\n\nexport { UploadHTMLConverter } from '../../features/converters/lexicalToHtml/sync/converters/upload.js'\nexport { defaultHTMLConverters } from '../../features/converters/lexicalToHtml/sync/defaultConverters.js'\nexport { convertLexicalToHTML } from '../../features/converters/lexicalToHtml/sync/index.js'\n\nexport type {\n  HTMLConverter,\n  HTMLConverters,\n  HTMLConvertersFunction,\n} from '../../features/converters/lexicalToHtml/sync/types.js'\n"],"mappings":"AAIA,SAASA,uBAAuB,QAAQ;AACxC,SAASC,oBAAoB,QAAQ;AACrC,SAASC,2BAA2B,QAAQ;AAC5C,SAASC,sBAAsB,QAAQ;AACvC,SAASC,iBAAiB,QAAQ;AAClC,SAASC,iBAAiB,QAAQ;AAClC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,gBAAgB,QAAQ;AACjC,SAASC,kBAAkB,QAAQ;AAEnC,SAASC,iBAAiB,QAAQ;AAElC,SAASC,mBAAmB,QAAQ;AACpC,SAASC,qBAAqB,QAAQ;AACtC,SAASC,oBAAoB,QAAQ","ignoreList":[]}

package/dist/exports/html-async/index.js

@@ -11,5 +11,4 @@ export { TextHTMLConverterAsync } from '../../features/converters/lexicalToHtml/
 export { UploadHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/upload.js';
 export { defaultHTMLConvertersAsync } from '../../features/converters/lexicalToHtml/async/defaultConverters.js';
 export { convertLexicalToHTMLAsync } from '../../features/converters/lexicalToHtml/async/index.js';
-
 //# sourceMappingURL=index.js.map

package/dist/exports/html-async/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/exports/html-async/index.ts"],"sourcesContent":["export { BlockquoteHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/blockquote.js'\nexport { HeadingHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/heading.js'\nexport { HorizontalRuleHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/horizontalRule.js'\nexport { LinebreakHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/linebreak.js'\nexport { LinkHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/link.js'\nexport { ListHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/list.js'\nexport { ParagraphHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/paragraph.js'\nexport { TabHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/tab.js'\nexport { TableHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/table.js'\nexport { TextHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/text.js'\n\nexport { UploadHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/upload.js'\n\nexport { defaultHTMLConvertersAsync } from '../../features/converters/lexicalToHtml/async/defaultConverters.js'\nexport { convertLexicalToHTMLAsync } from '../../features/converters/lexicalToHtml/async/index.js'\nexport type {\n  HTMLConverterAsync,\n  HTMLConvertersAsync,\n  HTMLConvertersFunctionAsync,\n} from '../../features/converters/lexicalToHtml/async/types.js'\n\nexport type {\n  ProvidedCSS,\n  SerializedLexicalNodeWithParent,\n} from '../../features/converters/lexicalToHtml/shared/types.js'\n"],"names":["BlockquoteHTMLConverterAsync","HeadingHTMLConverterAsync","HorizontalRuleHTMLConverterAsync","LinebreakHTMLConverterAsync","LinkHTMLConverterAsync","ListHTMLConverterAsync","ParagraphHTMLConverterAsync","TabHTMLConverterAsync","TableHTMLConverterAsync","TextHTMLConverterAsync","UploadHTMLConverterAsync","defaultHTMLConvertersAsync","convertLexicalToHTMLAsync"],"mappings":"AAAA,SAASA,4BAA4B,QAAQ,yEAAwE;AACrH,SAASC,yBAAyB,QAAQ,sEAAqE;AAC/G,SAASC,gCAAgC,QAAQ,6EAA4E;AAC7H,SAASC,2BAA2B,QAAQ,wEAAuE;AACnH,SAASC,sBAAsB,QAAQ,mEAAkE;AACzG,SAASC,sBAAsB,QAAQ,mEAAkE;AACzG,SAASC,2BAA2B,QAAQ,wEAAuE;AACnH,SAASC,qBAAqB,QAAQ,kEAAiE;AACvG,SAASC,uBAAuB,QAAQ,oEAAmE;AAC3G,SAASC,sBAAsB,QAAQ,mEAAkE;AAEzG,SAASC,wBAAwB,QAAQ,qEAAoE;AAE7G,SAASC,0BAA0B,QAAQ,qEAAoE;AAC/G,SAASC,yBAAyB,QAAQ,yDAAwD"}
+{"version":3,"file":"index.js","names":["BlockquoteHTMLConverterAsync","HeadingHTMLConverterAsync","HorizontalRuleHTMLConverterAsync","LinebreakHTMLConverterAsync","LinkHTMLConverterAsync","ListHTMLConverterAsync","ParagraphHTMLConverterAsync","TabHTMLConverterAsync","TableHTMLConverterAsync","TextHTMLConverterAsync","UploadHTMLConverterAsync","defaultHTMLConvertersAsync","convertLexicalToHTMLAsync"],"sources":["../../../src/exports/html-async/index.ts"],"sourcesContent":["export { BlockquoteHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/blockquote.js'\nexport { HeadingHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/heading.js'\nexport { HorizontalRuleHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/horizontalRule.js'\nexport { LinebreakHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/linebreak.js'\nexport { LinkHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/link.js'\nexport { ListHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/list.js'\nexport { ParagraphHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/paragraph.js'\nexport { TabHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/tab.js'\nexport { TableHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/table.js'\nexport { TextHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/text.js'\n\nexport { UploadHTMLConverterAsync } from '../../features/converters/lexicalToHtml/async/converters/upload.js'\n\nexport { defaultHTMLConvertersAsync } from '../../features/converters/lexicalToHtml/async/defaultConverters.js'\nexport { convertLexicalToHTMLAsync } from '../../features/converters/lexicalToHtml/async/index.js'\nexport type {\n  HTMLConverterAsync,\n  HTMLConvertersAsync,\n  HTMLConvertersFunctionAsync,\n} from '../../features/converters/lexicalToHtml/async/types.js'\n\nexport type {\n  ProvidedCSS,\n  SerializedLexicalNodeWithParent,\n} from '../../features/converters/lexicalToHtml/shared/types.js'\n"],"mappings":"AAAA,SAASA,4BAA4B,QAAQ;AAC7C,SAASC,yBAAyB,QAAQ;AAC1C,SAASC,gCAAgC,QAAQ;AACjD,SAASC,2BAA2B,QAAQ;AAC5C,SAASC,sBAAsB,QAAQ;AACvC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,2BAA2B,QAAQ;AAC5C,SAASC,qBAAqB,QAAQ;AACtC,SAASC,uBAAuB,QAAQ;AACxC,SAASC,sBAAsB,QAAQ;AAEvC,SAASC,wBAAwB,QAAQ;AAEzC,SAASC,0BAA0B,QAAQ;AAC3C,SAASC,yBAAyB,QAAQ","ignoreList":[]}

package/dist/exports/plaintext/index.js

@@ -1,3 +1,2 @@
 export { convertLexicalToPlaintext } from '../../features/converters/lexicalToPlaintext/sync/index.js';
-
 //# sourceMappingURL=index.js.map

package/dist/exports/plaintext/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/exports/plaintext/index.ts"],"sourcesContent":["export { convertLexicalToPlaintext } from '../../features/converters/lexicalToPlaintext/sync/index.js'\n\nexport type {\n  PlaintextConverter,\n  PlaintextConverters,\n} from '../../features/converters/lexicalToPlaintext/sync/types.js'\n"],"names":["convertLexicalToPlaintext"],"mappings":"AAAA,SAASA,yBAAyB,QAAQ,6DAA4D"}
+{"version":3,"file":"index.js","names":["convertLexicalToPlaintext"],"sources":["../../../src/exports/plaintext/index.ts"],"sourcesContent":["export { convertLexicalToPlaintext } from '../../features/converters/lexicalToPlaintext/sync/index.js'\n\nexport type {\n  PlaintextConverter,\n  PlaintextConverters,\n} from '../../features/converters/lexicalToPlaintext/sync/types.js'\n"],"mappings":"AAAA,SAASA,yBAAyB,QAAQ","ignoreList":[]}

package/dist/exports/react/index.js

@@ -12,5 +12,4 @@ export { TextJSXConverter } from '../../features/converters/lexicalToJSX/convert
 export { UploadJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/upload.js';
 export { defaultJSXConverters } from '../../features/converters/lexicalToJSX/converter/defaultConverters.js';
 export { convertLexicalNodesToJSX } from '../../features/converters/lexicalToJSX/converter/index.js';
-
 //# sourceMappingURL=index.js.map

package/dist/exports/react/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/exports/react/index.ts"],"sourcesContent":["export {\n  type JSXConvertersFunction,\n  RichText,\n} from '../../features/converters/lexicalToJSX/Component/index.js'\nexport { BlockquoteJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/blockquote.js'\nexport { HeadingJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/heading.js'\nexport { HorizontalRuleJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/horizontalRule.js'\nexport { LinebreakJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/linebreak.js'\nexport { LinkJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/link.js'\nexport { ListJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/list.js'\nexport { ParagraphJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/paragraph.js'\nexport { TabJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/tab.js'\nexport { TableJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/table.js'\n\nexport { TextJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/text.js'\n\nexport { UploadJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/upload.js'\nexport { defaultJSXConverters } from '../../features/converters/lexicalToJSX/converter/defaultConverters.js'\nexport { convertLexicalNodesToJSX } from '../../features/converters/lexicalToJSX/converter/index.js'\nexport type {\n  JSXConverter,\n  JSXConverters,\n  SerializedLexicalNodeWithParent,\n} from '../../features/converters/lexicalToJSX/converter/types.js'\n"],"names":["RichText","BlockquoteJSXConverter","HeadingJSXConverter","HorizontalRuleJSXConverter","LinebreakJSXConverter","LinkJSXConverter","ListJSXConverter","ParagraphJSXConverter","TabJSXConverter","TableJSXConverter","TextJSXConverter","UploadJSXConverter","defaultJSXConverters","convertLexicalNodesToJSX"],"mappings":"AAAA,SAEEA,QAAQ,QACH,4DAA2D;AAClE,SAASC,sBAAsB,QAAQ,4EAA2E;AAClH,SAASC,mBAAmB,QAAQ,yEAAwE;AAC5G,SAASC,0BAA0B,QAAQ,gFAA+E;AAC1H,SAASC,qBAAqB,QAAQ,2EAA0E;AAChH,SAASC,gBAAgB,QAAQ,sEAAqE;AACtG,SAASC,gBAAgB,QAAQ,sEAAqE;AACtG,SAASC,qBAAqB,QAAQ,2EAA0E;AAChH,SAASC,eAAe,QAAQ,qEAAoE;AACpG,SAASC,iBAAiB,QAAQ,uEAAsE;AAExG,SAASC,gBAAgB,QAAQ,sEAAqE;AAEtG,SAASC,kBAAkB,QAAQ,wEAAuE;AAC1G,SAASC,oBAAoB,QAAQ,wEAAuE;AAC5G,SAASC,wBAAwB,QAAQ,4DAA2D"}
+{"version":3,"file":"index.js","names":["RichText","BlockquoteJSXConverter","HeadingJSXConverter","HorizontalRuleJSXConverter","LinebreakJSXConverter","LinkJSXConverter","ListJSXConverter","ParagraphJSXConverter","TabJSXConverter","TableJSXConverter","TextJSXConverter","UploadJSXConverter","defaultJSXConverters","convertLexicalNodesToJSX"],"sources":["../../../src/exports/react/index.ts"],"sourcesContent":["export {\n  type JSXConvertersFunction,\n  RichText,\n} from '../../features/converters/lexicalToJSX/Component/index.js'\nexport { BlockquoteJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/blockquote.js'\nexport { HeadingJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/heading.js'\nexport { HorizontalRuleJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/horizontalRule.js'\nexport { LinebreakJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/linebreak.js'\nexport { LinkJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/link.js'\nexport { ListJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/list.js'\nexport { ParagraphJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/paragraph.js'\nexport { TabJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/tab.js'\nexport { TableJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/table.js'\n\nexport { TextJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/text.js'\n\nexport { UploadJSXConverter } from '../../features/converters/lexicalToJSX/converter/converters/upload.js'\nexport { defaultJSXConverters } from '../../features/converters/lexicalToJSX/converter/defaultConverters.js'\nexport { convertLexicalNodesToJSX } from '../../features/converters/lexicalToJSX/converter/index.js'\nexport type {\n  JSXConverter,\n  JSXConverters,\n  SerializedLexicalNodeWithParent,\n} from '../../features/converters/lexicalToJSX/converter/types.js'\n"],"mappings":"AAAA,SAEEA,QAAQ,QACH;AACP,SAASC,sBAAsB,QAAQ;AACvC,SAASC,mBAAmB,QAAQ;AACpC,SAASC,0BAA0B,QAAQ;AAC3C,SAASC,qBAAqB,QAAQ;AACtC,SAASC,gBAAgB,QAAQ;AACjC,SAASC,gBAAgB,QAAQ;AACjC,SAASC,qBAAqB,QAAQ;AACtC,SAASC,eAAe,QAAQ;AAChC,SAASC,iBAAiB,QAAQ;AAElC,SAASC,gBAAgB,QAAQ;AAEjC,SAASC,kBAAkB,QAAQ;AACnC,SAASC,oBAAoB,QAAQ;AACrC,SAASC,wBAAwB,QAAQ","ignoreList":[]}

package/dist/exports/server/ast/mdx.js

@@ -2,44 +2,42 @@ import * as acorn from 'acorn';
 import { fromMarkdown } from 'mdast-util-from-markdown';
 import { mdxJsxFromMarkdown } from 'mdast-util-mdx-jsx';
 import { mdxJsx } from 'micromark-extension-mdx-jsx';
-export function parseJSXToAST({ jsxString, keepPositions }) {
-    const treeComplex = fromMarkdown(jsxString, {
-        // @ts-expect-error
-        extensions: [
-            mdxJsx({
-                acorn,
-                addResult: false
-            })
-        ],
-        mdastExtensions: [
-            mdxJsxFromMarkdown()
-        ]
-    });
-    // Remove "position" keys
-    const parseTree = (tree)=>{
-        for(const key in tree){
-            // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
-            if (key === 'position' && tree[key].start && tree[key].end) {
-                // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
-                delete tree[key];
-            } else // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
-            if (typeof tree[key] === 'object') {
-                // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
-                parseTree(tree[key]);
-            } else // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
-            if (Array.isArray(tree[key])) {
-                // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
-                for (const item of tree[key]){
-                    parseTree(item);
-                }
-            }
+export function parseJSXToAST({
+  jsxString,
+  keepPositions
+}) {
+  const treeComplex = fromMarkdown(jsxString, {
+    // @ts-expect-error
+    extensions: [mdxJsx({
+      acorn,
+      addResult: false
+    })],
+    mdastExtensions: [mdxJsxFromMarkdown()]
+  });
+  // Remove "position" keys
+  const parseTree = tree => {
+    for (const key in tree) {
+      // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
+      if (key === 'position' && tree[key].start && tree[key].end) {
+        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
+        delete tree[key];
+        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
+      } else if (typeof tree[key] === 'object') {
+        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
+        parseTree(tree[key]);
+        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
+      } else if (Array.isArray(tree[key])) {
+        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
+        for (const item of tree[key]) {
+          parseTree(item);
         }
-    };
-    const tree = treeComplex;
-    if (keepPositions !== true) {
-        parseTree(tree);
+      }
     }
-    return tree;
+  };
+  const tree = treeComplex;
+  if (keepPositions !== true) {
+    parseTree(tree);
+  }
+  return tree;
 }
-
 //# sourceMappingURL=mdx.js.map

package/dist/exports/server/ast/mdx.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/exports/server/ast/mdx.ts"],"sourcesContent":["import * as acorn from 'acorn'\nimport { fromMarkdown } from 'mdast-util-from-markdown'\nimport { mdxJsxFromMarkdown } from 'mdast-util-mdx-jsx'\nimport { mdxJsx } from 'micromark-extension-mdx-jsx'\n\nexport type AST = ReturnType<typeof fromMarkdown>\n\nexport function parseJSXToAST({\n  jsxString,\n  keepPositions,\n}: {\n  jsxString: string\n  keepPositions?: boolean\n}): AST {\n  const treeComplex: AST = fromMarkdown(jsxString, {\n    // @ts-expect-error\n    extensions: [mdxJsx({ acorn, addResult: false })],\n    mdastExtensions: [mdxJsxFromMarkdown()],\n  })\n\n  // Remove \"position\" keys\n  const parseTree = (tree: object) => {\n    for (const key in tree) {\n      // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n      if (key === 'position' && tree[key].start && tree[key].end) {\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n        delete tree[key]\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n      } else if (typeof tree[key] === 'object') {\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n        parseTree(tree[key])\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n      } else if (Array.isArray(tree[key])) {\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n        for (const item of tree[key]) {\n          parseTree(item)\n        }\n      }\n    }\n  }\n\n  const tree: AST = treeComplex\n\n  if (keepPositions !== true) {\n    parseTree(tree)\n  }\n\n  return tree\n}\n"],"names":["acorn","fromMarkdown","mdxJsxFromMarkdown","mdxJsx","parseJSXToAST","jsxString","keepPositions","treeComplex","extensions","addResult","mdastExtensions","parseTree","tree","key","start","end","Array","isArray","item"],"mappings":"AAAA,YAAYA,WAAW,QAAO;AAC9B,SAASC,YAAY,QAAQ,2BAA0B;AACvD,SAASC,kBAAkB,QAAQ,qBAAoB;AACvD,SAASC,MAAM,QAAQ,8BAA6B;AAIpD,OAAO,SAASC,cAAc,EAC5BC,SAAS,EACTC,aAAa,EAId;IACC,MAAMC,cAAmBN,aAAaI,WAAW;QAC/C,mBAAmB;QACnBG,YAAY;YAACL,OAAO;gBAAEH;gBAAOS,WAAW;YAAM;SAAG;QACjDC,iBAAiB;YAACR;SAAqB;IACzC;IAEA,yBAAyB;IACzB,MAAMS,YAAY,CAACC;QACjB,IAAK,MAAMC,OAAOD,KAAM;YACtB,oFAAoF;YACpF,IAAIC,QAAQ,cAAcD,IAAI,CAACC,IAAI,CAACC,KAAK,IAAIF,IAAI,CAACC,IAAI,CAACE,GAAG,EAAE;gBAC1D,oFAAoF;gBACpF,OAAOH,IAAI,CAACC,IAAI;YAElB,OADE,oFAAoF;YAC/E,IAAI,OAAOD,IAAI,CAACC,IAAI,KAAK,UAAU;gBACxC,oFAAoF;gBACpFF,UAAUC,IAAI,CAACC,IAAI;YAErB,OADE,oFAAoF;YAC/E,IAAIG,MAAMC,OAAO,CAACL,IAAI,CAACC,IAAI,GAAG;gBACnC,oFAAoF;gBACpF,KAAK,MAAMK,QAAQN,IAAI,CAACC,IAAI,CAAE;oBAC5BF,UAAUO;gBACZ;YACF;QACF;IACF;IAEA,MAAMN,OAAYL;IAElB,IAAID,kBAAkB,MAAM;QAC1BK,UAAUC;IACZ;IAEA,OAAOA;AACT"}
+{"version":3,"file":"mdx.js","names":["acorn","fromMarkdown","mdxJsxFromMarkdown","mdxJsx","parseJSXToAST","jsxString","keepPositions","treeComplex","extensions","addResult","mdastExtensions","parseTree","tree","key","start","end","Array","isArray","item"],"sources":["../../../../src/exports/server/ast/mdx.ts"],"sourcesContent":["import * as acorn from 'acorn'\nimport { fromMarkdown } from 'mdast-util-from-markdown'\nimport { mdxJsxFromMarkdown } from 'mdast-util-mdx-jsx'\nimport { mdxJsx } from 'micromark-extension-mdx-jsx'\n\nexport type AST = ReturnType<typeof fromMarkdown>\n\nexport function parseJSXToAST({\n  jsxString,\n  keepPositions,\n}: {\n  jsxString: string\n  keepPositions?: boolean\n}): AST {\n  const treeComplex: AST = fromMarkdown(jsxString, {\n    // @ts-expect-error\n    extensions: [mdxJsx({ acorn, addResult: false })],\n    mdastExtensions: [mdxJsxFromMarkdown()],\n  })\n\n  // Remove \"position\" keys\n  const parseTree = (tree: object) => {\n    for (const key in tree) {\n      // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n      if (key === 'position' && tree[key].start && tree[key].end) {\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n        delete tree[key]\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n      } else if (typeof tree[key] === 'object') {\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n        parseTree(tree[key])\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n      } else if (Array.isArray(tree[key])) {\n        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n        for (const item of tree[key]) {\n          parseTree(item)\n        }\n      }\n    }\n  }\n\n  const tree: AST = treeComplex\n\n  if (keepPositions !== true) {\n    parseTree(tree)\n  }\n\n  return tree\n}\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AACvB,SAASC,YAAY,QAAQ;AAC7B,SAASC,kBAAkB,QAAQ;AACnC,SAASC,MAAM,QAAQ;AAIvB,OAAO,SAASC,cAAc;EAC5BC,SAAS;EACTC;AAAa,CAId;EACC,MAAMC,WAAA,GAAmBN,YAAA,CAAaI,SAAA,EAAW;IAC/C;IACAG,UAAA,EAAY,CAACL,MAAA,CAAO;MAAEH,KAAA;MAAOS,SAAA,EAAW;IAAM,GAAG;IACjDC,eAAA,EAAiB,CAACR,kBAAA;EACpB;EAEA;EACA,MAAMS,SAAA,GAAaC,IAAA;IACjB,KAAK,MAAMC,GAAA,IAAOD,IAAA,EAAM;MACtB;MACA,IAAIC,GAAA,KAAQ,cAAcD,IAAI,CAACC,GAAA,CAAI,CAACC,KAAK,IAAIF,IAAI,CAACC,GAAA,CAAI,CAACE,GAAG,EAAE;QAC1D;QACA,OAAOH,IAAI,CAACC,GAAA,CAAI;QAChB;MACF,OAAO,IAAI,OAAOD,IAAI,CAACC,GAAA,CAAI,KAAK,UAAU;QACxC;QACAF,SAAA,CAAUC,IAAI,CAACC,GAAA,CAAI;QACnB;MACF,OAAO,IAAIG,KAAA,CAAMC,OAAO,CAACL,IAAI,CAACC,GAAA,CAAI,GAAG;QACnC;QACA,KAAK,MAAMK,IAAA,IAAQN,IAAI,CAACC,GAAA,CAAI,EAAE;UAC5BF,SAAA,CAAUO,IAAA;QACZ;MACF;IACF;EACF;EAEA,MAAMN,IAAA,GAAYL,WAAA;EAElB,IAAID,aAAA,KAAkB,MAAM;IAC1BK,SAAA,CAAUC,IAAA;EACZ;EAEA,OAAOA,IAAA;AACT","ignoreList":[]}

package/dist/exports/server/migrate.js

@@ -13,5 +13,4 @@ export { defaultSlateConverters } from '../../features/migrations/slateToLexical
 export { convertSlateNodesToLexical, convertSlateToLexical } from '../../features/migrations/slateToLexical/converter/index.js';
 export { SlateToLexicalFeature } from '../../features/migrations/slateToLexical/feature.server.js';
 export { migrateSlateToLexical } from '../../utilities/migrateSlateToLexical/index.js';
-
 //# sourceMappingURL=migrate.js.map

package/dist/exports/server/migrate.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/exports/server/migrate.ts"],"sourcesContent":["export { LexicalPluginToLexicalFeature } from '../../features/migrations/lexicalPluginToLexical/feature.server.js'\nexport { SlateBlockquoteConverter } from '../../features/migrations/slateToLexical/converter/converters/blockquote/converter.js'\nexport { SlateHeadingConverter } from '../../features/migrations/slateToLexical/converter/converters/heading/converter.js'\nexport { SlateIndentConverter } from '../../features/migrations/slateToLexical/converter/converters/indent/converter.js'\nexport { SlateLinkConverter } from '../../features/migrations/slateToLexical/converter/converters/link/converter.js'\nexport { SlateListItemConverter } from '../../features/migrations/slateToLexical/converter/converters/listItem/converter.js'\nexport { SlateOrderedListConverter } from '../../features/migrations/slateToLexical/converter/converters/orderedList/converter.js'\nexport { SlateRelationshipConverter } from '../../features/migrations/slateToLexical/converter/converters/relationship/converter.js'\nexport { SlateUnknownConverter } from '../../features/migrations/slateToLexical/converter/converters/unknown/converter.js'\nexport { SlateUnorderedListConverter } from '../../features/migrations/slateToLexical/converter/converters/unorderedList/converter.js'\nexport { SlateUploadConverter } from '../../features/migrations/slateToLexical/converter/converters/upload/converter.js'\nexport { defaultSlateConverters } from '../../features/migrations/slateToLexical/converter/defaultConverters.js'\nexport {\n  convertSlateNodesToLexical,\n  convertSlateToLexical,\n} from '../../features/migrations/slateToLexical/converter/index.js'\n\nexport { SlateToLexicalFeature } from '../../features/migrations/slateToLexical/feature.server.js'\nexport { migrateSlateToLexical } from '../../utilities/migrateSlateToLexical/index.js'\n"],"names":["LexicalPluginToLexicalFeature","SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters","convertSlateNodesToLexical","convertSlateToLexical","SlateToLexicalFeature","migrateSlateToLexical"],"mappings":"AAAA,SAASA,6BAA6B,QAAQ,qEAAoE;AAClH,SAASC,wBAAwB,QAAQ,wFAAuF;AAChI,SAASC,qBAAqB,QAAQ,qFAAoF;AAC1H,SAASC,oBAAoB,QAAQ,oFAAmF;AACxH,SAASC,kBAAkB,QAAQ,kFAAiF;AACpH,SAASC,sBAAsB,QAAQ,sFAAqF;AAC5H,SAASC,yBAAyB,QAAQ,yFAAwF;AAClI,SAASC,0BAA0B,QAAQ,0FAAyF;AACpI,SAASC,qBAAqB,QAAQ,qFAAoF;AAC1H,SAASC,2BAA2B,QAAQ,2FAA0F;AACtI,SAASC,oBAAoB,QAAQ,oFAAmF;AACxH,SAASC,sBAAsB,QAAQ,0EAAyE;AAChH,SACEC,0BAA0B,EAC1BC,qBAAqB,QAChB,8DAA6D;AAEpE,SAASC,qBAAqB,QAAQ,6DAA4D;AAClG,SAASC,qBAAqB,QAAQ,iDAAgD"}
+{"version":3,"file":"migrate.js","names":["LexicalPluginToLexicalFeature","SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters","convertSlateNodesToLexical","convertSlateToLexical","SlateToLexicalFeature","migrateSlateToLexical"],"sources":["../../../src/exports/server/migrate.ts"],"sourcesContent":["export { LexicalPluginToLexicalFeature } from '../../features/migrations/lexicalPluginToLexical/feature.server.js'\nexport { SlateBlockquoteConverter } from '../../features/migrations/slateToLexical/converter/converters/blockquote/converter.js'\nexport { SlateHeadingConverter } from '../../features/migrations/slateToLexical/converter/converters/heading/converter.js'\nexport { SlateIndentConverter } from '../../features/migrations/slateToLexical/converter/converters/indent/converter.js'\nexport { SlateLinkConverter } from '../../features/migrations/slateToLexical/converter/converters/link/converter.js'\nexport { SlateListItemConverter } from '../../features/migrations/slateToLexical/converter/converters/listItem/converter.js'\nexport { SlateOrderedListConverter } from '../../features/migrations/slateToLexical/converter/converters/orderedList/converter.js'\nexport { SlateRelationshipConverter } from '../../features/migrations/slateToLexical/converter/converters/relationship/converter.js'\nexport { SlateUnknownConverter } from '../../features/migrations/slateToLexical/converter/converters/unknown/converter.js'\nexport { SlateUnorderedListConverter } from '../../features/migrations/slateToLexical/converter/converters/unorderedList/converter.js'\nexport { SlateUploadConverter } from '../../features/migrations/slateToLexical/converter/converters/upload/converter.js'\nexport { defaultSlateConverters } from '../../features/migrations/slateToLexical/converter/defaultConverters.js'\nexport {\n  convertSlateNodesToLexical,\n  convertSlateToLexical,\n} from '../../features/migrations/slateToLexical/converter/index.js'\n\nexport { SlateToLexicalFeature } from '../../features/migrations/slateToLexical/feature.server.js'\nexport { migrateSlateToLexical } from '../../utilities/migrateSlateToLexical/index.js'\n"],"mappings":"AAAA,SAASA,6BAA6B,QAAQ;AAC9C,SAASC,wBAAwB,QAAQ;AACzC,SAASC,qBAAqB,QAAQ;AACtC,SAASC,oBAAoB,QAAQ;AACrC,SAASC,kBAAkB,QAAQ;AACnC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,yBAAyB,QAAQ;AAC1C,SAASC,0BAA0B,QAAQ;AAC3C,SAASC,qBAAqB,QAAQ;AACtC,SAASC,2BAA2B,QAAQ;AAC5C,SAASC,oBAAoB,QAAQ;AACrC,SAASC,sBAAsB,QAAQ;AACvC,SACEC,0BAA0B,EAC1BC,qBAAqB,QAChB;AAEP,SAASC,qBAAqB,QAAQ;AACtC,SAASC,qBAAqB,QAAQ","ignoreList":[]}

package/dist/exports/server/rsc.js

@@ -1,5 +1,4 @@
 export { RscEntryLexicalCell } from '../../cell/rscEntry.js';
 export { LexicalDiffComponent } from '../../field/Diff/index.js';
 export { RscEntryLexicalField } from '../../field/rscEntry.js';
-
 //# sourceMappingURL=rsc.js.map

package/dist/exports/server/rsc.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/exports/server/rsc.ts"],"sourcesContent":["export { RscEntryLexicalCell } from '../../cell/rscEntry.js'\nexport { LexicalDiffComponent } from '../../field/Diff/index.js'\nexport { RscEntryLexicalField } from '../../field/rscEntry.js'\n"],"names":["RscEntryLexicalCell","LexicalDiffComponent","RscEntryLexicalField"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ,yBAAwB;AAC5D,SAASC,oBAAoB,QAAQ,4BAA2B;AAChE,SAASC,oBAAoB,QAAQ,0BAAyB"}
+{"version":3,"file":"rsc.js","names":["RscEntryLexicalCell","LexicalDiffComponent","RscEntryLexicalField"],"sources":["../../../src/exports/server/rsc.ts"],"sourcesContent":["export { RscEntryLexicalCell } from '../../cell/rscEntry.js'\nexport { LexicalDiffComponent } from '../../field/Diff/index.js'\nexport { RscEntryLexicalField } from '../../field/rscEntry.js'\n"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,oBAAoB,QAAQ;AACrC,SAASC,oBAAoB,QAAQ","ignoreList":[]}

package/dist/exports/shared.js

@@ -2,5 +2,4 @@ export { collectTopLevelJSXInLines } from '../utilities/jsx/collectTopLevelJSXIn
 export { extractPropsFromJSXPropsString } from '../utilities/jsx/extractPropsFromJSXPropsString.js';
 export { extractFrontmatter, frontmatterToObject, objectToFrontmatter, propsToJSXString } from '../utilities/jsx/jsx.js';
 export { hasText } from '../validate/hasText.js';
-
 //# sourceMappingURL=shared.js.map

package/dist/exports/shared.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/exports/shared.ts"],"sourcesContent":["export { collectTopLevelJSXInLines } from '../utilities/jsx/collectTopLevelJSXInLines.js'\n\nexport { extractPropsFromJSXPropsString } from '../utilities/jsx/extractPropsFromJSXPropsString.js'\nexport {\n  extractFrontmatter,\n  frontmatterToObject,\n  objectToFrontmatter,\n  propsToJSXString,\n} from '../utilities/jsx/jsx.js'\nexport { hasText } from '../validate/hasText.js'\n"],"names":["collectTopLevelJSXInLines","extractPropsFromJSXPropsString","extractFrontmatter","frontmatterToObject","objectToFrontmatter","propsToJSXString","hasText"],"mappings":"AAAA,SAASA,yBAAyB,QAAQ,gDAA+C;AAEzF,SAASC,8BAA8B,QAAQ,qDAAoD;AACnG,SACEC,kBAAkB,EAClBC,mBAAmB,EACnBC,mBAAmB,EACnBC,gBAAgB,QACX,0BAAyB;AAChC,SAASC,OAAO,QAAQ,yBAAwB"}
+{"version":3,"file":"shared.js","names":["collectTopLevelJSXInLines","extractPropsFromJSXPropsString","extractFrontmatter","frontmatterToObject","objectToFrontmatter","propsToJSXString","hasText"],"sources":["../../src/exports/shared.ts"],"sourcesContent":["export { collectTopLevelJSXInLines } from '../utilities/jsx/collectTopLevelJSXInLines.js'\n\nexport { extractPropsFromJSXPropsString } from '../utilities/jsx/extractPropsFromJSXPropsString.js'\nexport {\n  extractFrontmatter,\n  frontmatterToObject,\n  objectToFrontmatter,\n  propsToJSXString,\n} from '../utilities/jsx/jsx.js'\nexport { hasText } from '../validate/hasText.js'\n"],"mappings":"AAAA,SAASA,yBAAyB,QAAQ;AAE1C,SAASC,8BAA8B,QAAQ;AAC/C,SACEC,kBAAkB,EAClBC,mBAAmB,EACnBC,mBAAmB,EACnBC,gBAAgB,QACX;AACP,SAASC,OAAO,QAAQ","ignoreList":[]}

package/dist/features/align/client/index.js

@@ -1,4 +1,6 @@
 'use client';
+
+import { c as _c } from "react/compiler-runtime";
 import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
 import { $isDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
 import { $findMatchingParent } from '@lexical/utils';
@@ -12,177 +14,202 @@ import { createClientFeature } from '../../../utilities/createClientFeature.js';
 import { toolbarAlignGroupWithItems } from './toolbarAlignGroup.js';
 // DecoratorBlockNode has format, but Lexical forgot
 // to add the getters like ElementNode does.
-const getFormatType = (node)=>{
-    if ($isElementNode(node)) {
-        return node.getFormatType();
-    }
-    return node.__format;
+const getFormatType = node => {
+  if ($isElementNode(node)) {
+    return node.getFormatType();
+  }
+  return node.__format;
 };
-const toolbarGroups = [
-    toolbarAlignGroupWithItems([
-        {
-            ChildComponent: AlignLeftIcon,
-            isActive: ({ selection })=>{
-                if (!$isRangeSelection(selection)) {
-                    return false;
-                }
-                for (const node of selection.getNodes()){
-                    if ($isElementNode(node) || $isDecoratorBlockNode(node)) {
-                        if (getFormatType(node) === 'left') {
-                            continue;
-                        }
-                    }
-                    const parent = node.getParent();
-                    if ($isElementNode(parent) || $isDecoratorBlockNode(parent)) {
-                        if (getFormatType(parent) === 'left') {
-                            continue;
-                        }
-                    }
-                    return false;
-                }
-                return true;
-            },
-            key: 'alignLeft',
-            label: ({ i18n })=>{
-                return i18n.t('lexical:align:alignLeftLabel');
-            },
-            onSelect: ({ editor })=>{
-                editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'left');
-            },
-            order: 1
-        },
-        {
-            ChildComponent: AlignCenterIcon,
-            isActive: ({ selection })=>{
-                if (!$isRangeSelection(selection)) {
-                    return false;
-                }
-                for (const node of selection.getNodes()){
-                    if ($isElementNode(node) || $isDecoratorBlockNode(node)) {
-                        if (getFormatType(node) === 'center') {
-                            continue;
-                        }
-                    }
-                    const parent = node.getParent();
-                    if ($isElementNode(parent) || $isDecoratorBlockNode(parent)) {
-                        if (getFormatType(parent) === 'center') {
-                            continue;
-                        }
-                    }
-                    return false;
-                }
-                return true;
-            },
-            key: 'alignCenter',
-            label: ({ i18n })=>{
-                return i18n.t('lexical:align:alignCenterLabel');
-            },
-            onSelect: ({ editor })=>{
-                editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'center');
-            },
-            order: 2
-        },
-        {
-            ChildComponent: AlignRightIcon,
-            isActive: ({ selection })=>{
-                if (!$isRangeSelection(selection)) {
-                    return false;
-                }
-                for (const node of selection.getNodes()){
-                    if ($isElementNode(node) || $isDecoratorBlockNode(node)) {
-                        if (getFormatType(node) === 'right') {
-                            continue;
-                        }
-                    }
-                    const parent = node.getParent();
-                    if ($isElementNode(parent) || $isDecoratorBlockNode(parent)) {
-                        if (getFormatType(parent) === 'right') {
-                            continue;
-                        }
-                    }
-                    return false;
-                }
-                return true;
-            },
-            key: 'alignRight',
-            label: ({ i18n })=>{
-                return i18n.t('lexical:align:alignRightLabel');
-            },
-            onSelect: ({ editor })=>{
-                editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'right');
-            },
-            order: 3
-        },
-        {
-            ChildComponent: AlignJustifyIcon,
-            isActive: ({ selection })=>{
-                if (!$isRangeSelection(selection)) {
-                    return false;
-                }
-                for (const node of selection.getNodes()){
-                    if ($isElementNode(node) || $isDecoratorBlockNode(node)) {
-                        if (getFormatType(node) === 'justify') {
-                            continue;
-                        }
-                    }
-                    const parent = node.getParent();
-                    if ($isElementNode(parent) || $isDecoratorBlockNode(parent)) {
-                        if (getFormatType(parent) === 'justify') {
-                            continue;
-                        }
-                    }
-                    return false;
-                }
-                return true;
-            },
-            key: 'alignJustify',
-            label: ({ i18n })=>{
-                return i18n.t('lexical:align:alignJustifyLabel');
-            },
-            onSelect: ({ editor })=>{
-                editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'justify');
-            },
-            order: 4
+const toolbarGroups = [toolbarAlignGroupWithItems([{
+  ChildComponent: AlignLeftIcon,
+  isActive: ({
+    selection
+  }) => {
+    if (!$isRangeSelection(selection)) {
+      return false;
+    }
+    for (const node of selection.getNodes()) {
+      if ($isElementNode(node) || $isDecoratorBlockNode(node)) {
+        if (getFormatType(node) === 'left') {
+          continue;
         }
-    ])
-];
-const AlignPlugin = ()=>{
-    const [editor] = useLexicalComposerContext();
-    useEffect(()=>{
-        // Just like the default Lexical configuration, but in
-        // addition to ElementNode we also set DecoratorBlocks
-        return editor.registerCommand(FORMAT_ELEMENT_COMMAND, (format)=>{
-            const selection = $getSelection();
-            if (!$isRangeSelection(selection) && !$isNodeSelection(selection)) {
-                return false;
-            }
-            const nodes = selection.getNodes();
-            for (const node of nodes){
-                const element = $findMatchingParent(node, (parentNode)=>($isElementNode(parentNode) || $isDecoratorBlockNode(parentNode)) && !parentNode.isInline());
-                if (element !== null) {
-                    element.setFormat(format);
-                }
-            }
-            return true;
-        }, COMMAND_PRIORITY_LOW);
-    }, [
-        editor
-    ]);
-    return null;
-};
-export const AlignFeatureClient = createClientFeature({
-    plugins: [
-        {
-            Component: AlignPlugin,
-            position: 'normal'
+      }
+      const parent = node.getParent();
+      if ($isElementNode(parent) || $isDecoratorBlockNode(parent)) {
+        if (getFormatType(parent) === 'left') {
+          continue;
         }
-    ],
-    toolbarFixed: {
-        groups: toolbarGroups
-    },
-    toolbarInline: {
-        groups: toolbarGroups
+      }
+      return false;
+    }
+    return true;
+  },
+  key: 'alignLeft',
+  label: ({
+    i18n
+  }) => {
+    return i18n.t('lexical:align:alignLeftLabel');
+  },
+  onSelect: ({
+    editor
+  }) => {
+    editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'left');
+  },
+  order: 1
+}, {
+  ChildComponent: AlignCenterIcon,
+  isActive: ({
+    selection
+  }) => {
+    if (!$isRangeSelection(selection)) {
+      return false;
     }
+    for (const node of selection.getNodes()) {
+      if ($isElementNode(node) || $isDecoratorBlockNode(node)) {
+        if (getFormatType(node) === 'center') {
+          continue;
+        }
+      }
+      const parent = node.getParent();
+      if ($isElementNode(parent) || $isDecoratorBlockNode(parent)) {
+        if (getFormatType(parent) === 'center') {
+          continue;
+        }
+      }
+      return false;
+    }
+    return true;
+  },
+  key: 'alignCenter',
+  label: ({
+    i18n
+  }) => {
+    return i18n.t('lexical:align:alignCenterLabel');
+  },
+  onSelect: ({
+    editor
+  }) => {
+    editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'center');
+  },
+  order: 2
+}, {
+  ChildComponent: AlignRightIcon,
+  isActive: ({
+    selection
+  }) => {
+    if (!$isRangeSelection(selection)) {
+      return false;
+    }
+    for (const node of selection.getNodes()) {
+      if ($isElementNode(node) || $isDecoratorBlockNode(node)) {
+        if (getFormatType(node) === 'right') {
+          continue;
+        }
+      }
+      const parent = node.getParent();
+      if ($isElementNode(parent) || $isDecoratorBlockNode(parent)) {
+        if (getFormatType(parent) === 'right') {
+          continue;
+        }
+      }
+      return false;
+    }
+    return true;
+  },
+  key: 'alignRight',
+  label: ({
+    i18n
+  }) => {
+    return i18n.t('lexical:align:alignRightLabel');
+  },
+  onSelect: ({
+    editor
+  }) => {
+    editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'right');
+  },
+  order: 3
+}, {
+  ChildComponent: AlignJustifyIcon,
+  isActive: ({
+    selection
+  }) => {
+    if (!$isRangeSelection(selection)) {
+      return false;
+    }
+    for (const node of selection.getNodes()) {
+      if ($isElementNode(node) || $isDecoratorBlockNode(node)) {
+        if (getFormatType(node) === 'justify') {
+          continue;
+        }
+      }
+      const parent = node.getParent();
+      if ($isElementNode(parent) || $isDecoratorBlockNode(parent)) {
+        if (getFormatType(parent) === 'justify') {
+          continue;
+        }
+      }
+      return false;
+    }
+    return true;
+  },
+  key: 'alignJustify',
+  label: ({
+    i18n
+  }) => {
+    return i18n.t('lexical:align:alignJustifyLabel');
+  },
+  onSelect: ({
+    editor
+  }) => {
+    editor.dispatchCommand(FORMAT_ELEMENT_COMMAND, 'justify');
+  },
+  order: 4
+}])];
+const AlignPlugin = () => {
+  const $ = _c(3);
+  const [editor] = useLexicalComposerContext();
+  let t0;
+  let t1;
+  if ($[0] !== editor) {
+    t0 = () => editor.registerCommand(FORMAT_ELEMENT_COMMAND, _temp2, COMMAND_PRIORITY_LOW);
+    t1 = [editor];
+    $[0] = editor;
+    $[1] = t0;
+    $[2] = t1;
+  } else {
+    t0 = $[1];
+    t1 = $[2];
+  }
+  useEffect(t0, t1);
+  return null;
+};
+export const AlignFeatureClient = createClientFeature({
+  plugins: [{
+    Component: AlignPlugin,
+    position: 'normal'
+  }],
+  toolbarFixed: {
+    groups: toolbarGroups
+  },
+  toolbarInline: {
+    groups: toolbarGroups
+  }
 });
-
+function _temp(parentNode) {
+  return ($isElementNode(parentNode) || $isDecoratorBlockNode(parentNode)) && !parentNode.isInline();
+}
+function _temp2(format) {
+  const selection = $getSelection();
+  if (!$isRangeSelection(selection) && !$isNodeSelection(selection)) {
+    return false;
+  }
+  const nodes = selection.getNodes();
+  for (const node of nodes) {
+    const element = $findMatchingParent(node, _temp);
+    if (element !== null) {
+      element.setFormat(format);
+    }
+  }
+  return true;
+}
 //# sourceMappingURL=index.js.map