@payloadcms/richtext-lexical 3.71.0-internal-debug.e053082 → 3.71.0-internal.49c4f67

package/dist/features/migrations/slateToLexical/converter/converters/unknown/converter.js

@@ -1,27 +1,27 @@
 import { convertSlateNodesToLexical } from '../../index.js';
 export const SlateUnknownConverter = {
-    converter ({ converters, slateNode }) {
-        return {
-            type: 'unknownConverted',
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: false,
-                converters,
-                parentNodeType: 'unknownConverted',
-                slateNodes: slateNode.children
-            }),
-            data: {
-                nodeData: slateNode,
-                nodeType: slateNode.type
-            },
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            version: 1
-        };
-    },
-    nodeTypes: [
-        'unknown'
-    ]
+  converter({
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'unknownConverted',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: false,
+        converters,
+        parentNodeType: 'unknownConverted',
+        slateNodes: slateNode.children
+      }),
+      data: {
+        nodeData: slateNode,
+        nodeType: slateNode.type
+      },
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
+    };
+  },
+  nodeTypes: ['unknown']
 };
-
 //# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/unknown/converter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/converter.ts"],"sourcesContent":["import type { SerializedUnknownConvertedNode } from '../../../nodes/unknownConvertedNode/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateUnknownConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'unknownConverted',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'unknownConverted',\n        slateNodes: slateNode.children!,\n      }),\n      data: {\n        nodeData: slateNode,\n        nodeType: slateNode.type,\n      },\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    } as const as SerializedUnknownConvertedNode\n  },\n  nodeTypes: ['unknown'],\n}\n"],"names":["convertSlateNodesToLexical","SlateUnknownConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,wBAA4C;IACvDC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,MAAM;gBACJC,UAAUP;gBACVQ,UAAUR,UAAUC,IAAI;YAC1B;YACAQ,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAU;AACxB,EAAC"}
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateUnknownConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/converter.ts"],"sourcesContent":["import type { SerializedUnknownConvertedNode } from '../../../nodes/unknownConvertedNode/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateUnknownConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'unknownConverted',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'unknownConverted',\n        slateNodes: slateNode.children!,\n      }),\n      data: {\n        nodeData: slateNode,\n        nodeType: slateNode.type,\n      },\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    } as const as SerializedUnknownConvertedNode\n  },\n  nodeTypes: ['unknown'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,qBAAA,GAA4C;EACvDC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,IAAA,EAAM;QACJC,QAAA,EAAUP,SAAA;QACVQ,QAAA,EAAUR,SAAA,CAAUC;MACtB;MACAQ,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/unorderedList/converter.js

@@ -1,26 +1,26 @@
 import { convertSlateNodesToLexical } from '../../index.js';
 export const SlateUnorderedListConverter = {
-    converter ({ converters, slateNode }) {
-        return {
-            type: 'list',
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: false,
-                converters,
-                parentNodeType: 'list',
-                slateNodes: slateNode.children
-            }),
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            listType: 'bullet',
-            start: 1,
-            tag: 'ul',
-            version: 1
-        };
-    },
-    nodeTypes: [
-        'ul'
-    ]
+  converter({
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'list',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: false,
+        converters,
+        parentNodeType: 'list',
+        slateNodes: slateNode.children
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      listType: 'bullet',
+      start: 1,
+      tag: 'ul',
+      version: 1
+    };
+  },
+  nodeTypes: ['ul']
 };
-
 //# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/unorderedList/converter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unorderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateUnorderedListConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'list',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'list',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      listType: 'bullet',\n      start: 1,\n      tag: 'ul',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ul'],\n}\n"],"names":["convertSlateNodesToLexical","SlateUnorderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,8BAAkD;IAC7DC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,UAAU;YACVC,OAAO;YACPC,KAAK;YACLC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAK;AACnB,EAAC"}
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateUnorderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unorderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateUnorderedListConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'list',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'list',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      listType: 'bullet',\n      start: 1,\n      tag: 'ul',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ul'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,2BAAA,GAAkD;EAC7DC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,QAAA,EAAU;MACVC,KAAA,EAAO;MACPC,GAAA,EAAK;MACLC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/upload/converter.js

