@payloadcms/richtext-lexical 3.57.0-canary.7 → 3.57.0-internal.266049e

package/dist/features/blocks/client/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/client/index.tsx"],"names":[],"mappings":"AAqBA,eAAO,MAAM,mBAAmB,8EAyL/B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/blocks/client/index.tsx"],"names":[],"mappings":"AAsBA,eAAO,MAAM,mBAAmB,8EA6L/B,CAAA"}

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

@@ -5,6 +5,7 @@ import { BlockIcon } from '../../../lexical/ui/icons/Block/index.js';
 import { InlineBlocksIcon } from '../../../lexical/ui/icons/InlineBlocks/index.js';
 import { createClientFeature } from '../../../utilities/createClientFeature.js';
 import { getBlockImageComponent } from './getBlockImageComponent.js';
+import { getBlockMarkdownTransformers } from './markdown/markdownTransformer.js';
 import { BlockNode } from './nodes/BlocksNode.js';
 import { InlineBlockNode } from './nodes/InlineBlocksNode.js';
 import { INSERT_BLOCK_COMMAND, INSERT_INLINE_BLOCK_COMMAND } from './plugin/commands.js';
@@ -30,6 +31,10 @@ export const BlocksFeatureClient = createClientFeature(({
     return field.blockReferences ? typeof field.blockReferences[0] === 'string' ? config.blocksMap[field.blockReferences[0]] : field.blockReferences[0] : field.blocks[0];
   }).filter(block => block !== undefined);
   return {
+    markdownTransformers: getBlockMarkdownTransformers({
+      blocks: clientBlocks,
+      inlineBlocks: clientInlineBlocks
+    }),
     nodes: [BlockNode, InlineBlockNode],
     plugins: [{
       Component: BlocksPlugin,

package/dist/features/blocks/client/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["getTranslation","BlockIcon","InlineBlocksIcon","createClientFeature","getBlockImageComponent","BlockNode","InlineBlockNode","INSERT_BLOCK_COMMAND","INSERT_INLINE_BLOCK_COMMAND","BlocksPlugin","BlocksFeatureClient","config","featureClientSchemaMap","props","schemaPath","schemaMapRenderedBlockPathPrefix","schemaMapRenderedInlineBlockPathPrefix","clientSchema","blocksFields","Object","entries","filter","key","startsWith","replace","includes","map","value","inlineBlocksFields","clientBlocks","field","blockReferences","blocksMap","blocks","block","undefined","clientInlineBlocks","nodes","plugins","Component","position","sanitizedClientFeatureProps","slashMenu","groups","length","items","Icon","imageURL","imageAltText","slug","keywords","label","i18n","blockDisplayName","labels","singular","onSelect","editor","dispatchCommand","blockName","blockType","t","inlineBlock","Boolean","toolbarFixed","type","ChildComponent","index","isActive","order"],"sources":["../../../../src/features/blocks/client/index.tsx"],"sourcesContent":["'use client'\n\nimport type { I18nClient } from '@payloadcms/translations'\nimport type { BlocksFieldClient, ClientBlock } from 'payload'\n\nimport { getTranslation } from '@payloadcms/translations'\n\nimport type {\n  SlashMenuGroup,\n  SlashMenuItem,\n} from '../../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nimport type { ToolbarGroup, ToolbarGroupItem } from '../../toolbars/types.js'\n\nimport { BlockIcon } from '../../../lexical/ui/icons/Block/index.js'\nimport { InlineBlocksIcon } from '../../../lexical/ui/icons/InlineBlocks/index.js'\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { getBlockImageComponent } from './getBlockImageComponent.js'\nimport { BlockNode } from './nodes/BlocksNode.js'\nimport { InlineBlockNode } from './nodes/InlineBlocksNode.js'\nimport { INSERT_BLOCK_COMMAND, INSERT_INLINE_BLOCK_COMMAND } from './plugin/commands.js'\nimport { BlocksPlugin } from './plugin/index.js'\nexport const BlocksFeatureClient = createClientFeature(\n  ({ config, featureClientSchemaMap, props, schemaPath }) => {\n    const schemaMapRenderedBlockPathPrefix = `${schemaPath}.lexical_internal_feature.blocks.lexical_blocks`\n    const schemaMapRenderedInlineBlockPathPrefix = `${schemaPath}.lexical_internal_feature.blocks.lexical_inline_blocks`\n    const clientSchema = featureClientSchemaMap['blocks']\n\n    if (!clientSchema) {\n      return {}\n    }\n\n    const blocksFields: BlocksFieldClient[] = Object.entries(clientSchema)\n      .filter(\n        ([key]) =>\n          key.startsWith(schemaMapRenderedBlockPathPrefix + '.') &&\n          !key.replace(schemaMapRenderedBlockPathPrefix + '.', '').includes('.'),\n      )\n      .map(([, value]) => value[0] as BlocksFieldClient)\n\n    const inlineBlocksFields: BlocksFieldClient[] = Object.entries(clientSchema)\n      .filter(\n        ([key]) =>\n          key.startsWith(schemaMapRenderedInlineBlockPathPrefix + '.') &&\n          !key.replace(schemaMapRenderedInlineBlockPathPrefix + '.', '').includes('.'),\n      )\n      .map(([, value]) => value[0] as BlocksFieldClient)\n\n    const clientBlocks: ClientBlock[] = blocksFields\n      .map((field) => {\n        return field.blockReferences\n          ? typeof field.blockReferences[0] === 'string'\n            ? config.blocksMap[field.blockReferences[0]]\n            : field.blockReferences[0]\n          : field.blocks[0]\n      })\n      .filter((block) => block !== undefined)\n\n    const clientInlineBlocks: ClientBlock[] = inlineBlocksFields\n      .map((field) => {\n        return field.blockReferences\n          ? typeof field.blockReferences[0] === 'string'\n            ? config.blocksMap[field.blockReferences[0]]\n            : field.blockReferences[0]\n          : field.blocks[0]\n      })\n      .filter((block) => block !== undefined)\n\n    return {\n      nodes: [BlockNode, InlineBlockNode],\n      plugins: [\n        {\n          Component: BlocksPlugin,\n          position: 'normal',\n        },\n      ],\n      sanitizedClientFeatureProps: props,\n      slashMenu: {\n        groups: [\n          clientBlocks?.length\n            ? {\n                items: clientBlocks.map((block) => {\n                  return {\n                    Icon: getBlockImageComponent(block.imageURL, block.imageAltText),\n                    key: 'block-' + block.slug,\n                    keywords: ['block', 'blocks', block.slug],\n                    label: ({ i18n }) => {\n                      const blockDisplayName = block?.labels?.singular\n                        ? getTranslation(block.labels.singular, i18n)\n                        : block?.slug\n\n                      return blockDisplayName\n                    },\n                    onSelect: ({ editor }) => {\n                      editor.dispatchCommand(INSERT_BLOCK_COMMAND, {\n                        blockName: '',\n                        blockType: block.slug,\n                      })\n                    },\n                  } as SlashMenuItem\n                }),\n                key: 'blocks',\n                label: ({ i18n }: { i18n: I18nClient<object, 'lexical:blocks:label'> }) => {\n                  return i18n.t('lexical:blocks:label')\n                },\n              }\n            : null,\n          clientInlineBlocks?.length\n            ? {\n                items: clientInlineBlocks.map((inlineBlock) => {\n                  return {\n                    Icon: InlineBlocksIcon,\n                    key: 'inlineBlocks-' + inlineBlock.slug,\n                    keywords: ['inlineBlock', 'inline block', inlineBlock.slug],\n                    label: ({ i18n }) => {\n                      const blockDisplayName = inlineBlock?.labels?.singular\n                        ? getTranslation(inlineBlock.labels.singular, i18n)\n                        : inlineBlock?.slug\n\n                      return blockDisplayName\n                    },\n                    onSelect: ({ editor }) => {\n                      editor.dispatchCommand(INSERT_INLINE_BLOCK_COMMAND, {\n                        blockName: '',\n                        blockType: inlineBlock.slug,\n                      })\n                    },\n                  } as SlashMenuItem\n                }),\n                key: 'inlineBlocks',\n                label: ({\n                  i18n,\n                }: {\n                  i18n: I18nClient<object, 'lexical:blocks:inlineBlocks:label'>\n                }) => {\n                  return i18n.t('lexical:blocks:inlineBlocks:label')\n                },\n              }\n            : null,\n        ].filter(Boolean) as SlashMenuGroup[],\n      },\n      toolbarFixed: {\n        groups: [\n          clientBlocks.length\n            ? {\n                type: 'dropdown',\n                ChildComponent: BlockIcon,\n                items: clientBlocks.map((block, index) => {\n                  return {\n                    ChildComponent: getBlockImageComponent(block.imageURL, block.imageAltText),\n                    isActive: undefined, // At this point, we would be inside a sub-richtext-editor. And at this point this will be run against the focused sub-editor, not the parent editor which has the actual block. Thus, no point in running this\n                    key: 'block-' + block.slug,\n                    label: ({ i18n }) => {\n                      const blockDisplayName = block?.labels?.singular\n                        ? getTranslation(block.labels.singular, i18n)\n                        : block?.slug\n\n                      return blockDisplayName\n                    },\n                    onSelect: ({ editor }) => {\n                      editor.dispatchCommand(INSERT_BLOCK_COMMAND, {\n                        blockName: '',\n                        blockType: block.slug,\n                      })\n                    },\n                    order: index,\n                  } as ToolbarGroupItem\n                }),\n                key: 'blocks',\n                order: 20,\n              }\n            : null,\n          clientInlineBlocks?.length\n            ? {\n                type: 'dropdown',\n                ChildComponent: InlineBlocksIcon,\n                items: clientInlineBlocks.map((inlineBlock, index) => {\n                  return {\n                    ChildComponent: inlineBlock.imageURL\n                      ? getBlockImageComponent(inlineBlock.imageURL, inlineBlock.imageAltText)\n                      : InlineBlocksIcon,\n                    isActive: undefined,\n                    key: 'inlineBlock-' + inlineBlock.slug,\n                    label: ({ i18n }) => {\n                      const blockDisplayName = inlineBlock?.labels?.singular\n                        ? getTranslation(inlineBlock.labels.singular, i18n)\n                        : inlineBlock?.slug\n\n                      return blockDisplayName\n                    },\n                    onSelect: ({ editor }) => {\n                      editor.dispatchCommand(INSERT_INLINE_BLOCK_COMMAND, {\n                        blockName: '',\n                        blockType: inlineBlock.slug,\n                      })\n                    },\n                    order: index,\n                  } as ToolbarGroupItem\n                }),\n                key: 'inlineBlocks',\n                order: 25,\n              }\n            : null,\n        ].filter(Boolean) as ToolbarGroup[],\n      },\n    }\n  },\n)\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"index.js","names":["getTranslation","BlockIcon","InlineBlocksIcon","createClientFeature","getBlockImageComponent","getBlockMarkdownTransformers","BlockNode","InlineBlockNode","INSERT_BLOCK_COMMAND","INSERT_INLINE_BLOCK_COMMAND","BlocksPlugin","BlocksFeatureClient","config","featureClientSchemaMap","props","schemaPath","schemaMapRenderedBlockPathPrefix","schemaMapRenderedInlineBlockPathPrefix","clientSchema","blocksFields","Object","entries","filter","key","startsWith","replace","includes","map","value","inlineBlocksFields","clientBlocks","field","blockReferences","blocksMap","blocks","block","undefined","clientInlineBlocks","markdownTransformers","inlineBlocks","nodes","plugins","Component","position","sanitizedClientFeatureProps","slashMenu","groups","length","items","Icon","imageURL","imageAltText","slug","keywords","label","i18n","blockDisplayName","labels","singular","onSelect","editor","dispatchCommand","blockName","blockType","t","inlineBlock","Boolean","toolbarFixed","type","ChildComponent","index","isActive","order"],"sources":["../../../../src/features/blocks/client/index.tsx"],"sourcesContent":["'use client'\n\nimport type { I18nClient } from '@payloadcms/translations'\nimport type { BlocksFieldClient, ClientBlock } from 'payload'\n\nimport { getTranslation } from '@payloadcms/translations'\n\nimport type {\n  SlashMenuGroup,\n  SlashMenuItem,\n} from '../../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nimport type { ToolbarGroup, ToolbarGroupItem } from '../../toolbars/types.js'\n\nimport { BlockIcon } from '../../../lexical/ui/icons/Block/index.js'\nimport { InlineBlocksIcon } from '../../../lexical/ui/icons/InlineBlocks/index.js'\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { getBlockImageComponent } from './getBlockImageComponent.js'\nimport { getBlockMarkdownTransformers } from './markdown/markdownTransformer.js'\nimport { BlockNode } from './nodes/BlocksNode.js'\nimport { InlineBlockNode } from './nodes/InlineBlocksNode.js'\nimport { INSERT_BLOCK_COMMAND, INSERT_INLINE_BLOCK_COMMAND } from './plugin/commands.js'\nimport { BlocksPlugin } from './plugin/index.js'\nexport const BlocksFeatureClient = createClientFeature(\n  ({ config, featureClientSchemaMap, props, schemaPath }) => {\n    const schemaMapRenderedBlockPathPrefix = `${schemaPath}.lexical_internal_feature.blocks.lexical_blocks`\n    const schemaMapRenderedInlineBlockPathPrefix = `${schemaPath}.lexical_internal_feature.blocks.lexical_inline_blocks`\n    const clientSchema = featureClientSchemaMap['blocks']\n\n    if (!clientSchema) {\n      return {}\n    }\n\n    const blocksFields: BlocksFieldClient[] = Object.entries(clientSchema)\n      .filter(\n        ([key]) =>\n          key.startsWith(schemaMapRenderedBlockPathPrefix + '.') &&\n          !key.replace(schemaMapRenderedBlockPathPrefix + '.', '').includes('.'),\n      )\n      .map(([, value]) => value[0] as BlocksFieldClient)\n\n    const inlineBlocksFields: BlocksFieldClient[] = Object.entries(clientSchema)\n      .filter(\n        ([key]) =>\n          key.startsWith(schemaMapRenderedInlineBlockPathPrefix + '.') &&\n          !key.replace(schemaMapRenderedInlineBlockPathPrefix + '.', '').includes('.'),\n      )\n      .map(([, value]) => value[0] as BlocksFieldClient)\n\n    const clientBlocks: ClientBlock[] = blocksFields\n      .map((field) => {\n        return field.blockReferences\n          ? typeof field.blockReferences[0] === 'string'\n            ? config.blocksMap[field.blockReferences[0]]\n            : field.blockReferences[0]\n          : field.blocks[0]\n      })\n      .filter((block) => block !== undefined)\n\n    const clientInlineBlocks: ClientBlock[] = inlineBlocksFields\n      .map((field) => {\n        return field.blockReferences\n          ? typeof field.blockReferences[0] === 'string'\n            ? config.blocksMap[field.blockReferences[0]]\n            : field.blockReferences[0]\n          : field.blocks[0]\n      })\n      .filter((block) => block !== undefined)\n\n    return {\n      markdownTransformers: getBlockMarkdownTransformers({\n        blocks: clientBlocks,\n        inlineBlocks: clientInlineBlocks,\n      }),\n      nodes: [BlockNode, InlineBlockNode],\n      plugins: [\n        {\n          Component: BlocksPlugin,\n          position: 'normal',\n        },\n      ],\n      sanitizedClientFeatureProps: props,\n      slashMenu: {\n        groups: [\n          clientBlocks?.length\n            ? {\n                items: clientBlocks.map((block) => {\n                  return {\n                    Icon: getBlockImageComponent(block.imageURL, block.imageAltText),\n                    key: 'block-' + block.slug,\n                    keywords: ['block', 'blocks', block.slug],\n                    label: ({ i18n }) => {\n                      const blockDisplayName = block?.labels?.singular\n                        ? getTranslation(block.labels.singular, i18n)\n                        : block?.slug\n\n                      return blockDisplayName\n                    },\n                    onSelect: ({ editor }) => {\n                      editor.dispatchCommand(INSERT_BLOCK_COMMAND, {\n                        blockName: '',\n                        blockType: block.slug,\n                      })\n                    },\n                  } as SlashMenuItem\n                }),\n                key: 'blocks',\n                label: ({ i18n }: { i18n: I18nClient<object, 'lexical:blocks:label'> }) => {\n                  return i18n.t('lexical:blocks:label')\n                },\n              }\n            : null,\n          clientInlineBlocks?.length\n            ? {\n                items: clientInlineBlocks.map((inlineBlock) => {\n                  return {\n                    Icon: InlineBlocksIcon,\n                    key: 'inlineBlocks-' + inlineBlock.slug,\n                    keywords: ['inlineBlock', 'inline block', inlineBlock.slug],\n                    label: ({ i18n }) => {\n                      const blockDisplayName = inlineBlock?.labels?.singular\n                        ? getTranslation(inlineBlock.labels.singular, i18n)\n                        : inlineBlock?.slug\n\n                      return blockDisplayName\n                    },\n                    onSelect: ({ editor }) => {\n                      editor.dispatchCommand(INSERT_INLINE_BLOCK_COMMAND, {\n                        blockName: '',\n                        blockType: inlineBlock.slug,\n                      })\n                    },\n                  } as SlashMenuItem\n                }),\n                key: 'inlineBlocks',\n                label: ({\n                  i18n,\n                }: {\n                  i18n: I18nClient<object, 'lexical:blocks:inlineBlocks:label'>\n                }) => {\n                  return i18n.t('lexical:blocks:inlineBlocks:label')\n                },\n              }\n            : null,\n        ].filter(Boolean) as SlashMenuGroup[],\n      },\n      toolbarFixed: {\n        groups: [\n          clientBlocks.length\n            ? {\n                type: 'dropdown',\n                ChildComponent: BlockIcon,\n                items: clientBlocks.map((block, index) => {\n                  return {\n                    ChildComponent: getBlockImageComponent(block.imageURL, block.imageAltText),\n                    isActive: undefined, // At this point, we would be inside a sub-richtext-editor. And at this point this will be run against the focused sub-editor, not the parent editor which has the actual block. Thus, no point in running this\n                    key: 'block-' + block.slug,\n                    label: ({ i18n }) => {\n                      const blockDisplayName = block?.labels?.singular\n                        ? getTranslation(block.labels.singular, i18n)\n                        : block?.slug\n\n                      return blockDisplayName\n                    },\n                    onSelect: ({ editor }) => {\n                      editor.dispatchCommand(INSERT_BLOCK_COMMAND, {\n                        blockName: '',\n                        blockType: block.slug,\n                      })\n                    },\n                    order: index,\n                  } as ToolbarGroupItem\n                }),\n                key: 'blocks',\n                order: 20,\n              }\n            : null,\n          clientInlineBlocks?.length\n            ? {\n                type: 'dropdown',\n                ChildComponent: InlineBlocksIcon,\n                items: clientInlineBlocks.map((inlineBlock, index) => {\n                  return {\n                    ChildComponent: inlineBlock.imageURL\n                      ? getBlockImageComponent(inlineBlock.imageURL, inlineBlock.imageAltText)\n                      : InlineBlocksIcon,\n                    isActive: undefined,\n                    key: 'inlineBlock-' + inlineBlock.slug,\n                    label: ({ i18n }) => {\n                      const blockDisplayName = inlineBlock?.labels?.singular\n                        ? getTranslation(inlineBlock.labels.singular, i18n)\n                        : inlineBlock?.slug\n\n                      return blockDisplayName\n                    },\n                    onSelect: ({ editor }) => {\n                      editor.dispatchCommand(INSERT_INLINE_BLOCK_COMMAND, {\n                        blockName: '',\n                        blockType: inlineBlock.slug,\n                      })\n                    },\n                    order: index,\n                  } as ToolbarGroupItem\n                }),\n                key: 'inlineBlocks',\n                order: 25,\n              }\n            : null,\n        ].filter(Boolean) as ToolbarGroup[],\n      },\n    }\n  },\n)\n"],"mappings":"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","ignoreList":[]}

package/dist/features/blocks/client/markdown/getLexicalToMarkdown.d.ts

@@ -0,0 +1,6 @@
+import type { Klass, LexicalNode, LexicalNodeReplacement } from 'lexical';
+import { type Transformer } from '../../../../packages/@lexical/markdown/index.js';
+export declare function getLexicalToMarkdown(allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>, allTransformers: Transformer[]): (args: {
+    editorState: Record<string, any>;
+}) => string;
+//# sourceMappingURL=getLexicalToMarkdown.d.ts.map

package/dist/features/blocks/client/markdown/getLexicalToMarkdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLexicalToMarkdown.d.ts","sourceRoot":"","sources":["../../../../../src/features/blocks/client/markdown/getLexicalToMarkdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAIzE,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,iDAAiD,CAAA;AAExD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,EAC5D,eAAe,EAAE,WAAW,EAAE,GAC7B,CAAC,IAAI,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,KAAK,MAAM,CAoBxD"}

package/dist/features/blocks/client/markdown/getLexicalToMarkdown.js

@@ -0,0 +1,24 @@
+import { createHeadlessEditor } from '@lexical/headless';
+import { $convertToMarkdownString } from '../../../../packages/@lexical/markdown/index.js';
+export function getLexicalToMarkdown(allNodes, allTransformers) {
+  const lexicalToMarkdown = ({
+    editorState
+  }) => {
+    const headlessEditor = createHeadlessEditor({
+      nodes: allNodes
+    });
+    try {
+      headlessEditor.setEditorState(headlessEditor.parseEditorState(editorState)) // This should commit the editor state immediately
+      ;
+    } catch (e) {
+      console.error('getLexicalToMarkdown: ERROR parsing editor state', e);
+    }
+    let markdown = '';
+    headlessEditor.getEditorState().read(() => {
+      markdown = $convertToMarkdownString(allTransformers);
+    });
+    return markdown;
+  };
+  return lexicalToMarkdown;
+}
+//# sourceMappingURL=getLexicalToMarkdown.js.map

package/dist/features/blocks/client/markdown/getLexicalToMarkdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLexicalToMarkdown.js","names":["createHeadlessEditor","$convertToMarkdownString","getLexicalToMarkdown","allNodes","allTransformers","lexicalToMarkdown","editorState","headlessEditor","nodes","setEditorState","parseEditorState","e","console","error","markdown","getEditorState","read"],"sources":["../../../../../src/features/blocks/client/markdown/getLexicalToMarkdown.ts"],"sourcesContent":["import type { Klass, LexicalNode, LexicalNodeReplacement } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport {\n  $convertToMarkdownString,\n  type Transformer,\n} from '../../../../packages/@lexical/markdown/index.js'\n\nexport function getLexicalToMarkdown(\n  allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>,\n  allTransformers: Transformer[],\n): (args: { editorState: Record<string, any> }) => string {\n  const lexicalToMarkdown = ({ editorState }: { editorState: Record<string, any> }): string => {\n    const headlessEditor = createHeadlessEditor({\n      nodes: allNodes,\n    })\n\n    try {\n      headlessEditor.setEditorState(headlessEditor.parseEditorState(editorState as any)) // This should commit the editor state immediately\n    } catch (e) {\n      console.error('getLexicalToMarkdown: ERROR parsing editor state', e)\n    }\n\n    let markdown: string = ''\n    headlessEditor.getEditorState().read(() => {\n      markdown = $convertToMarkdownString(allTransformers)\n    })\n\n    return markdown\n  }\n  return lexicalToMarkdown\n}\n"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ;AAErC,SACEC,wBAAwB,QAEnB;AAEP,OAAO,SAASC,qBACdC,QAA4D,EAC5DC,eAA8B;EAE9B,MAAMC,iBAAA,GAAoBA,CAAC;IAAEC;EAAW,CAAwC;IAC9E,MAAMC,cAAA,GAAiBP,oBAAA,CAAqB;MAC1CQ,KAAA,EAAOL;IACT;IAEA,IAAI;MACFI,cAAA,CAAeE,cAAc,CAACF,cAAA,CAAeG,gBAAgB,CAACJ,WAAA,GAAqB;MAAA;IACrF,EAAE,OAAOK,CAAA,EAAG;MACVC,OAAA,CAAQC,KAAK,CAAC,oDAAoDF,CAAA;IACpE;IAEA,IAAIG,QAAA,GAAmB;IACvBP,cAAA,CAAeQ,cAAc,GAAGC,IAAI,CAAC;MACnCF,QAAA,GAAWb,wBAAA,CAAyBG,eAAA;IACtC;IAEA,OAAOU,QAAA;EACT;EACA,OAAOT,iBAAA;AACT","ignoreList":[]}

package/dist/features/blocks/client/markdown/getMarkdownToLexical.d.ts

@@ -0,0 +1,6 @@
+import type { Klass, LexicalNode, LexicalNodeReplacement, SerializedEditorState } from 'lexical';
+import { type Transformer } from '../../../../packages/@lexical/markdown/index.js';
+export declare function getMarkdownToLexical(allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>, allTransformers: Transformer[]): (args: {
+    markdown: string;
+}) => SerializedEditorState;
+//# sourceMappingURL=getMarkdownToLexical.d.ts.map

package/dist/features/blocks/client/markdown/getMarkdownToLexical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMarkdownToLexical.d.ts","sourceRoot":"","sources":["../../../../../src/features/blocks/client/markdown/getMarkdownToLexical.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAIhG,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,iDAAiD,CAAA;AAExD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,EAC5D,eAAe,EAAE,WAAW,EAAE,GAC7B,CAAC,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,KAAK,qBAAqB,CAkBvD"}

package/dist/features/blocks/client/markdown/getMarkdownToLexical.js

@@ -0,0 +1,20 @@
+import { createHeadlessEditor } from '@lexical/headless';
+import { $convertFromMarkdownString } from '../../../../packages/@lexical/markdown/index.js';
+export function getMarkdownToLexical(allNodes, allTransformers) {
+  const markdownToLexical = ({
+    markdown
+  }) => {
+    const headlessEditor = createHeadlessEditor({
+      nodes: allNodes
+    });
+    headlessEditor.update(() => {
+      $convertFromMarkdownString(markdown, allTransformers);
+    }, {
+      discrete: true
+    });
+    const editorJSON = headlessEditor.getEditorState().toJSON();
+    return editorJSON;
+  };
+  return markdownToLexical;
+}
+//# sourceMappingURL=getMarkdownToLexical.js.map

package/dist/features/blocks/client/markdown/getMarkdownToLexical.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMarkdownToLexical.js","names":["createHeadlessEditor","$convertFromMarkdownString","getMarkdownToLexical","allNodes","allTransformers","markdownToLexical","markdown","headlessEditor","nodes","update","discrete","editorJSON","getEditorState","toJSON"],"sources":["../../../../../src/features/blocks/client/markdown/getMarkdownToLexical.ts"],"sourcesContent":["import type { Klass, LexicalNode, LexicalNodeReplacement, SerializedEditorState } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport {\n  $convertFromMarkdownString,\n  type Transformer,\n} from '../../../../packages/@lexical/markdown/index.js'\n\nexport function getMarkdownToLexical(\n  allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>,\n  allTransformers: Transformer[],\n): (args: { markdown: string }) => SerializedEditorState {\n  const markdownToLexical = ({ markdown }: { markdown: string }): SerializedEditorState => {\n    const headlessEditor = createHeadlessEditor({\n      nodes: allNodes,\n    })\n\n    headlessEditor.update(\n      () => {\n        $convertFromMarkdownString(markdown, allTransformers)\n      },\n      { discrete: true },\n    )\n\n    const editorJSON = headlessEditor.getEditorState().toJSON()\n\n    return editorJSON\n  }\n  return markdownToLexical\n}\n"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ;AAErC,SACEC,0BAA0B,QAErB;AAEP,OAAO,SAASC,qBACdC,QAA4D,EAC5DC,eAA8B;EAE9B,MAAMC,iBAAA,GAAoBA,CAAC;IAAEC;EAAQ,CAAwB;IAC3D,MAAMC,cAAA,GAAiBP,oBAAA,CAAqB;MAC1CQ,KAAA,EAAOL;IACT;IAEAI,cAAA,CAAeE,MAAM,CACnB;MACER,0BAAA,CAA2BK,QAAA,EAAUF,eAAA;IACvC,GACA;MAAEM,QAAA,EAAU;IAAK;IAGnB,MAAMC,UAAA,GAAaJ,cAAA,CAAeK,cAAc,GAAGC,MAAM;IAEzD,OAAOF,UAAA;EACT;EACA,OAAON,iBAAA;AACT","ignoreList":[]}

package/dist/features/blocks/client/markdown/markdownTransformer.d.ts

@@ -0,0 +1,12 @@
+import type { ClientBlock } from 'payload';
+import { type Klass, type LexicalNode, type LexicalNodeReplacement } from 'lexical';
+import type { Transformer } from '../../../../packages/@lexical/markdown/index.js';
+import type { MultilineElementTransformer, TextMatchTransformer } from '../../../../packages/@lexical/markdown/MarkdownTransformers.js';
+export declare const getBlockMarkdownTransformers: ({ blocks, inlineBlocks, }: {
+    blocks: ClientBlock[];
+    inlineBlocks: ClientBlock[];
+}) => ((props: {
+    allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>;
+    allTransformers: Transformer[];
+}) => MultilineElementTransformer | TextMatchTransformer)[];
+//# sourceMappingURL=markdownTransformer.d.ts.map

package/dist/features/blocks/client/markdown/markdownTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../../src/features/blocks/client/markdown/markdownTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,OAAO,EAGL,KAAK,KAAK,EACV,KAAK,WAAW,EAChB,KAAK,sBAAsB,EAE5B,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iDAAiD,CAAA;AAClF,OAAO,KAAK,EACV,2BAA2B,EAC3B,oBAAoB,EACrB,MAAM,gEAAgE,CAAA;AAqBvE,eAAO,MAAM,4BAA4B,8BAGtC;IACD,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,YAAY,EAAE,WAAW,EAAE,CAAA;CAC5B,KAAG,CAAC,CAAC,KAAK,EAAE;IACX,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,CAAA;IAC5D,eAAe,EAAE,WAAW,EAAE,CAAA;CAC/B,KAAK,2BAA2B,GAAG,oBAAoB,CAAC,EA8BxD,CAAA"}

package/dist/features/blocks/client/markdown/markdownTransformer.js

@@ -0,0 +1,348 @@
+import { $parseSerializedNode } from 'lexical';
+import { extractPropsFromJSXPropsString } from '../../../../utilities/jsx/extractPropsFromJSXPropsString.js';
+import { propsToJSXString } from '../../../../utilities/jsx/jsx.js';
+import { linesFromStartToContentAndPropsString } from '../../server/markdown/linesFromMatchToContentAndPropsString.js';
+import { $createBlockNode, $isBlockNode, BlockNode } from '../nodes/BlocksNode.js';
+import { $createInlineBlockNode, $isInlineBlockNode, InlineBlockNode } from '../nodes/InlineBlocksNode.js';
+import { getLexicalToMarkdown } from './getLexicalToMarkdown.js';
+import { getMarkdownToLexical } from './getMarkdownToLexical.js';
+function createTagRegexes(tagName) {
+  const escapedTagName = tagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return {
+    regExpEnd: new RegExp(`</(${escapedTagName})\\s*>|<${escapedTagName}[^>]*?/>`, 'i'),
+    regExpStart: new RegExp(`<(${escapedTagName})([^>]*?)\\s*(/?)>`, 'i')
+  };
+}
+export const getBlockMarkdownTransformers = ({
+  blocks,
+  inlineBlocks
+}) => {
+  if (!blocks?.length && !inlineBlocks?.length) {
+    return [];
+  }
+  let transformers = [];
+  if (blocks?.length) {
+    for (const block of blocks) {
+      const transformer = getMarkdownTransformerForBlock(block, false);
+      if (transformer) {
+        transformers = transformers.concat(transformer);
+      }
+    }
+  }
+  if (inlineBlocks?.length) {
+    for (const block of inlineBlocks) {
+      const transformer = getMarkdownTransformerForBlock(block, true);
+      if (transformer) {
+        transformers = transformers.concat(transformer);
+      }
+    }
+  }
+  return transformers;
+};
+function getMarkdownTransformerForBlock(block, isInlineBlock) {
+  if (!block.jsx) {
+    return null;
+  }
+  const regex = createTagRegexes(block.slug);
+  const toReturn = [];
+  if (isInlineBlock) {
+    toReturn.push(({
+      allNodes,
+      allTransformers
+    }) => ({
+      type: 'text-match',
+      dependencies: [InlineBlockNode],
+      export: node => {
+        if (!$isInlineBlockNode(node)) {
+          return null;
+        }
+        if (node.getFields()?.blockType?.toLowerCase() !== block.slug.toLowerCase()) {
+          return null;
+        }
+        const nodeFields = node.getFields();
+        const lexicalToMarkdown = getLexicalToMarkdown(allNodes, allTransformers);
+        const exportResult = block.jsx.export({
+          fields: nodeFields,
+          lexicalToMarkdown
+        });
+        if (exportResult === false) {
+          return null;
+        }
+        if (typeof exportResult === 'string') {
+          return exportResult;
+        }
+        const hasProps = exportResult.props && Object.keys(exportResult.props)?.length > 0;
+        const props = exportResult.props ?? {};
+        if (exportResult?.children?.length) {
+          return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({
+            props
+          }) : ''}>${exportResult.children}</${nodeFields.blockType}>`;
+        }
+        return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({
+          props
+        }) : ''}/>`;
+      },
+      getEndIndex: (node, match) => {
+        const {
+          endlineLastCharIndex
+        } = linesFromStartToContentAndPropsString({
+          isEndOptional: false,
+          lines: [node.getTextContent()],
+          regexpEndRegex: regex.regExpEnd,
+          startLineIndex: 0,
+          startMatch: match,
+          trimChildren: false
+        });
+        return endlineLastCharIndex;
+      },
+      importRegExp: block.jsx?.customStartRegex ?? regex.regExpStart,
+      regExp: /___ignoreignoreignore___/g,
+      replace(node, match) {
+        const {
+          content,
+          propsString
+        } = linesFromStartToContentAndPropsString({
+          isEndOptional: false,
+          lines: [node.getTextContent()],
+          regexpEndRegex: regex.regExpEnd,
+          startLineIndex: 0,
+          startMatch: {
+            ...match,
+            index: 0
+          },
+          trimChildren: false
+        });
+        if (!block?.jsx?.import) {
+          // No multiline transformer handled this line successfully
+          return;
+        }
+        const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers);
+        const blockFields = block.jsx.import({
+          children: content,
+          closeMatch: null,
+          htmlToLexical: null,
+          markdownToLexical,
+          openMatch: match,
+          props: propsString ? extractPropsFromJSXPropsString({
+            propsString
+          }) : {}
+        });
+        if (blockFields === false) {
+          return;
+        }
+        const inlineBlockNode = $createInlineBlockNode({
+          blockType: block.slug,
+          ...blockFields
+        });
+        node.replace(inlineBlockNode);
+      }
+    }));
+    return toReturn;
+  }
+  toReturn.push(({
+    allNodes,
+    allTransformers
+  }) => ({
+    dependencies: [BlockNode],
+    export: node => {
+      if (!$isBlockNode(node)) {
+        return null;
+      }
+      if (node.getFields()?.blockType?.toLowerCase() !== block.slug.toLowerCase()) {
+        return null;
+      }
+      const nodeFields = node.getFields();
+      const lexicalToMarkdown = getLexicalToMarkdown(allNodes, allTransformers);
+      const exportResult = block.jsx.export({
+        fields: nodeFields,
+        lexicalToMarkdown
+      });
+      if (exportResult === false) {
+        return null;
+      }
+      if (typeof exportResult === 'string') {
+        return exportResult;
+      }
+      const hasProps = exportResult.props && Object.keys(exportResult.props)?.length > 0;
+      const props = exportResult.props ?? {};
+      if (exportResult?.children?.length) {
+        const children = exportResult.children;
+        let sanitizedChildren = '';
+        // Ensure it has a leftpad of at least 2 spaces. The data is saved without those spaces, so we can just blindly add it to every child
+        if (children.includes('\n')) {
+          for (const child of children.split('\n')) {
+            let sanitizedChild = '';
+            if (!block?.jsx?.doNotTrimChildren && child !== '') {
+              sanitizedChild = '  ';
+            }
+            sanitizedChild += child + '\n';
+            sanitizedChildren += sanitizedChild;
+          }
+        } else {
+          sanitizedChildren = (block?.jsx?.doNotTrimChildren ? '' : '  ') + children + '\n';
+        }
+        return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({
+          props
+        }) : ''}>\n${sanitizedChildren}</${nodeFields.blockType}>`;
+      }
+      return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({
+        props
+      }) : ''}/>`;
+    },
+    handleImportAfterStartMatch: block.jsx?.customEndRegex ? undefined : ({
+      lines,
+      rootNode,
+      startLineIndex,
+      startMatch,
+      transformer
+    }) => {
+      const regexpEndRegex = typeof transformer.regExpEnd === 'object' && 'regExp' in transformer.regExpEnd ? transformer.regExpEnd.regExp : transformer.regExpEnd;
+      const isEndOptional = transformer.regExpEnd && typeof transformer.regExpEnd === 'object' && 'optional' in transformer.regExpEnd ? transformer.regExpEnd.optional : !transformer.regExpEnd;
+      const {
+        afterEndLine,
+        beforeStartLine,
+        content: unsanitizedContent,
+        endLineIndex,
+        propsString
+      } = linesFromStartToContentAndPropsString({
+        isEndOptional,
+        lines,
+        regexpEndRegex,
+        startLineIndex,
+        startMatch,
+        trimChildren: false
+      });
+      let content = '';
+      if (block?.jsx?.doNotTrimChildren) {
+        content = unsanitizedContent.endsWith('\n') ? unsanitizedContent.slice(0, -1) : unsanitizedContent;
+      } else {
+        // Ensure it has a leftpad of at least 2 spaces. The data is saved without those spaces, so we can just blindly add it to every child
+        if (unsanitizedContent.includes('\n')) {
+          const split = unsanitizedContent.split('\n');
+          let index = 0;
+          for (const child of split) {
+            index++;
+            if (child.startsWith('  ')) {
+              content += child.slice(2);
+            } else {
+              // If one child is misaligned, skip aligning completely, unless it's just empty
+              if (child === '') {
+                content += child;
+              } else {
+                content = unsanitizedContent.endsWith('\n') ? unsanitizedContent.slice(0, -1) : unsanitizedContent;
+                break;
+              }
+            }
+            content += index === split.length ? '' : '\n';
+          }
+        } else {
+          content = (!unsanitizedContent.startsWith('  ') ? unsanitizedContent : unsanitizedContent.slice(2)) + '\n';
+        }
+      }
+      if (!block?.jsx?.import) {
+        // No multiline transformer handled this line successfully
+        return [false, startLineIndex];
+      }
+      const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers);
+      const blockFields = block.jsx.import({
+        children: content,
+        closeMatch: null,
+        htmlToLexical: null,
+        markdownToLexical,
+        openMatch: startMatch,
+        props: propsString ? extractPropsFromJSXPropsString({
+          propsString
+        }) : {}
+      });
+      if (blockFields === false) {
+        return [false, startLineIndex];
+      }
+      const node = $createBlockNode({
+        blockType: block.slug,
+        ...blockFields
+      });
+      if (node) {
+        // Now handle beforeStartLine and afterEndLine. If those are not empty, we need to add them as text nodes before and after the block node.
+        // However, those themselves can contain other markdown matches, so we need to parse them as well.
+        // Example where this is needed: "Hello <InlineCode>inline code</InlineCode> test."
+        let prevNodes = null;
+        let nextNodes = null;
+        // TODO: Might not need this prevNodes and nextNodes handling if inline nodes are handled by textmatch transformers
+        if (beforeStartLine?.length) {
+          prevNodes = markdownToLexical({
+            markdown: beforeStartLine
+          })?.root?.children ?? [];
+          const firstPrevNode = prevNodes?.[0];
+          if (firstPrevNode) {
+            rootNode.append($parseSerializedNode(firstPrevNode));
+          }
+        }
+        rootNode.append(node);
+        if (afterEndLine?.length) {
+          nextNodes = markdownToLexical({
+            markdown: afterEndLine
+          })?.root?.children;
+          const lastChild = rootNode.getChildren()[rootNode.getChildren().length - 1];
+          const children = $parseSerializedNode(nextNodes[0])?.getChildren();
+          if (children?.length) {
+            for (const child of children) {
+              lastChild.append(child);
+            }
+          }
+        }
+      }
+      return [true, endLineIndex];
+    },
+    regExpEnd: block.jsx?.customEndRegex ?? regex.regExpEnd,
+    regExpStart: block.jsx?.customStartRegex ?? regex.regExpStart,
+    // This replace is ONLY run for ``` code blocks (so any blocks with custom start and end regexes). For others, we use the special JSX handling above:
+    type: 'multiline-element',
+    replace: (rootNode, children, openMatch, closeMatch, linesInBetween) => {
+      if (block?.jsx?.import) {
+        if (!linesInBetween) {
+          // convert children to linesInBetween
+          let line = '';
+          if (children) {
+            for (const child of children) {
+              line += child.getTextContent();
+            }
+          }
+          linesInBetween = [line];
+        }
+        let childrenString = '';
+        if (block?.jsx?.doNotTrimChildren) {
+          childrenString = linesInBetween.join('\n');
+        } else {
+          childrenString = linesInBetween.join('\n').trim();
+        }
+        const propsString = openMatch[1]?.trim();
+        const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers);
+        const blockFields = block.jsx.import({
+          children: childrenString,
+          closeMatch: closeMatch,
+          htmlToLexical: null,
+          markdownToLexical,
+          openMatch: openMatch,
+          props: propsString ? extractPropsFromJSXPropsString({
+            propsString
+          }) : {}
+        });
+        if (blockFields === false) {
+          return false;
+        }
+        const node = $createBlockNode({
+          blockType: block.slug,
+          ...blockFields
+        });
+        if (node) {
+          rootNode.append(node);
+        }
+        return;
+      }
+      return false // Run next transformer
+      ;
+    }
+  }));
+  return toReturn;
+}
+//# sourceMappingURL=markdownTransformer.js.map

package/dist/features/blocks/client/markdown/markdownTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.js","names":["$parseSerializedNode","extractPropsFromJSXPropsString","propsToJSXString","linesFromStartToContentAndPropsString","$createBlockNode","$isBlockNode","BlockNode","$createInlineBlockNode","$isInlineBlockNode","InlineBlockNode","getLexicalToMarkdown","getMarkdownToLexical","createTagRegexes","tagName","escapedTagName","replace","regExpEnd","RegExp","regExpStart","getBlockMarkdownTransformers","blocks","inlineBlocks","length","transformers","block","transformer","getMarkdownTransformerForBlock","concat","isInlineBlock","jsx","regex","slug","toReturn","push","allNodes","allTransformers","type","dependencies","export","node","getFields","blockType","toLowerCase","nodeFields","lexicalToMarkdown","exportResult","fields","hasProps","props","Object","keys","children","getEndIndex","match","endlineLastCharIndex","isEndOptional","lines","getTextContent","regexpEndRegex","startLineIndex","startMatch","trimChildren","importRegExp","customStartRegex","regExp","content","propsString","index","import","markdownToLexical","blockFields","closeMatch","htmlToLexical","openMatch","inlineBlockNode","sanitizedChildren","includes","child","split","sanitizedChild","doNotTrimChildren","handleImportAfterStartMatch","customEndRegex","undefined","rootNode","optional","afterEndLine","beforeStartLine","unsanitizedContent","endLineIndex","endsWith","slice","startsWith","prevNodes","nextNodes","markdown","root","firstPrevNode","append","lastChild","getChildren","linesInBetween","line","childrenString","join","trim"],"sources":["../../../../../src/features/blocks/client/markdown/markdownTransformer.ts"],"sourcesContent":["import type { ClientBlock } from 'payload'\n\nimport {\n  $parseSerializedNode,\n  type ElementNode,\n  type Klass,\n  type LexicalNode,\n  type LexicalNodeReplacement,\n  type SerializedLexicalNode,\n} from 'lexical'\n\nimport type { Transformer } from '../../../../packages/@lexical/markdown/index.js'\nimport type {\n  MultilineElementTransformer,\n  TextMatchTransformer,\n} from '../../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nimport { extractPropsFromJSXPropsString } from '../../../../utilities/jsx/extractPropsFromJSXPropsString.js'\nimport { propsToJSXString } from '../../../../utilities/jsx/jsx.js'\nimport { linesFromStartToContentAndPropsString } from '../../server/markdown/linesFromMatchToContentAndPropsString.js'\nimport { $createBlockNode, $isBlockNode, BlockNode } from '../nodes/BlocksNode.js'\nimport {\n  $createInlineBlockNode,\n  $isInlineBlockNode,\n  InlineBlockNode,\n} from '../nodes/InlineBlocksNode.js'\nimport { getLexicalToMarkdown } from './getLexicalToMarkdown.js'\nimport { getMarkdownToLexical } from './getMarkdownToLexical.js'\n\nfunction createTagRegexes(tagName: string) {\n  const escapedTagName = tagName.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n  return {\n    regExpEnd: new RegExp(`</(${escapedTagName})\\\\s*>|<${escapedTagName}[^>]*?/>`, 'i'),\n    regExpStart: new RegExp(`<(${escapedTagName})([^>]*?)\\\\s*(/?)>`, 'i'),\n  }\n}\nexport const getBlockMarkdownTransformers = ({\n  blocks,\n  inlineBlocks,\n}: {\n  blocks: ClientBlock[]\n  inlineBlocks: ClientBlock[]\n}): ((props: {\n  allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n  allTransformers: Transformer[]\n}) => MultilineElementTransformer | TextMatchTransformer)[] => {\n  if (!blocks?.length && !inlineBlocks?.length) {\n    return []\n  }\n  let transformers: ((props: {\n    allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n    allTransformers: Transformer[]\n  }) => MultilineElementTransformer | TextMatchTransformer)[] = []\n\n  if (blocks?.length) {\n    for (const block of blocks) {\n      const transformer = getMarkdownTransformerForBlock(block, false)\n\n      if (transformer) {\n        transformers = transformers.concat(transformer)\n      }\n    }\n  }\n\n  if (inlineBlocks?.length) {\n    for (const block of inlineBlocks) {\n      const transformer = getMarkdownTransformerForBlock(block, true)\n\n      if (transformer) {\n        transformers = transformers.concat(transformer)\n      }\n    }\n  }\n\n  return transformers\n}\n\nfunction getMarkdownTransformerForBlock(\n  block: ClientBlock,\n  isInlineBlock: boolean,\n): Array<\n  (props: {\n    allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n    allTransformers: Transformer[]\n  }) => MultilineElementTransformer | TextMatchTransformer\n> | null {\n  if (!block.jsx) {\n    return null\n  }\n  const regex = createTagRegexes(block.slug)\n  const toReturn: Array<\n    (props: {\n      allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n      allTransformers: Transformer[]\n    }) => MultilineElementTransformer | TextMatchTransformer\n  > = []\n\n  if (isInlineBlock) {\n    toReturn.push(({ allNodes, allTransformers }) => ({\n      type: 'text-match',\n      dependencies: [InlineBlockNode],\n      export: (node) => {\n        if (!$isInlineBlockNode(node)) {\n          return null\n        }\n\n        if (node.getFields()?.blockType?.toLowerCase() !== block.slug.toLowerCase()) {\n          return null\n        }\n\n        const nodeFields = node.getFields()\n        const lexicalToMarkdown = getLexicalToMarkdown(allNodes, allTransformers)\n\n        const exportResult = block.jsx!.export({\n          fields: nodeFields,\n          lexicalToMarkdown,\n        })\n        if (exportResult === false) {\n          return null\n        }\n        if (typeof exportResult === 'string') {\n          return exportResult\n        }\n\n        const hasProps = exportResult.props && Object.keys(exportResult.props)?.length > 0\n        const props = exportResult.props ?? {}\n\n        if (exportResult?.children?.length) {\n          return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({ props }) : ''}>${exportResult.children}</${nodeFields.blockType}>`\n        }\n\n        return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({ props }) : ''}/>`\n      },\n      getEndIndex: (node, match) => {\n        const { endlineLastCharIndex } = linesFromStartToContentAndPropsString({\n          isEndOptional: false,\n          lines: [node.getTextContent()],\n          regexpEndRegex: regex.regExpEnd,\n          startLineIndex: 0,\n          startMatch: match,\n          trimChildren: false,\n        })\n\n        return endlineLastCharIndex\n      },\n      importRegExp: block.jsx?.customStartRegex ?? regex.regExpStart,\n      regExp: /___ignoreignoreignore___/g,\n      replace(node, match) {\n        const { content, propsString } = linesFromStartToContentAndPropsString({\n          isEndOptional: false,\n          lines: [node.getTextContent()],\n          regexpEndRegex: regex.regExpEnd,\n          startLineIndex: 0,\n          startMatch: {\n            ...match,\n            index: 0,\n          },\n          trimChildren: false,\n        })\n\n        if (!block?.jsx?.import) {\n          // No multiline transformer handled this line successfully\n          return\n        }\n\n        const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers)\n\n        const blockFields = block.jsx.import({\n          children: content,\n          closeMatch: null,\n          htmlToLexical: null, // TODO\n          markdownToLexical,\n          openMatch: match,\n          props: propsString\n            ? extractPropsFromJSXPropsString({\n                propsString,\n              })\n            : {},\n        })\n        if (blockFields === false) {\n          return\n        }\n\n        const inlineBlockNode = $createInlineBlockNode({\n          blockType: block.slug,\n          ...(blockFields as any),\n        })\n\n        node.replace(inlineBlockNode)\n      },\n    }))\n\n    return toReturn\n  }\n\n  toReturn.push(({ allNodes, allTransformers }) => ({\n    dependencies: [BlockNode],\n    export: (node) => {\n      if (!$isBlockNode(node)) {\n        return null\n      }\n\n      if (node.getFields()?.blockType?.toLowerCase() !== block.slug.toLowerCase()) {\n        return null\n      }\n\n      const nodeFields = node.getFields()\n      const lexicalToMarkdown = getLexicalToMarkdown(allNodes, allTransformers)\n\n      const exportResult = block.jsx!.export({\n        fields: nodeFields,\n        lexicalToMarkdown,\n      })\n      if (exportResult === false) {\n        return null\n      }\n      if (typeof exportResult === 'string') {\n        return exportResult\n      }\n\n      const hasProps = exportResult.props && Object.keys(exportResult.props)?.length > 0\n      const props = exportResult.props ?? {}\n\n      if (exportResult?.children?.length) {\n        const children = exportResult.children\n        let sanitizedChildren = ''\n\n        // Ensure it has a leftpad of at least 2 spaces. The data is saved without those spaces, so we can just blindly add it to every child\n        if (children.includes('\\n')) {\n          for (const child of children.split('\\n')) {\n            let sanitizedChild = ''\n            if (!block?.jsx?.doNotTrimChildren && child !== '') {\n              sanitizedChild = '  '\n            }\n            sanitizedChild += child + '\\n'\n\n            sanitizedChildren += sanitizedChild\n          }\n        } else {\n          sanitizedChildren = (block?.jsx?.doNotTrimChildren ? '' : '  ') + children + '\\n'\n        }\n\n        return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({ props }) : ''}>\\n${sanitizedChildren}</${nodeFields.blockType}>`\n      }\n\n      return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({ props }) : ''}/>`\n    },\n    handleImportAfterStartMatch: block.jsx?.customEndRegex\n      ? undefined\n      : ({ lines, rootNode, startLineIndex, startMatch, transformer }) => {\n          const regexpEndRegex: RegExp | undefined =\n            typeof transformer.regExpEnd === 'object' && 'regExp' in transformer.regExpEnd\n              ? transformer.regExpEnd.regExp\n              : transformer.regExpEnd\n\n          const isEndOptional =\n            transformer.regExpEnd &&\n            typeof transformer.regExpEnd === 'object' &&\n            'optional' in transformer.regExpEnd\n              ? transformer.regExpEnd.optional\n              : !transformer.regExpEnd\n\n          const {\n            afterEndLine,\n            beforeStartLine,\n            content: unsanitizedContent,\n            endLineIndex,\n            propsString,\n          } = linesFromStartToContentAndPropsString({\n            isEndOptional,\n            lines,\n            regexpEndRegex,\n            startLineIndex,\n            startMatch,\n            trimChildren: false,\n          })\n\n          let content = ''\n\n          if (block?.jsx?.doNotTrimChildren) {\n            content = unsanitizedContent.endsWith('\\n')\n              ? unsanitizedContent.slice(0, -1)\n              : unsanitizedContent\n          } else {\n            // Ensure it has a leftpad of at least 2 spaces. The data is saved without those spaces, so we can just blindly add it to every child\n            if (unsanitizedContent.includes('\\n')) {\n              const split = unsanitizedContent.split('\\n')\n              let index = 0\n              for (const child of split) {\n                index++\n\n                if (child.startsWith('  ')) {\n                  content += child.slice(2)\n                } else {\n                  // If one child is misaligned, skip aligning completely, unless it's just empty\n                  if (child === '') {\n                    content += child\n                  } else {\n                    content = unsanitizedContent.endsWith('\\n')\n                      ? unsanitizedContent.slice(0, -1)\n                      : unsanitizedContent\n                    break\n                  }\n                }\n\n                content += index === split.length ? '' : '\\n'\n              }\n            } else {\n              content =\n                (!unsanitizedContent.startsWith('  ')\n                  ? unsanitizedContent\n                  : unsanitizedContent.slice(2)) + '\\n'\n            }\n          }\n\n          if (!block?.jsx?.import) {\n            // No multiline transformer handled this line successfully\n            return [false, startLineIndex]\n          }\n\n          const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers)\n\n          const blockFields = block.jsx.import({\n            children: content,\n            closeMatch: null,\n            htmlToLexical: null, // TODO\n            markdownToLexical,\n            openMatch: startMatch,\n            props: propsString\n              ? extractPropsFromJSXPropsString({\n                  propsString,\n                })\n              : {},\n          })\n          if (blockFields === false) {\n            return [false, startLineIndex]\n          }\n\n          const node = $createBlockNode({\n            blockType: block.slug,\n            ...blockFields,\n          } as any)\n\n          if (node) {\n            // Now handle beforeStartLine and afterEndLine. If those are not empty, we need to add them as text nodes before and after the block node.\n            // However, those themselves can contain other markdown matches, so we need to parse them as well.\n            // Example where this is needed: \"Hello <InlineCode>inline code</InlineCode> test.\"\n            let prevNodes: null | SerializedLexicalNode[] = null\n            let nextNodes: null | SerializedLexicalNode[] = null\n            // TODO: Might not need this prevNodes and nextNodes handling if inline nodes are handled by textmatch transformers\n\n            if (beforeStartLine?.length) {\n              prevNodes = markdownToLexical({ markdown: beforeStartLine })?.root?.children ?? []\n\n              const firstPrevNode = prevNodes?.[0]\n              if (firstPrevNode) {\n                rootNode.append($parseSerializedNode(firstPrevNode))\n              }\n            }\n\n            rootNode.append(node)\n\n            if (afterEndLine?.length) {\n              nextNodes = markdownToLexical({ markdown: afterEndLine })?.root?.children\n              const lastChild = rootNode.getChildren()[rootNode.getChildren().length - 1]\n\n              const children = ($parseSerializedNode(nextNodes[0]!) as ElementNode)?.getChildren()\n              if (children?.length) {\n                for (const child of children) {\n                  ;(lastChild as ElementNode).append(child)\n                }\n              }\n            }\n          }\n\n          return [true, endLineIndex]\n        },\n    regExpEnd: block.jsx?.customEndRegex ?? regex.regExpEnd,\n    regExpStart: block.jsx?.customStartRegex ?? regex.regExpStart,\n    // This replace is ONLY run for ``` code blocks (so any blocks with custom start and end regexes). For others, we use the special JSX handling above:\n    type: 'multiline-element',\n    replace: (rootNode, children, openMatch, closeMatch, linesInBetween) => {\n      if (block?.jsx?.import) {\n        if (!linesInBetween) {\n          // convert children to linesInBetween\n          let line = ''\n          if (children) {\n            for (const child of children) {\n              line += child.getTextContent()\n            }\n          }\n\n          linesInBetween = [line]\n        }\n\n        let childrenString = ''\n        if (block?.jsx?.doNotTrimChildren) {\n          childrenString = linesInBetween.join('\\n')\n        } else {\n          childrenString = linesInBetween.join('\\n').trim()\n        }\n\n        const propsString = openMatch[1]?.trim()\n\n        const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers)\n\n        const blockFields = block.jsx.import({\n          children: childrenString,\n          closeMatch: closeMatch as RegExpMatchArray,\n          htmlToLexical: null, // TODO\n          markdownToLexical,\n          openMatch: openMatch as RegExpMatchArray,\n          props: propsString\n            ? extractPropsFromJSXPropsString({\n                propsString,\n              })\n            : {},\n        })\n        if (blockFields === false) {\n          return false\n        }\n\n        const node = $createBlockNode({\n          blockType: block.slug,\n          ...blockFields,\n        } as any)\n\n        if (node) {\n          rootNode.append(node)\n        }\n\n        return\n      }\n      return false // Run next transformer\n    },\n  }))\n\n  return toReturn\n}\n"],"mappings":"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","ignoreList":[]}