@@ -1,19 +1,18 @@
 export const SlateUploadConverter = {
-    converter ({ slateNode }) {
-        return {
-            type: 'upload',
-            fields: {
-                ...slateNode.fields
-            },
-            format: '',
-            relationTo: slateNode.relationTo,
-            value: slateNode.value?.id || '',
-            version: 2
-        };
-    },
-    nodeTypes: [
-        'upload'
-    ]
+  converter({
+    slateNode
+  }) {
+    return {
+      type: 'upload',
+      fields: {
+        ...slateNode.fields
+      },
+      format: '',
+      relationTo: slateNode.relationTo,
+      value: slateNode.value?.id || '',
+      version: 2
+    };
+  },
+  nodeTypes: ['upload']
 };
-
 //# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/upload/converter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["import type { SerializedUploadNode } from '../../../../../upload/server/nodes/UploadNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const SlateUploadConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'upload',\n      fields: {\n        ...slateNode.fields,\n      },\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode.value?.id || '',\n      version: 2,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"names":["SlateUploadConverter","converter","slateNode","type","fields","format","relationTo","value","id","version","nodeTypes"],"mappings":"AAGA,OAAO,MAAMA,uBAA2C;IACtDC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;gBACN,GAAGF,UAAUE,MAAM;YACrB;YACAC,QAAQ;YACRC,YAAYJ,UAAUI,UAAU;YAChCC,OAAOL,UAAUK,KAAK,EAAEC,MAAM;YAC9BC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}
+{"version":3,"file":"converter.js","names":["SlateUploadConverter","converter","slateNode","type","fields","format","relationTo","value","id","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["import type { SerializedUploadNode } from '../../../../../upload/server/nodes/UploadNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const SlateUploadConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'upload',\n      fields: {\n        ...slateNode.fields,\n      },\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode.value?.id || '',\n      version: 2,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"mappings":"AAGA,OAAO,MAAMA,oBAAA,GAA2C;EACtDC,UAAU;IAAEC;EAAS,CAAE;IACrB,OAAO;MACLC,IAAA,EAAM;MACNC,MAAA,EAAQ;QACN,GAAGF,SAAA,CAAUE;MACf;MACAC,MAAA,EAAQ;MACRC,UAAA,EAAYJ,SAAA,CAAUI,UAAU;MAChCC,KAAA,EAAOL,SAAA,CAAUK,KAAK,EAAEC,EAAA,IAAM;MAC9BC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/defaultConverters.js

@@ -8,17 +8,5 @@ import { SlateRelationshipConverter } from './converters/relationship/converter.
 import { SlateUnknownConverter } from './converters/unknown/converter.js';
 import { SlateUnorderedListConverter } from './converters/unorderedList/converter.js';
 import { SlateUploadConverter } from './converters/upload/converter.js';
-export const defaultSlateConverters = [
-    SlateBlockquoteConverter,
-    SlateHeadingConverter,
-    SlateIndentConverter,
-    SlateLinkConverter,
-    SlateListItemConverter,
-    SlateOrderedListConverter,
-    SlateRelationshipConverter,
-    SlateUnorderedListConverter,
-    SlateUploadConverter,
-    SlateUnknownConverter
-];
-
+export const defaultSlateConverters = [SlateBlockquoteConverter, SlateHeadingConverter, SlateIndentConverter, SlateLinkConverter, SlateListItemConverter, SlateOrderedListConverter, SlateRelationshipConverter, SlateUnorderedListConverter, SlateUploadConverter, SlateUnknownConverter];
 //# sourceMappingURL=defaultConverters.js.map

package/dist/features/migrations/slateToLexical/converter/defaultConverters.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/migrations/slateToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { SlateNodeConverter } from './types.js'\n\nimport { SlateBlockquoteConverter } from './converters/blockquote/converter.js'\nimport { SlateHeadingConverter } from './converters/heading/converter.js'\nimport { SlateIndentConverter } from './converters/indent/converter.js'\nimport { SlateLinkConverter } from './converters/link/converter.js'\nimport { SlateListItemConverter } from './converters/listItem/converter.js'\nimport { SlateOrderedListConverter } from './converters/orderedList/converter.js'\nimport { SlateRelationshipConverter } from './converters/relationship/converter.js'\nimport { SlateUnknownConverter } from './converters/unknown/converter.js'\nimport { SlateUnorderedListConverter } from './converters/unorderedList/converter.js'\nimport { SlateUploadConverter } from './converters/upload/converter.js'\n\nexport const defaultSlateConverters: SlateNodeConverter[] = [\n  SlateBlockquoteConverter,\n  SlateHeadingConverter,\n  SlateIndentConverter,\n  SlateLinkConverter,\n  SlateListItemConverter,\n  SlateOrderedListConverter,\n  SlateRelationshipConverter,\n  SlateUnorderedListConverter,\n  SlateUploadConverter,\n  SlateUnknownConverter,\n]\n"],"names":["SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters"],"mappings":"AAEA,SAASA,wBAAwB,QAAQ,uCAAsC;AAC/E,SAASC,qBAAqB,QAAQ,oCAAmC;AACzE,SAASC,oBAAoB,QAAQ,mCAAkC;AACvE,SAASC,kBAAkB,QAAQ,iCAAgC;AACnE,SAASC,sBAAsB,QAAQ,qCAAoC;AAC3E,SAASC,yBAAyB,QAAQ,wCAAuC;AACjF,SAASC,0BAA0B,QAAQ,yCAAwC;AACnF,SAASC,qBAAqB,QAAQ,oCAAmC;AACzE,SAASC,2BAA2B,QAAQ,0CAAyC;AACrF,SAASC,oBAAoB,QAAQ,mCAAkC;AAEvE,OAAO,MAAMC,yBAA+C;IAC1DV;IACAC;IACAC;IACAC;IACAC;IACAC;IACAC;IACAE;IACAC;IACAF;CACD,CAAA"}
+{"version":3,"file":"defaultConverters.js","names":["SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters"],"sources":["../../../../../src/features/migrations/slateToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { SlateNodeConverter } from './types.js'\n\nimport { SlateBlockquoteConverter } from './converters/blockquote/converter.js'\nimport { SlateHeadingConverter } from './converters/heading/converter.js'\nimport { SlateIndentConverter } from './converters/indent/converter.js'\nimport { SlateLinkConverter } from './converters/link/converter.js'\nimport { SlateListItemConverter } from './converters/listItem/converter.js'\nimport { SlateOrderedListConverter } from './converters/orderedList/converter.js'\nimport { SlateRelationshipConverter } from './converters/relationship/converter.js'\nimport { SlateUnknownConverter } from './converters/unknown/converter.js'\nimport { SlateUnorderedListConverter } from './converters/unorderedList/converter.js'\nimport { SlateUploadConverter } from './converters/upload/converter.js'\n\nexport const defaultSlateConverters: SlateNodeConverter[] = [\n  SlateBlockquoteConverter,\n  SlateHeadingConverter,\n  SlateIndentConverter,\n  SlateLinkConverter,\n  SlateListItemConverter,\n  SlateOrderedListConverter,\n  SlateRelationshipConverter,\n  SlateUnorderedListConverter,\n  SlateUploadConverter,\n  SlateUnknownConverter,\n]\n"],"mappings":"AAEA,SAASA,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;AAErC,OAAO,MAAMC,sBAAA,GAA+C,CAC1DV,wBAAA,EACAC,qBAAA,EACAC,oBAAA,EACAC,kBAAA,EACAC,sBAAA,EACAC,yBAAA,EACAC,0BAAA,EACAE,2BAAA,EACAC,oBAAA,EACAF,qBAAA,CACD","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/index.js

@@ -1,123 +1,130 @@
 import { NodeFormat } from '../../../../lexical/utils/nodeFormat.js';
-export function convertSlateToLexical({ converters, slateData }) {
-    return {
-        root: {
-            type: 'root',
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: true,
-                converters,
-                parentNodeType: 'root',
-                slateNodes: slateData
-            }),
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            version: 1
-        }
-    };
-}
-export function convertSlateNodesToLexical({ canContainParagraphs, converters, parentNodeType, slateNodes }) /**
-   * Type of the parent lexical node (not the type of the original, parent slate type)
-   */ {
-    if (!converters?.length || !slateNodes?.length) {
-        return [];
+export function convertSlateToLexical({
+  converters,
+  slateData
+}) {
+  return {
+    root: {
+      type: 'root',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: true,
+        converters,
+        parentNodeType: 'root',
+        slateNodes: slateData
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
     }
-    const unknownConverter = converters.find((converter)=>converter.nodeTypes.includes('unknown'));
-    // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix
-    return(// Flatten in case we unwrap an array of child nodes
-    slateNodes.flatMap((slateNode, i)=>{
-        if (!('type' in slateNode)) {
-            if (canContainParagraphs) {
-                // This is a paragraph node. They do not have a type property in Slate
-                return convertParagraphNode(converters, slateNode);
-            } else {
-                // Unwrap generic Slate nodes recursively since depth wasn't guaranteed by Slate, especially when copy + pasting rich text
-                // - If there are children and it can't be a paragraph in Lexical, assume that the generic node should be unwrapped until the text nodes, and only assume that its a text node when there are no more children
-                if (slateNode.children) {
-                    return convertSlateNodesToLexical({
-                        canContainParagraphs,
-                        converters,
-                        parentNodeType,
-                        slateNodes: slateNode.children || []
-                    });
-                }
-                // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs
-                return convertTextNode(slateNode);
-            }
-        }
-        if (slateNode.type === 'p') {
-            return convertParagraphNode(converters, slateNode);
-        }
-        const converter = converters.find((converter)=>converter.nodeTypes.includes(slateNode.type));
-        if (converter) {
-            return converter.converter({
-                childIndex: i,
-                converters,
-                parentNodeType,
-                slateNode
+  };
+}
+export function convertSlateNodesToLexical({
+  canContainParagraphs,
+  converters,
+  parentNodeType,
+  slateNodes
+}) {
+  if (!converters?.length || !slateNodes?.length) {
+    return [];
+  }
+  const unknownConverter = converters.find(converter => converter.nodeTypes.includes('unknown'));
+  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix
+  return (
+    // Flatten in case we unwrap an array of child nodes
+    slateNodes.flatMap((slateNode, i) => {
+      if (!('type' in slateNode)) {
+        if (canContainParagraphs) {
+          // This is a paragraph node. They do not have a type property in Slate
+          return convertParagraphNode(converters, slateNode);
+        } else {
+          // Unwrap generic Slate nodes recursively since depth wasn't guaranteed by Slate, especially when copy + pasting rich text
+          // - If there are children and it can't be a paragraph in Lexical, assume that the generic node should be unwrapped until the text nodes, and only assume that its a text node when there are no more children
+          if (slateNode.children) {
+            return convertSlateNodesToLexical({
+              canContainParagraphs,
+              converters,
+              parentNodeType,
+              slateNodes: slateNode.children || []
             });
+          }
+          // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs
+          return convertTextNode(slateNode);
         }
-        console.warn('slateToLexical > No converter found for node type: ' + slateNode.type);
-        return unknownConverter?.converter({
-            childIndex: i,
-            converters,
-            parentNodeType,
-            slateNode
+      }
+      if (slateNode.type === 'p') {
+        return convertParagraphNode(converters, slateNode);
+      }
+      const converter = converters.find(converter => converter.nodeTypes.includes(slateNode.type));
+      if (converter) {
+        return converter.converter({
+          childIndex: i,
+          converters,
+          parentNodeType,
+          slateNode
         });
-    }) || []);
+      }
+      console.warn('slateToLexical > No converter found for node type: ' + slateNode.type);
+      return unknownConverter?.converter({
+        childIndex: i,
+        converters,
+        parentNodeType,
+        slateNode
+      });
+    }) || []
+  );
 }
 export function convertParagraphNode(converters, node) {
-    return {
-        type: 'paragraph',
-        children: convertSlateNodesToLexical({
-            canContainParagraphs: false,
-            converters,
-            parentNodeType: 'paragraph',
-            slateNodes: node.children || []
-        }),
-        direction: 'ltr',
-        format: '',
-        indent: 0,
-        textFormat: 0,
-        textStyle: '',
-        version: 1
-    };
+  return {
+    type: 'paragraph',
+    children: convertSlateNodesToLexical({
+      canContainParagraphs: false,
+      converters,
+      parentNodeType: 'paragraph',
+      slateNodes: node.children || []
+    }),
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    textFormat: 0,
+    textStyle: '',
+    version: 1
+  };
 }
 export function convertTextNode(node) {
-    return {
-        type: 'text',
-        detail: 0,
-        format: convertNodeToFormat(node),
-        mode: 'normal',
-        style: '',
-        text: node.text ?? '',
-        version: 1
-    };
+  return {
+    type: 'text',
+    detail: 0,
+    format: convertNodeToFormat(node),
+    mode: 'normal',
+    style: '',
+    text: node.text ?? '',
+    version: 1
+  };
 }
 export function convertNodeToFormat(node) {
-    let format = 0;
-    if (node.bold) {
-        format = format | NodeFormat.IS_BOLD;
-    }
-    if (node.italic) {
-        format = format | NodeFormat.IS_ITALIC;
-    }
-    if (node.strikethrough) {
-        format = format | NodeFormat.IS_STRIKETHROUGH;
-    }
-    if (node.underline) {
-        format = format | NodeFormat.IS_UNDERLINE;
-    }
-    if (node.subscript) {
-        format = format | NodeFormat.IS_SUBSCRIPT;
-    }
-    if (node.superscript) {
-        format = format | NodeFormat.IS_SUPERSCRIPT;
-    }
-    if (node.code) {
-        format = format | NodeFormat.IS_CODE;
-    }
-    return format;
+  let format = 0;
+  if (node.bold) {
+    format = format | NodeFormat.IS_BOLD;
+  }
+  if (node.italic) {
+    format = format | NodeFormat.IS_ITALIC;
+  }
+  if (node.strikethrough) {
+    format = format | NodeFormat.IS_STRIKETHROUGH;
+  }
+  if (node.underline) {
+    format = format | NodeFormat.IS_UNDERLINE;
+  }
+  if (node.subscript) {
+    format = format | NodeFormat.IS_SUBSCRIPT;
+  }
+  if (node.superscript) {
+    format = format | NodeFormat.IS_SUPERSCRIPT;
+  }
+  if (node.code) {
+    format = format | NodeFormat.IS_CODE;
+  }
+  return format;
 }
-
 //# sourceMappingURL=index.js.map

package/dist/features/migrations/slateToLexical/converter/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/migrations/slateToLexical/converter/index.ts"],"sourcesContent":["import type {\n  SerializedEditorState,\n  SerializedLexicalNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n} from 'lexical'\n\nimport type { SlateNode, SlateNodeConverter } from './types.js'\n\nimport { NodeFormat } from '../../../../lexical/utils/nodeFormat.js'\n\nexport function convertSlateToLexical({\n  converters,\n  slateData,\n}: {\n  converters: SlateNodeConverter[]\n  slateData: SlateNode[]\n}): SerializedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: true,\n        converters,\n        parentNodeType: 'root',\n        slateNodes: slateData,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n}\n\nexport function convertSlateNodesToLexical({\n  canContainParagraphs,\n  converters,\n  parentNodeType,\n  slateNodes,\n}: {\n  canContainParagraphs: boolean\n  converters: SlateNodeConverter[] | undefined\n  /**\n   * Type of the parent lexical node (not the type of the original, parent slate type)\n   */\n  parentNodeType: string\n  slateNodes: SlateNode[]\n}): SerializedLexicalNode[] {\n  if (!converters?.length || !slateNodes?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix\n  return (\n    // Flatten in case we unwrap an array of child nodes\n    slateNodes.flatMap((slateNode, i) => {\n      if (!('type' in slateNode)) {\n        if (canContainParagraphs) {\n          // This is a paragraph node. They do not have a type property in Slate\n          return convertParagraphNode(converters, slateNode)\n        } else {\n          // Unwrap generic Slate nodes recursively since depth wasn't guaranteed by Slate, especially when copy + pasting rich text\n          // - If there are children and it can't be a paragraph in Lexical, assume that the generic node should be unwrapped until the text nodes, and only assume that its a text node when there are no more children\n          if (slateNode.children) {\n            return convertSlateNodesToLexical({\n              canContainParagraphs,\n              converters,\n              parentNodeType,\n              slateNodes: slateNode.children || [],\n            })\n          }\n          // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs\n          return convertTextNode(slateNode)\n        }\n      }\n      if (slateNode.type === 'p') {\n        return convertParagraphNode(converters, slateNode)\n      }\n\n      const converter = converters.find((converter) =>\n        converter.nodeTypes.includes(slateNode.type!),\n      )\n\n      if (converter) {\n        return converter.converter({ childIndex: i, converters, parentNodeType, slateNode })\n      }\n\n      console.warn('slateToLexical > No converter found for node type: ' + slateNode.type)\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        parentNodeType,\n        slateNode,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: SlateNodeConverter[],\n  node: SlateNode,\n): SerializedParagraphNode {\n  return {\n    type: 'paragraph',\n    children: convertSlateNodesToLexical({\n      canContainParagraphs: false,\n      converters,\n      parentNodeType: 'paragraph',\n      slateNodes: node.children || [],\n    }),\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    textFormat: 0,\n    textStyle: '',\n    version: 1,\n  }\n}\nexport function convertTextNode(node: SlateNode): SerializedTextNode {\n  return {\n    type: 'text',\n    detail: 0,\n    format: convertNodeToFormat(node),\n    mode: 'normal',\n    style: '',\n    text: node.text ?? '',\n    version: 1,\n  }\n}\n\nexport function convertNodeToFormat(node: SlateNode): number {\n  let format = 0\n  if (node.bold) {\n    format = format | NodeFormat.IS_BOLD\n  }\n  if (node.italic) {\n    format = format | NodeFormat.IS_ITALIC\n  }\n  if (node.strikethrough) {\n    format = format | NodeFormat.IS_STRIKETHROUGH\n  }\n  if (node.underline) {\n    format = format | NodeFormat.IS_UNDERLINE\n  }\n  if (node.subscript) {\n    format = format | NodeFormat.IS_SUBSCRIPT\n  }\n  if (node.superscript) {\n    format = format | NodeFormat.IS_SUPERSCRIPT\n  }\n  if (node.code) {\n    format = format | NodeFormat.IS_CODE\n  }\n  return format\n}\n"],"names":["NodeFormat","convertSlateToLexical","converters","slateData","root","type","children","convertSlateNodesToLexical","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","flatMap","slateNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node","textFormat","textStyle","detail","convertNodeToFormat","mode","style","text","bold","IS_BOLD","italic","IS_ITALIC","strikethrough","IS_STRIKETHROUGH","underline","IS_UNDERLINE","subscript","IS_SUBSCRIPT","superscript","IS_SUPERSCRIPT","code","IS_CODE"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["NodeFormat","convertSlateToLexical","converters","slateData","root","type","children","convertSlateNodesToLexical","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","flatMap","slateNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node","textFormat","textStyle","detail","convertNodeToFormat","mode","style","text","bold","IS_BOLD","italic","IS_ITALIC","strikethrough","IS_STRIKETHROUGH","underline","IS_UNDERLINE","subscript","IS_SUBSCRIPT","superscript","IS_SUPERSCRIPT","code","IS_CODE"],"sources":["../../../../../src/features/migrations/slateToLexical/converter/index.ts"],"sourcesContent":["import type {\n  SerializedEditorState,\n  SerializedLexicalNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n} from 'lexical'\n\nimport type { SlateNode, SlateNodeConverter } from './types.js'\n\nimport { NodeFormat } from '../../../../lexical/utils/nodeFormat.js'\n\nexport function convertSlateToLexical({\n  converters,\n  slateData,\n}: {\n  converters: SlateNodeConverter[]\n  slateData: SlateNode[]\n}): SerializedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: true,\n        converters,\n        parentNodeType: 'root',\n        slateNodes: slateData,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n}\n\nexport function convertSlateNodesToLexical({\n  canContainParagraphs,\n  converters,\n  parentNodeType,\n  slateNodes,\n}: {\n  canContainParagraphs: boolean\n  converters: SlateNodeConverter[] | undefined\n  /**\n   * Type of the parent lexical node (not the type of the original, parent slate type)\n   */\n  parentNodeType: string\n  slateNodes: SlateNode[]\n}): SerializedLexicalNode[] {\n  if (!converters?.length || !slateNodes?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix\n  return (\n    // Flatten in case we unwrap an array of child nodes\n    slateNodes.flatMap((slateNode, i) => {\n      if (!('type' in slateNode)) {\n        if (canContainParagraphs) {\n          // This is a paragraph node. They do not have a type property in Slate\n          return convertParagraphNode(converters, slateNode)\n        } else {\n          // Unwrap generic Slate nodes recursively since depth wasn't guaranteed by Slate, especially when copy + pasting rich text\n          // - If there are children and it can't be a paragraph in Lexical, assume that the generic node should be unwrapped until the text nodes, and only assume that its a text node when there are no more children\n          if (slateNode.children) {\n            return convertSlateNodesToLexical({\n              canContainParagraphs,\n              converters,\n              parentNodeType,\n              slateNodes: slateNode.children || [],\n            })\n          }\n          // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs\n          return convertTextNode(slateNode)\n        }\n      }\n      if (slateNode.type === 'p') {\n        return convertParagraphNode(converters, slateNode)\n      }\n\n      const converter = converters.find((converter) =>\n        converter.nodeTypes.includes(slateNode.type!),\n      )\n\n      if (converter) {\n        return converter.converter({ childIndex: i, converters, parentNodeType, slateNode })\n      }\n\n      console.warn('slateToLexical > No converter found for node type: ' + slateNode.type)\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        parentNodeType,\n        slateNode,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: SlateNodeConverter[],\n  node: SlateNode,\n): SerializedParagraphNode {\n  return {\n    type: 'paragraph',\n    children: convertSlateNodesToLexical({\n      canContainParagraphs: false,\n      converters,\n      parentNodeType: 'paragraph',\n      slateNodes: node.children || [],\n    }),\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    textFormat: 0,\n    textStyle: '',\n    version: 1,\n  }\n}\nexport function convertTextNode(node: SlateNode): SerializedTextNode {\n  return {\n    type: 'text',\n    detail: 0,\n    format: convertNodeToFormat(node),\n    mode: 'normal',\n    style: '',\n    text: node.text ?? '',\n    version: 1,\n  }\n}\n\nexport function convertNodeToFormat(node: SlateNode): number {\n  let format = 0\n  if (node.bold) {\n    format = format | NodeFormat.IS_BOLD\n  }\n  if (node.italic) {\n    format = format | NodeFormat.IS_ITALIC\n  }\n  if (node.strikethrough) {\n    format = format | NodeFormat.IS_STRIKETHROUGH\n  }\n  if (node.underline) {\n    format = format | NodeFormat.IS_UNDERLINE\n  }\n  if (node.subscript) {\n    format = format | NodeFormat.IS_SUBSCRIPT\n  }\n  if (node.superscript) {\n    format = format | NodeFormat.IS_SUPERSCRIPT\n  }\n  if (node.code) {\n    format = format | NodeFormat.IS_CODE\n  }\n  return format\n}\n"],"mappings":"AASA,SAASA,UAAU,QAAQ;AAE3B,OAAO,SAASC,sBAAsB;EACpCC,UAAU;EACVC;AAAS,CAIV;EACC,OAAO;IACLC,IAAA,EAAM;MACJC,IAAA,EAAM;MACNC,QAAA,EAAUC,0BAAA,CAA2B;QACnCC,oBAAA,EAAsB;QACtBN,UAAA;QACAO,cAAA,EAAgB;QAChBC,UAAA,EAAYP;MACd;MACAQ,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;AACF;AAEA,OAAO,SAASP,2BAA2B;EACzCC,oBAAoB;EACpBN,UAAU;EACVO,cAAc;EACdC;AAAU,CASX;EACC,IAAI,CAACR,UAAA,EAAYa,MAAA,IAAU,CAACL,UAAA,EAAYK,MAAA,EAAQ;IAC9C,OAAO,EAAE;EACX;EACA,MAAMC,gBAAA,GAAmBd,UAAA,CAAWe,IAAI,CAAEC,SAAA,IAAcA,SAAA,CAAUC,SAAS,CAACC,QAAQ,CAAC;EACrF;EACA;IACE;IACAV,UAAA,CAAWW,OAAO,CAAC,CAACC,SAAA,EAAWC,CAAA;MAC7B,IAAI,EAAE,UAAUD,SAAQ,GAAI;QAC1B,IAAId,oBAAA,EAAsB;UACxB;UACA,OAAOgB,oBAAA,CAAqBtB,UAAA,EAAYoB,SAAA;QAC1C,OAAO;UACL;UACA;UACA,IAAIA,SAAA,CAAUhB,QAAQ,EAAE;YACtB,OAAOC,0BAAA,CAA2B;cAChCC,oBAAA;cACAN,UAAA;cACAO,cAAA;cACAC,UAAA,EAAYY,SAAA,CAAUhB,QAAQ,IAAI;YACpC;UACF;UACA;UACA,OAAOmB,eAAA,CAAgBH,SAAA;QACzB;MACF;MACA,IAAIA,SAAA,CAAUjB,IAAI,KAAK,KAAK;QAC1B,OAAOmB,oBAAA,CAAqBtB,UAAA,EAAYoB,SAAA;MAC1C;MAEA,MAAMJ,SAAA,GAAYhB,UAAA,CAAWe,IAAI,CAAEC,SAAA,IACjCA,SAAA,CAAUC,SAAS,CAACC,QAAQ,CAACE,SAAA,CAAUjB,IAAI;MAG7C,IAAIa,SAAA,EAAW;QACb,OAAOA,SAAA,CAAUA,SAAS,CAAC;UAAEQ,UAAA,EAAYH,CAAA;UAAGrB,UAAA;UAAYO,cAAA;UAAgBa;QAAU;MACpF;MAEAK,OAAA,CAAQC,IAAI,CAAC,wDAAwDN,SAAA,CAAUjB,IAAI;MACnF,OAAOW,gBAAA,EAAkBE,SAAA,CAAU;QACjCQ,UAAA,EAAYH,CAAA;QACZrB,UAAA;QACAO,cAAA;QACAa;MACF;IACF,MAAM;EAAE;AAEZ;AAEA,OAAO,SAASE,qBACdtB,UAAgC,EAChC2B,IAAe;EAEf,OAAO;IACLxB,IAAA,EAAM;IACNC,QAAA,EAAUC,0BAAA,CAA2B;MACnCC,oBAAA,EAAsB;MACtBN,UAAA;MACAO,cAAA,EAAgB;MAChBC,UAAA,EAAYmB,IAAA,CAAKvB,QAAQ,IAAI;IAC/B;IACAK,SAAA,EAAW;IACXC,MAAA,EAAQ;IACRC,MAAA,EAAQ;IACRiB,UAAA,EAAY;IACZC,SAAA,EAAW;IACXjB,OAAA,EAAS;EACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAAe;EAC7C,OAAO;IACLxB,IAAA,EAAM;IACN2B,MAAA,EAAQ;IACRpB,MAAA,EAAQqB,mBAAA,CAAoBJ,IAAA;IAC5BK,IAAA,EAAM;IACNC,KAAA,EAAO;IACPC,IAAA,EAAMP,IAAA,CAAKO,IAAI,IAAI;IACnBtB,OAAA,EAAS;EACX;AACF;AAEA,OAAO,SAASmB,oBAAoBJ,IAAe;EACjD,IAAIjB,MAAA,GAAS;EACb,IAAIiB,IAAA,CAAKQ,IAAI,EAAE;IACbzB,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAWsC,OAAO;EACtC;EACA,IAAIT,IAAA,CAAKU,MAAM,EAAE;IACf3B,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAWwC,SAAS;EACxC;EACA,IAAIX,IAAA,CAAKY,aAAa,EAAE;IACtB7B,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAW0C,gBAAgB;EAC/C;EACA,IAAIb,IAAA,CAAKc,SAAS,EAAE;IAClB/B,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAW4C,YAAY;EAC3C;EACA,IAAIf,IAAA,CAAKgB,SAAS,EAAE;IAClBjC,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAW8C,YAAY;EAC3C;EACA,IAAIjB,IAAA,CAAKkB,WAAW,EAAE;IACpBnC,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAWgD,cAAc;EAC7C;EACA,IAAInB,IAAA,CAAKoB,IAAI,EAAE;IACbrC,MAAA,GAASA,MAAA,GAASZ,UAAA,CAAWkD,OAAO;EACtC;EACA,OAAOtC,MAAA;AACT","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/types.js

@@ -1,3 +1,2 @@
-export { }; // doesn't always have type, e.g. for paragraphs
-
+export {};
 //# sourceMappingURL=types.js.map

package/dist/features/migrations/slateToLexical/converter/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nexport type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    parentNodeType,\n    slateNode,\n  }: {\n    childIndex: number\n    converters: SlateNodeConverter[]\n    parentNodeType: string\n    slateNode: SlateNode\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type SlateNode = {\n  [key: string]: any\n  children?: SlateNode[]\n  type?: string // doesn't always have type, e.g. for paragraphs\n}\n"],"names":[],"mappings":"AAiBA,WAIC,CADe,gDAAgD"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nexport type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    parentNodeType,\n    slateNode,\n  }: {\n    childIndex: number\n    converters: SlateNodeConverter[]\n    parentNodeType: string\n    slateNode: SlateNode\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type SlateNode = {\n  [key: string]: any\n  children?: SlateNode[]\n  type?: string // doesn't always have type, e.g. for paragraphs\n}\n"],"mappings":"AAiBA","ignoreList":[]}

package/dist/features/migrations/slateToLexical/feature.client.js

@@ -1,12 +1,10 @@
 'use client';
+
 import { createClientFeature } from '../../../utilities/createClientFeature.js';
 import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
-export const SlateToLexicalFeatureClient = createClientFeature(()=>{
-    return {
-        nodes: [
-            UnknownConvertedNode
-        ]
-    };
+export const SlateToLexicalFeatureClient = createClientFeature(() => {
+  return {
+    nodes: [UnknownConvertedNode]
+  };
 });
-
 //# sourceMappingURL=feature.client.js.map

package/dist/features/migrations/slateToLexical/feature.client.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const SlateToLexicalFeatureClient = createClientFeature(() => {\n  return {\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"names":["createClientFeature","UnknownConvertedNode","SlateToLexicalFeatureClient","nodes"],"mappings":"AAAA;AAEA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,OAAO,MAAMC,8BAA8BF,oBAAoB;IAC7D,OAAO;QACLG,OAAO;YAACF;SAAqB;IAC/B;AACF,GAAE"}
+{"version":3,"file":"feature.client.js","names":["createClientFeature","UnknownConvertedNode","SlateToLexicalFeatureClient","nodes"],"sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const SlateToLexicalFeatureClient = createClientFeature(() => {\n  return {\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"mappings":"AAAA;;AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,2BAAA,GAA8BF,mBAAA,CAAoB;EAC7D,OAAO;IACLG,KAAA,EAAO,CAACF,oBAAA;EACV;AACF","ignoreList":[]}