@payloadcms/richtext-lexical 3.0.0-beta.78 → 3.0.0-beta.80

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { LexicalPluginNodeConverterProvider } from './types.js'\n\nimport { HeadingConverter } from './converters/heading/index.js'\nimport { LinkConverter } from './converters/link/index.js'\nimport { ListConverter } from './converters/list/index.js'\nimport { ListItemConverter } from './converters/listItem/index.js'\nimport { QuoteConverter } from './converters/quote/index.js'\nimport { UnknownConverter } from './converters/unknown/index.js'\nimport { UploadConverter } from './converters/upload/index.js'\n\nexport const defaultConverters: LexicalPluginNodeConverterProvider[] = [\n  HeadingConverter,\n  LinkConverter,\n  ListConverter,\n  ListItemConverter,\n  QuoteConverter,\n  UnknownConverter,\n  UploadConverter,\n]\n"],"names":["HeadingConverter","LinkConverter","ListConverter","ListItemConverter","QuoteConverter","UnknownConverter","UploadConverter","defaultConverters"],"mappings":"AAEA,SAASA,gBAAgB,QAAQ,gCAA+B;AAChE,SAASC,aAAa,QAAQ,6BAA4B;AAC1D,SAASC,aAAa,QAAQ,6BAA4B;AAC1D,SAASC,iBAAiB,QAAQ,iCAAgC;AAClE,SAASC,cAAc,QAAQ,8BAA6B;AAC5D,SAASC,gBAAgB,QAAQ,gCAA+B;AAChE,SAASC,eAAe,QAAQ,+BAA8B;AAE9D,OAAO,MAAMC,oBAA0D;IACrEP;IACAC;IACAC;IACAC;IACAC;IACAC;IACAC;CACD,CAAA"}
+{"version":3,"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { LexicalPluginNodeConverter } from './types.js'\n\nimport { HeadingConverter } from './converters/heading/converter.js'\nimport { LinkConverter } from './converters/link/converter.js'\nimport { ListConverter } from './converters/list/converter.js'\nimport { ListItemConverter } from './converters/listItem/converter.js'\nimport { QuoteConverter } from './converters/quote/converter.js'\nimport { UnknownConverter } from './converters/unknown/converter.js'\nimport { UploadConverter } from './converters/upload/converter.js'\n\nexport const defaultConverters: LexicalPluginNodeConverter[] = [\n  HeadingConverter,\n  LinkConverter,\n  ListConverter,\n  ListItemConverter,\n  QuoteConverter,\n  UnknownConverter,\n  UploadConverter,\n]\n"],"names":["HeadingConverter","LinkConverter","ListConverter","ListItemConverter","QuoteConverter","UnknownConverter","UploadConverter","defaultConverters"],"mappings":"AAEA,SAASA,gBAAgB,QAAQ,oCAAmC;AACpE,SAASC,aAAa,QAAQ,iCAAgC;AAC9D,SAASC,aAAa,QAAQ,iCAAgC;AAC9D,SAASC,iBAAiB,QAAQ,qCAAoC;AACtE,SAASC,cAAc,QAAQ,kCAAiC;AAChE,SAASC,gBAAgB,QAAQ,oCAAmC;AACpE,SAASC,eAAe,QAAQ,mCAAkC;AAElE,OAAO,MAAMC,oBAAkD;IAC7DP;IACAC;IACAC;IACAC;IACAC;IACAC;IACAC;CACD,CAAA"}

package/dist/features/migrations/lexicalPluginToLexical/converter/index.d.ts

@@ -1,17 +1,19 @@
 import type { SerializedEditorState, SerializedLexicalNode, SerializedParagraphNode, SerializedTextNode } from 'lexical';
 import type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './types.js';
-export declare function convertLexicalPluginToLexical({ converters, lexicalPluginData, }: {
+export declare function convertLexicalPluginToLexical({ converters, lexicalPluginData, quiet, }: {
     converters: LexicalPluginNodeConverter[];
     lexicalPluginData: PayloadPluginLexicalData;
+    quiet?: boolean;
 }): SerializedEditorState;
-export declare function convertLexicalPluginNodesToLexical({ converters, lexicalPluginNodes, parentNodeType, }: {
+export declare function convertLexicalPluginNodesToLexical({ converters, lexicalPluginNodes, parentNodeType, quiet, }: {
     converters: LexicalPluginNodeConverter[];
     lexicalPluginNodes: SerializedLexicalNode[] | undefined;
     /**
      * Type of the parent lexical node (not the type of the original, parent payload-plugin-lexical type)
      */
     parentNodeType: string;
+    quiet?: boolean;
 }): SerializedLexicalNode[];
-export declare function convertParagraphNode(converters: LexicalPluginNodeConverter[], node: SerializedLexicalNode): SerializedParagraphNode;
+export declare function convertParagraphNode(converters: LexicalPluginNodeConverter[], node: SerializedLexicalNode, quiet?: boolean): SerializedParagraphNode;
 export declare function convertTextNode(node: SerializedLexicalNode): SerializedTextNode;
 //# sourceMappingURL=index.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/converter/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EACnB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAEtF,wBAAgB,6BAA6B,CAAC,EAC5C,UAAU,EACV,iBAAiB,GAClB,EAAE;IACD,UAAU,EAAE,0BAA0B,EAAE,CAAA;IACxC,iBAAiB,EAAE,wBAAwB,CAAA;CAC5C,GAAG,qBAAqB,CAexB;AAED,wBAAgB,kCAAkC,CAAC,EACjD,UAAU,EACV,kBAAkB,EAClB,cAAc,GACf,EAAE;IACD,UAAU,EAAE,0BAA0B,EAAE,CAAA;IACxC,kBAAkB,EAAE,qBAAqB,EAAE,GAAG,SAAS,CAAA;IACvD;;OAEG;IACH,cAAc,EAAE,MAAM,CAAA;CACvB,GAAG,qBAAqB,EAAE,CAiC1B;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,0BAA0B,EAAE,EACxC,IAAI,EAAE,qBAAqB,GAC1B,uBAAuB,CAYzB;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,qBAAqB,GAAG,kBAAkB,CAE/E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EACnB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAEtF,wBAAgB,6BAA6B,CAAC,EAC5C,UAAU,EACV,iBAAiB,EACjB,KAAK,GACN,EAAE;IACD,UAAU,EAAE,0BAA0B,EAAE,CAAA;IACxC,iBAAiB,EAAE,wBAAwB,CAAA;IAC3C,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,GAAG,qBAAqB,CAgBxB;AAED,wBAAgB,kCAAkC,CAAC,EACjD,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,KAAK,GACN,EAAE;IACD,UAAU,EAAE,0BAA0B,EAAE,CAAA;IACxC,kBAAkB,EAAE,qBAAqB,EAAE,GAAG,SAAS,CAAA;IACvD;;OAEG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,GAAG,qBAAqB,EAAE,CA2C1B;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,0BAA0B,EAAE,EACxC,IAAI,EAAE,qBAAqB,EAC3B,KAAK,CAAC,EAAE,OAAO,GACd,uBAAuB,CAazB;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,qBAAqB,GAAG,kBAAkB,CAE/E"}

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

@@ -1,11 +1,12 @@
-export function convertLexicalPluginToLexical({ converters, lexicalPluginData }) {
+export function convertLexicalPluginToLexical({ converters, lexicalPluginData, quiet }) {
     return {
         root: {
             type: 'root',
             children: convertLexicalPluginNodesToLexical({
                 converters,
                 lexicalPluginNodes: lexicalPluginData?.jsonContent?.root?.children || [],
-                parentNodeType: 'root'
+                parentNodeType: 'root',
+                quiet
             }),
             direction: lexicalPluginData?.jsonContent?.root?.direction || 'ltr',
             format: lexicalPluginData?.jsonContent?.root?.format || '',
@@ -14,14 +15,14 @@ export function convertLexicalPluginToLexical({ converters, lexicalPluginData })
         }
     };
 }
-export function convertLexicalPluginNodesToLexical({ converters, lexicalPluginNodes, parentNodeType }) {
+export function convertLexicalPluginNodesToLexical({ converters, lexicalPluginNodes, parentNodeType, quiet }) {
     if (!lexicalPluginNodes?.length) {
         return [];
     }
     const unknownConverter = converters.find((converter)=>converter.nodeTypes.includes('unknown'));
     return lexicalPluginNodes.map((lexicalPluginNode, i)=>{
         if (lexicalPluginNode.type === 'paragraph') {
-            return convertParagraphNode(converters, lexicalPluginNode);
+            return convertParagraphNode(converters, lexicalPluginNode, quiet);
         }
         if (lexicalPluginNode.type === 'text' || !lexicalPluginNode.type) {
             return convertTextNode(lexicalPluginNode);
@@ -32,26 +33,31 @@ export function convertLexicalPluginNodesToLexical({ converters, lexicalPluginNo
                 childIndex: i,
                 converters,
                 lexicalPluginNode,
-                parentNodeType
+                parentNodeType,
+                quiet
             });
         }
-        console.warn('lexicalPluginToLexical > No converter found for node type: ' + lexicalPluginNode.type);
+        if (!quiet) {
+            console.warn('lexicalPluginToLexical > No converter found for node type: ' + lexicalPluginNode.type);
+        }
         return unknownConverter?.converter({
             childIndex: i,
             converters,
             lexicalPluginNode,
-            parentNodeType
+            parentNodeType,
+            quiet
         });
     }) || [];
 }
-export function convertParagraphNode(converters, node) {
+export function convertParagraphNode(converters, node, quiet) {
     return {
         ...node,
         type: 'paragraph',
         children: convertLexicalPluginNodesToLexical({
             converters,
             lexicalPluginNodes: node.children || [],
-            parentNodeType: 'paragraph'
+            parentNodeType: 'paragraph',
+            quiet
         }),
         version: 1
     };

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/index.ts"],"sourcesContent":["import type {\n  SerializedEditorState,\n  SerializedLexicalNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n} from 'lexical'\n\nimport type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './types.js'\n\nexport function convertLexicalPluginToLexical({\n  converters,\n  lexicalPluginData,\n}: {\n  converters: LexicalPluginNodeConverter[]\n  lexicalPluginData: PayloadPluginLexicalData\n}): SerializedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginData?.jsonContent?.root?.children || [],\n        parentNodeType: 'root',\n      }),\n      direction: lexicalPluginData?.jsonContent?.root?.direction || 'ltr',\n      format: lexicalPluginData?.jsonContent?.root?.format || '',\n      indent: lexicalPluginData?.jsonContent?.root?.indent || 0,\n      version: 1,\n    },\n  }\n}\n\nexport function convertLexicalPluginNodesToLexical({\n  converters,\n  lexicalPluginNodes,\n  parentNodeType,\n}: {\n  converters: LexicalPluginNodeConverter[]\n  lexicalPluginNodes: SerializedLexicalNode[] | undefined\n  /**\n   * Type of the parent lexical node (not the type of the original, parent payload-plugin-lexical type)\n   */\n  parentNodeType: string\n}): SerializedLexicalNode[] {\n  if (!lexicalPluginNodes?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  return (\n    lexicalPluginNodes.map((lexicalPluginNode, i) => {\n      if (lexicalPluginNode.type === 'paragraph') {\n        return convertParagraphNode(converters, lexicalPluginNode)\n      }\n      if (lexicalPluginNode.type === 'text' || !lexicalPluginNode.type) {\n        return convertTextNode(lexicalPluginNode)\n      }\n\n      const converter = converters.find((converter) =>\n        converter.nodeTypes.includes(lexicalPluginNode.type),\n      )\n\n      if (converter) {\n        return converter.converter({ childIndex: i, converters, lexicalPluginNode, parentNodeType })\n      }\n\n      console.warn(\n        'lexicalPluginToLexical > No converter found for node type: ' + lexicalPluginNode.type,\n      )\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        lexicalPluginNode,\n        parentNodeType,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: LexicalPluginNodeConverter[],\n  node: SerializedLexicalNode,\n): SerializedParagraphNode {\n  return {\n    ...node,\n    type: 'paragraph',\n\n    children: convertLexicalPluginNodesToLexical({\n      converters,\n      lexicalPluginNodes: (node as any).children || [],\n      parentNodeType: 'paragraph',\n    }),\n    version: 1,\n  } as SerializedParagraphNode\n}\nexport function convertTextNode(node: SerializedLexicalNode): SerializedTextNode {\n  return node as SerializedTextNode\n}\n"],"names":["convertLexicalPluginToLexical","converters","lexicalPluginData","root","type","children","convertLexicalPluginNodesToLexical","lexicalPluginNodes","jsonContent","parentNodeType","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","map","lexicalPluginNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node"],"mappings":"AASA,OAAO,SAASA,8BAA8B,EAC5CC,UAAU,EACVC,iBAAiB,EAIlB;IACC,OAAO;QACLC,MAAM;YACJC,MAAM;YACNC,UAAUC,mCAAmC;gBAC3CL;gBACAM,oBAAoBL,mBAAmBM,aAAaL,MAAME,YAAY,EAAE;gBACxEI,gBAAgB;YAClB;YACAC,WAAWR,mBAAmBM,aAAaL,MAAMO,aAAa;YAC9DC,QAAQT,mBAAmBM,aAAaL,MAAMQ,UAAU;YACxDC,QAAQV,mBAAmBM,aAAaL,MAAMS,UAAU;YACxDC,SAAS;QACX;IACF;AACF;AAEA,OAAO,SAASP,mCAAmC,EACjDL,UAAU,EACVM,kBAAkB,EAClBE,cAAc,EAQf;IACC,IAAI,CAACF,oBAAoBO,QAAQ;QAC/B,OAAO,EAAE;IACX;IACA,MAAMC,mBAAmBd,WAAWe,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IACrF,OACEZ,mBAAmBa,GAAG,CAAC,CAACC,mBAAmBC;QACzC,IAAID,kBAAkBjB,IAAI,KAAK,aAAa;YAC1C,OAAOmB,qBAAqBtB,YAAYoB;QAC1C;QACA,IAAIA,kBAAkBjB,IAAI,KAAK,UAAU,CAACiB,kBAAkBjB,IAAI,EAAE;YAChE,OAAOoB,gBAAgBH;QACzB;QAEA,MAAMJ,YAAYhB,WAAWe,IAAI,CAAC,CAACC,YACjCA,UAAUC,SAAS,CAACC,QAAQ,CAACE,kBAAkBjB,IAAI;QAGrD,IAAIa,WAAW;YACb,OAAOA,UAAUA,SAAS,CAAC;gBAAEQ,YAAYH;gBAAGrB;gBAAYoB;gBAAmBZ;YAAe;QAC5F;QAEAiB,QAAQC,IAAI,CACV,gEAAgEN,kBAAkBjB,IAAI;QAExF,OAAOW,kBAAkBE,UAAU;YACjCQ,YAAYH;YACZrB;YACAoB;YACAZ;QACF;IACF,MAAM,EAAE;AAEZ;AAEA,OAAO,SAASc,qBACdtB,UAAwC,EACxC2B,IAA2B;IAE3B,OAAO;QACL,GAAGA,IAAI;QACPxB,MAAM;QAENC,UAAUC,mCAAmC;YAC3CL;YACAM,oBAAoB,AAACqB,KAAavB,QAAQ,IAAI,EAAE;YAChDI,gBAAgB;QAClB;QACAI,SAAS;IACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAA2B;IACzD,OAAOA;AACT"}
+{"version":3,"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/index.ts"],"sourcesContent":["import type {\n  SerializedEditorState,\n  SerializedLexicalNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n} from 'lexical'\n\nimport type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './types.js'\n\nexport function convertLexicalPluginToLexical({\n  converters,\n  lexicalPluginData,\n  quiet,\n}: {\n  converters: LexicalPluginNodeConverter[]\n  lexicalPluginData: PayloadPluginLexicalData\n  quiet?: boolean\n}): SerializedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginData?.jsonContent?.root?.children || [],\n        parentNodeType: 'root',\n        quiet,\n      }),\n      direction: lexicalPluginData?.jsonContent?.root?.direction || 'ltr',\n      format: lexicalPluginData?.jsonContent?.root?.format || '',\n      indent: lexicalPluginData?.jsonContent?.root?.indent || 0,\n      version: 1,\n    },\n  }\n}\n\nexport function convertLexicalPluginNodesToLexical({\n  converters,\n  lexicalPluginNodes,\n  parentNodeType,\n  quiet,\n}: {\n  converters: LexicalPluginNodeConverter[]\n  lexicalPluginNodes: SerializedLexicalNode[] | undefined\n  /**\n   * Type of the parent lexical node (not the type of the original, parent payload-plugin-lexical type)\n   */\n  parentNodeType: string\n  quiet?: boolean\n}): SerializedLexicalNode[] {\n  if (!lexicalPluginNodes?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  return (\n    lexicalPluginNodes.map((lexicalPluginNode, i) => {\n      if (lexicalPluginNode.type === 'paragraph') {\n        return convertParagraphNode(converters, lexicalPluginNode, quiet)\n      }\n      if (lexicalPluginNode.type === 'text' || !lexicalPluginNode.type) {\n        return convertTextNode(lexicalPluginNode)\n      }\n\n      const converter = converters.find((converter) =>\n        converter.nodeTypes.includes(lexicalPluginNode.type),\n      )\n\n      if (converter) {\n        return converter.converter({\n          childIndex: i,\n          converters,\n          lexicalPluginNode,\n          parentNodeType,\n          quiet,\n        })\n      }\n\n      if (!quiet) {\n        console.warn(\n          'lexicalPluginToLexical > No converter found for node type: ' + lexicalPluginNode.type,\n        )\n      }\n\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        lexicalPluginNode,\n        parentNodeType,\n        quiet,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: LexicalPluginNodeConverter[],\n  node: SerializedLexicalNode,\n  quiet?: boolean,\n): SerializedParagraphNode {\n  return {\n    ...node,\n    type: 'paragraph',\n\n    children: convertLexicalPluginNodesToLexical({\n      converters,\n      lexicalPluginNodes: (node as any).children || [],\n      parentNodeType: 'paragraph',\n      quiet,\n    }),\n    version: 1,\n  } as SerializedParagraphNode\n}\nexport function convertTextNode(node: SerializedLexicalNode): SerializedTextNode {\n  return node as SerializedTextNode\n}\n"],"names":["convertLexicalPluginToLexical","converters","lexicalPluginData","quiet","root","type","children","convertLexicalPluginNodesToLexical","lexicalPluginNodes","jsonContent","parentNodeType","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","map","lexicalPluginNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node"],"mappings":"AASA,OAAO,SAASA,8BAA8B,EAC5CC,UAAU,EACVC,iBAAiB,EACjBC,KAAK,EAKN;IACC,OAAO;QACLC,MAAM;YACJC,MAAM;YACNC,UAAUC,mCAAmC;gBAC3CN;gBACAO,oBAAoBN,mBAAmBO,aAAaL,MAAME,YAAY,EAAE;gBACxEI,gBAAgB;gBAChBP;YACF;YACAQ,WAAWT,mBAAmBO,aAAaL,MAAMO,aAAa;YAC9DC,QAAQV,mBAAmBO,aAAaL,MAAMQ,UAAU;YACxDC,QAAQX,mBAAmBO,aAAaL,MAAMS,UAAU;YACxDC,SAAS;QACX;IACF;AACF;AAEA,OAAO,SAASP,mCAAmC,EACjDN,UAAU,EACVO,kBAAkB,EAClBE,cAAc,EACdP,KAAK,EASN;IACC,IAAI,CAACK,oBAAoBO,QAAQ;QAC/B,OAAO,EAAE;IACX;IACA,MAAMC,mBAAmBf,WAAWgB,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IACrF,OACEZ,mBAAmBa,GAAG,CAAC,CAACC,mBAAmBC;QACzC,IAAID,kBAAkBjB,IAAI,KAAK,aAAa;YAC1C,OAAOmB,qBAAqBvB,YAAYqB,mBAAmBnB;QAC7D;QACA,IAAImB,kBAAkBjB,IAAI,KAAK,UAAU,CAACiB,kBAAkBjB,IAAI,EAAE;YAChE,OAAOoB,gBAAgBH;QACzB;QAEA,MAAMJ,YAAYjB,WAAWgB,IAAI,CAAC,CAACC,YACjCA,UAAUC,SAAS,CAACC,QAAQ,CAACE,kBAAkBjB,IAAI;QAGrD,IAAIa,WAAW;YACb,OAAOA,UAAUA,SAAS,CAAC;gBACzBQ,YAAYH;gBACZtB;gBACAqB;gBACAZ;gBACAP;YACF;QACF;QAEA,IAAI,CAACA,OAAO;YACVwB,QAAQC,IAAI,CACV,gEAAgEN,kBAAkBjB,IAAI;QAE1F;QAEA,OAAOW,kBAAkBE,UAAU;YACjCQ,YAAYH;YACZtB;YACAqB;YACAZ;YACAP;QACF;IACF,MAAM,EAAE;AAEZ;AAEA,OAAO,SAASqB,qBACdvB,UAAwC,EACxC4B,IAA2B,EAC3B1B,KAAe;IAEf,OAAO;QACL,GAAG0B,IAAI;QACPxB,MAAM;QAENC,UAAUC,mCAAmC;YAC3CN;YACAO,oBAAoB,AAACqB,KAAavB,QAAQ,IAAI,EAAE;YAChDI,gBAAgB;YAChBP;QACF;QACAW,SAAS;IACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAA2B;IACzD,OAAOA;AACT"}

package/dist/features/migrations/lexicalPluginToLexical/converter/types.d.ts

@@ -1,5 +1,4 @@
 import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
-import type React from 'react';
 export type LexicalPluginNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
     converter: ({ childIndex, converters, lexicalPluginNode, parentNodeType, }: {
         childIndex: number;
@@ -8,6 +7,7 @@ export type LexicalPluginNodeConverter<T extends SerializedLexicalNode = Seriali
             children?: SerializedLexicalNode[];
         } & SerializedLexicalNode;
         parentNodeType: string;
+        quiet?: boolean;
     }) => T;
     nodeTypes: string[];
 };
@@ -20,12 +20,4 @@ export type PayloadPluginLexicalData = {
     preview: string;
     words: number;
 };
-export type LexicalPluginNodeConverterClientComponent = React.FC<{
-    componentKey: string;
-    featureKey: string;
-}>;
-export type LexicalPluginNodeConverterProvider = {
-    ClientConverter: LexicalPluginNodeConverterClientComponent;
-    converter: LexicalPluginNodeConverter;
-};
 //# sourceMappingURL=types.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/converter/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAC3E,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IAChG,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,cAAc,GACf,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,0BAA0B,EAAE,CAAA;QACxC,iBAAiB,EAAE;YAAE,QAAQ,CAAC,EAAE,qBAAqB,EAAE,CAAA;SAAE,GAAG,qBAAqB,CAAA;QACjF,cAAc,EAAE,MAAM,CAAA;KACvB,KAAK,CAAC,CAAA;IACP,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,qBAAqB,CAAA;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,yCAAyC,GAAG,KAAK,CAAC,EAAE,CAAC;IAC/D,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAC,CAAA;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,eAAe,EAAE,yCAAyC,CAAA;IAC1D,SAAS,EAAE,0BAA0B,CAAA;CACtC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAE3E,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IAChG,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,cAAc,GACf,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,0BAA0B,EAAE,CAAA;QACxC,iBAAiB,EAAE;YAAE,QAAQ,CAAC,EAAE,qBAAqB,EAAE,CAAA;SAAE,GAAG,qBAAqB,CAAA;QACjF,cAAc,EAAE,MAAM,CAAA;QACtB,KAAK,CAAC,EAAE,OAAO,CAAA;KAChB,KAAK,CAAC,CAAA;IACP,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,qBAAqB,CAAA;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\nimport type React from 'react'\n\nexport type LexicalPluginNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    lexicalPluginNode,\n    parentNodeType,\n  }: {\n    childIndex: number\n    converters: LexicalPluginNodeConverter[]\n    lexicalPluginNode: { children?: SerializedLexicalNode[] } & SerializedLexicalNode\n    parentNodeType: string\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type PayloadPluginLexicalData = {\n  characters: number\n  comments: unknown[]\n  html?: string\n  jsonContent: SerializedEditorState\n  markdown?: string\n  preview: string\n  words: number\n}\n\nexport type LexicalPluginNodeConverterClientComponent = React.FC<{\n  componentKey: string\n  featureKey: string\n}>\n\nexport type LexicalPluginNodeConverterProvider = {\n  ClientConverter: LexicalPluginNodeConverterClientComponent\n  converter: LexicalPluginNodeConverter\n}\n"],"names":[],"mappings":"AAiCA,WAGC"}
+{"version":3,"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nexport type LexicalPluginNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    lexicalPluginNode,\n    parentNodeType,\n  }: {\n    childIndex: number\n    converters: LexicalPluginNodeConverter[]\n    lexicalPluginNode: { children?: SerializedLexicalNode[] } & SerializedLexicalNode\n    parentNodeType: string\n    quiet?: boolean\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type PayloadPluginLexicalData = {\n  characters: number\n  comments: unknown[]\n  html?: string\n  jsonContent: SerializedEditorState\n  markdown?: string\n  preview: string\n  words: number\n}\n"],"names":[],"mappings":"AAkBA,WAQC"}

package/dist/features/migrations/lexicalPluginToLexical/feature.client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"names":[],"mappings":"AAQA,eAAO,MAAM,mCAAmC;;;EAoB9C,CAAA"}
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"names":[],"mappings":"AAKA,eAAO,MAAM,mCAAmC;;;EAI9C,CAAA"}

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

@@ -1,23 +1,8 @@
 'use client';
 import { createClientFeature } from '../../../utilities/createClientFeature.js';
-import { convertLexicalPluginToLexical } from './converter/index.js';
 import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
-export const LexicalPluginToLexicalFeatureClient = createClientFeature(({ clientFunctions })=>{
-    const converters = Object.values(clientFunctions);
+export const LexicalPluginToLexicalFeatureClient = createClientFeature(()=>{
     return {
-        hooks: {
-            load ({ incomingEditorState }) {
-                if (!incomingEditorState || !('jsonContent' in incomingEditorState)) {
-                    // incomingEditorState null or not from Lexical Plugin
-                    return incomingEditorState;
-                }
-                // Lexical Plugin => convert to lexical
-                return convertLexicalPluginToLexical({
-                    converters,
-                    lexicalPluginData: incomingEditorState
-                });
-            }
-        },
         nodes: [
             UnknownConvertedNode
         ]

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './converter/types.js'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { convertLexicalPluginToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const LexicalPluginToLexicalFeatureClient = createClientFeature(({ clientFunctions }) => {\n  const converters: LexicalPluginNodeConverter[] = Object.values(clientFunctions)\n\n  return {\n    hooks: {\n      load({ incomingEditorState }) {\n        if (!incomingEditorState || !('jsonContent' in incomingEditorState)) {\n          // incomingEditorState null or not from Lexical Plugin\n          return incomingEditorState\n        }\n        // Lexical Plugin => convert to lexical\n\n        return convertLexicalPluginToLexical({\n          converters,\n          lexicalPluginData: incomingEditorState as unknown as PayloadPluginLexicalData,\n        })\n      },\n    },\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"names":["createClientFeature","convertLexicalPluginToLexical","UnknownConvertedNode","LexicalPluginToLexicalFeatureClient","clientFunctions","converters","Object","values","hooks","load","incomingEditorState","lexicalPluginData","nodes"],"mappings":"AAAA;AAIA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,6BAA6B,QAAQ,uBAAsB;AACpE,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,OAAO,MAAMC,sCAAsCH,oBAAoB,CAAC,EAAEI,eAAe,EAAE;IACzF,MAAMC,aAA2CC,OAAOC,MAAM,CAACH;IAE/D,OAAO;QACLI,OAAO;YACLC,MAAK,EAAEC,mBAAmB,EAAE;gBAC1B,IAAI,CAACA,uBAAuB,CAAE,CAAA,iBAAiBA,mBAAkB,GAAI;oBACnE,sDAAsD;oBACtD,OAAOA;gBACT;gBACA,uCAAuC;gBAEvC,OAAOT,8BAA8B;oBACnCI;oBACAM,mBAAmBD;gBACrB;YACF;QACF;QACAE,OAAO;YAACV;SAAqB;IAC/B;AACF,GAAE"}
+{"version":3,"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const LexicalPluginToLexicalFeatureClient = createClientFeature(() => {\n  return {\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"names":["createClientFeature","UnknownConvertedNode","LexicalPluginToLexicalFeatureClient","nodes"],"mappings":"AAAA;AAEA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,OAAO,MAAMC,sCAAsCF,oBAAoB;IACrE,OAAO;QACLG,OAAO;YAACF;SAAqB;IAC/B;AACF,GAAE"}

package/dist/features/migrations/lexicalPluginToLexical/feature.server.d.ts

@@ -1,8 +1,9 @@
-import type { LexicalPluginNodeConverterProvider } from './converter/types.js';
+import type { LexicalPluginNodeConverter } from './converter/types.js';
 export type LexicalPluginToLexicalFeatureProps = {
     converters?: (({ defaultConverters, }: {
-        defaultConverters: LexicalPluginNodeConverterProvider[];
-    }) => LexicalPluginNodeConverterProvider[]) | LexicalPluginNodeConverterProvider[];
+        defaultConverters: LexicalPluginNodeConverter[];
+    }) => LexicalPluginNodeConverter[]) | LexicalPluginNodeConverter[];
+    quiet?: boolean;
 };
 export declare const LexicalPluginToLexicalFeature: import("../../typesServer.js").FeatureProviderProviderServer<LexicalPluginToLexicalFeatureProps, LexicalPluginToLexicalFeatureProps, undefined>;
 //# sourceMappingURL=feature.server.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/feature.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,sBAAsB,CAAA;AAQ9E,MAAM,MAAM,kCAAkC,GAAG;IAC/C,UAAU,CAAC,EACP,CAAC,CAAC,EACA,iBAAiB,GAClB,EAAE;QACD,iBAAiB,EAAE,kCAAkC,EAAE,CAAA;KACxD,KAAK,kCAAkC,EAAE,CAAC,GAC3C,kCAAkC,EAAE,CAAA;CACzC,CAAA;AAED,eAAO,MAAM,6BAA6B,iJA4CtC,CAAA"}
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAA4B,MAAM,sBAAsB,CAAA;AAOhG,MAAM,MAAM,kCAAkC,GAAG;IAC/C,UAAU,CAAC,EACP,CAAC,CAAC,EACA,iBAAiB,GAClB,EAAE;QACD,iBAAiB,EAAE,0BAA0B,EAAE,CAAA;KAChD,KAAK,0BAA0B,EAAE,CAAC,GACnC,0BAA0B,EAAE,CAAA;IAChC,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,6BAA6B,iJA+CtC,CAAA"}

package/dist/features/migrations/lexicalPluginToLexical/feature.server.js

@@ -1,7 +1,6 @@
-// eslint-disable-next-line payload/no-imports-from-exports-dir
-import { LexicalPluginToLexicalFeatureClient } from '../../../exports/client/index.js';
 import { createServerFeature } from '../../../utilities/createServerFeature.js';
 import { defaultConverters } from './converter/defaultConverters.js';
+import { convertLexicalPluginToLexical } from './converter/index.js';
 import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
 export const LexicalPluginToLexicalFeature = createServerFeature({
     feature: ({ props })=>{
@@ -20,16 +19,22 @@ export const LexicalPluginToLexicalFeature = createServerFeature({
         }
         props.converters = converters;
         return {
-            ClientFeature: LexicalPluginToLexicalFeatureClient,
-            generateComponentMap: ()=>{
-                const map = {};
-                for (const converter of converters){
-                    if (converter.ClientConverter) {
-                        const key = converter.converter.nodeTypes.join('-');
-                        map[key] = converter.ClientConverter;
+            ClientFeature: '@payloadcms/richtext-lexical/client#LexicalPluginToLexicalFeatureClient',
+            hooks: {
+                afterRead: [
+                    ({ value })=>{
+                        if (!value || !('jsonContent' in value)) {
+                            // incomingEditorState null or not from Lexical Plugin
+                            return value;
+                        }
+                        // Lexical Plugin => convert to lexical
+                        return convertLexicalPluginToLexical({
+                            converters: props.converters,
+                            lexicalPluginData: value,
+                            quiet: props?.quiet
+                        });
                     }
-                }
-                return map;
+                ]
             },
             nodes: [
                 {

package/dist/features/migrations/lexicalPluginToLexical/feature.server.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.server.ts"],"sourcesContent":["import type React from 'react'\n\nimport type { LexicalPluginNodeConverterProvider } from './converter/types.js'\n\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { LexicalPluginToLexicalFeatureClient } from '../../../exports/client/index.js'\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\nimport { defaultConverters } from './converter/defaultConverters.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type LexicalPluginToLexicalFeatureProps = {\n  converters?:\n    | (({\n        defaultConverters,\n      }: {\n        defaultConverters: LexicalPluginNodeConverterProvider[]\n      }) => LexicalPluginNodeConverterProvider[])\n    | LexicalPluginNodeConverterProvider[]\n}\n\nexport const LexicalPluginToLexicalFeature =\n  createServerFeature<LexicalPluginToLexicalFeatureProps>({\n    feature: ({ props }) => {\n      if (!props) {\n        props = {}\n      }\n\n      let converters: LexicalPluginNodeConverterProvider[] = []\n\n      if (props?.converters && typeof props?.converters === 'function') {\n        converters = props.converters({ defaultConverters })\n      } else if (props.converters && typeof props?.converters !== 'function') {\n        converters = props.converters\n      } else {\n        converters = defaultConverters\n      }\n\n      props.converters = converters\n\n      return {\n        ClientFeature: LexicalPluginToLexicalFeatureClient,\n        generateComponentMap: () => {\n          const map: {\n            [key: string]: React.FC\n          } = {}\n\n          for (const converter of converters) {\n            if (converter.ClientConverter) {\n              const key = converter.converter.nodeTypes.join('-')\n              map[key] = converter.ClientConverter\n            }\n          }\n\n          return map\n        },\n        nodes: [\n          {\n            node: UnknownConvertedNode,\n          },\n        ],\n        sanitizedServerFeatureProps: props,\n      }\n    },\n    key: 'lexicalPluginToLexical',\n  })\n"],"names":["LexicalPluginToLexicalFeatureClient","createServerFeature","defaultConverters","UnknownConvertedNode","LexicalPluginToLexicalFeature","feature","props","converters","ClientFeature","generateComponentMap","map","converter","ClientConverter","key","nodeTypes","join","nodes","node","sanitizedServerFeatureProps"],"mappings":"AAIA,+DAA+D;AAC/D,SAASA,mCAAmC,QAAQ,mCAAkC;AACtF,SAASC,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,iBAAiB,QAAQ,mCAAkC;AACpE,SAASC,oBAAoB,QAAQ,wCAAuC;AAY5E,OAAO,MAAMC,gCACXH,oBAAwD;IACtDI,SAAS,CAAC,EAAEC,KAAK,EAAE;QACjB,IAAI,CAACA,OAAO;YACVA,QAAQ,CAAC;QACX;QAEA,IAAIC,aAAmD,EAAE;QAEzD,IAAID,OAAOC,cAAc,OAAOD,OAAOC,eAAe,YAAY;YAChEA,aAAaD,MAAMC,UAAU,CAAC;gBAAEL;YAAkB;QACpD,OAAO,IAAII,MAAMC,UAAU,IAAI,OAAOD,OAAOC,eAAe,YAAY;YACtEA,aAAaD,MAAMC,UAAU;QAC/B,OAAO;YACLA,aAAaL;QACf;QAEAI,MAAMC,UAAU,GAAGA;QAEnB,OAAO;YACLC,eAAeR;YACfS,sBAAsB;gBACpB,MAAMC,MAEF,CAAC;gBAEL,KAAK,MAAMC,aAAaJ,WAAY;oBAClC,IAAII,UAAUC,eAAe,EAAE;wBAC7B,MAAMC,MAAMF,UAAUA,SAAS,CAACG,SAAS,CAACC,IAAI,CAAC;wBAC/CL,GAAG,CAACG,IAAI,GAAGF,UAAUC,eAAe;oBACtC;gBACF;gBAEA,OAAOF;YACT;YACAM,OAAO;gBACL;oBACEC,MAAMd;gBACR;aACD;YACDe,6BAA6BZ;QAC/B;IACF;IACAO,KAAK;AACP,GAAE"}
+{"version":3,"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.server.ts"],"sourcesContent":["import type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './converter/types.js'\n\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\nimport { defaultConverters } from './converter/defaultConverters.js'\nimport { convertLexicalPluginToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type LexicalPluginToLexicalFeatureProps = {\n  converters?:\n    | (({\n        defaultConverters,\n      }: {\n        defaultConverters: LexicalPluginNodeConverter[]\n      }) => LexicalPluginNodeConverter[])\n    | LexicalPluginNodeConverter[]\n  quiet?: boolean\n}\n\nexport const LexicalPluginToLexicalFeature =\n  createServerFeature<LexicalPluginToLexicalFeatureProps>({\n    feature: ({ props }) => {\n      if (!props) {\n        props = {}\n      }\n\n      let converters: LexicalPluginNodeConverter[] = []\n\n      if (props?.converters && typeof props?.converters === 'function') {\n        converters = props.converters({ defaultConverters })\n      } else if (props.converters && typeof props?.converters !== 'function') {\n        converters = props.converters\n      } else {\n        converters = defaultConverters\n      }\n\n      props.converters = converters\n\n      return {\n        ClientFeature: '@payloadcms/richtext-lexical/client#LexicalPluginToLexicalFeatureClient',\n        hooks: {\n          afterRead: [\n            ({ value }) => {\n              if (!value || !('jsonContent' in value)) {\n                // incomingEditorState null or not from Lexical Plugin\n                return value\n              }\n\n              // Lexical Plugin => convert to lexical\n              return convertLexicalPluginToLexical({\n                converters: props.converters as LexicalPluginNodeConverter[],\n                lexicalPluginData: value as PayloadPluginLexicalData,\n                quiet: props?.quiet,\n              })\n            },\n          ],\n        },\n        nodes: [\n          {\n            node: UnknownConvertedNode,\n          },\n        ],\n        sanitizedServerFeatureProps: props,\n      }\n    },\n    key: 'lexicalPluginToLexical',\n  })\n"],"names":["createServerFeature","defaultConverters","convertLexicalPluginToLexical","UnknownConvertedNode","LexicalPluginToLexicalFeature","feature","props","converters","ClientFeature","hooks","afterRead","value","lexicalPluginData","quiet","nodes","node","sanitizedServerFeatureProps","key"],"mappings":"AAEA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,iBAAiB,QAAQ,mCAAkC;AACpE,SAASC,6BAA6B,QAAQ,uBAAsB;AACpE,SAASC,oBAAoB,QAAQ,wCAAuC;AAa5E,OAAO,MAAMC,gCACXJ,oBAAwD;IACtDK,SAAS,CAAC,EAAEC,KAAK,EAAE;QACjB,IAAI,CAACA,OAAO;YACVA,QAAQ,CAAC;QACX;QAEA,IAAIC,aAA2C,EAAE;QAEjD,IAAID,OAAOC,cAAc,OAAOD,OAAOC,eAAe,YAAY;YAChEA,aAAaD,MAAMC,UAAU,CAAC;gBAAEN;YAAkB;QACpD,OAAO,IAAIK,MAAMC,UAAU,IAAI,OAAOD,OAAOC,eAAe,YAAY;YACtEA,aAAaD,MAAMC,UAAU;QAC/B,OAAO;YACLA,aAAaN;QACf;QAEAK,MAAMC,UAAU,GAAGA;QAEnB,OAAO;YACLC,eAAe;YACfC,OAAO;gBACLC,WAAW;oBACT,CAAC,EAAEC,KAAK,EAAE;wBACR,IAAI,CAACA,SAAS,CAAE,CAAA,iBAAiBA,KAAI,GAAI;4BACvC,sDAAsD;4BACtD,OAAOA;wBACT;wBAEA,uCAAuC;wBACvC,OAAOT,8BAA8B;4BACnCK,YAAYD,MAAMC,UAAU;4BAC5BK,mBAAmBD;4BACnBE,OAAOP,OAAOO;wBAChB;oBACF;iBACD;YACH;YACAC,OAAO;gBACL;oBACEC,MAAMZ;gBACR;aACD;YACDa,6BAA6BV;QAC/B;IACF;IACAW,KAAK;AACP,GAAE"}

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/converter.d.ts

@@ -1,3 +1,3 @@
 import type { SlateNodeConverter } from '../../types.js';
-export declare const _SlateBlockquoteConverter: SlateNodeConverter;
+export declare const SlateBlockquoteConverter: SlateNodeConverter;
 //# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,yBAAyB,EAAE,kBAiBvC,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,wBAAwB,EAAE,kBAiBtC,CAAA"}

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

@@ -1,5 +1,5 @@
 import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateBlockquoteConverter = {
+export const SlateBlockquoteConverter = {
     converter ({ converters, slateNode }) {
         return {
             type: 'quote',

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '../../../../../blockquote/feature.server.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const _SlateBlockquoteConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'quote',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'quote',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    } as const as SerializedQuoteNode\n  },\n  nodeTypes: ['blockquote'],\n}\n"],"names":["convertSlateNodesToLexical","_SlateBlockquoteConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,4BAAgD;IAC3DC,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,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAa;AAC3B,EAAC"}
+{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '../../../../../blockquote/server/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateBlockquoteConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'quote',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'quote',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    } as const as SerializedQuoteNode\n  },\n  nodeTypes: ['blockquote'],\n}\n"],"names":["convertSlateNodesToLexical","SlateBlockquoteConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,2BAA+C;IAC1DC,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,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAa;AAC3B,EAAC"}

package/dist/features/migrations/slateToLexical/converter/converters/heading/converter.d.ts

@@ -1,3 +1,3 @@
 import type { SlateNodeConverter } from '../../types.js';
-export declare const _SlateHeadingConverter: SlateNodeConverter;
+export declare const SlateHeadingConverter: SlateNodeConverter;
 //# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/heading/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,sBAAsB,EAAE,kBAkBpC,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,qBAAqB,EAAE,kBAkBnC,CAAA"}

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

@@ -1,5 +1,5 @@
 import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateHeadingConverter = {
+export const SlateHeadingConverter = {
     converter ({ converters, slateNode }) {
         return {
             type: 'heading',

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '../../../../../heading/feature.server.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const _SlateHeadingConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'heading',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'heading',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      tag: slateNode.type as 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6', // Slate puts the tag (h1 / h2 / ...) inside of node.type\n      version: 1,\n    } as const as SerializedHeadingNode\n  },\n  nodeTypes: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],\n}\n"],"names":["convertSlateNodesToLexical","_SlateHeadingConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","tag","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,yBAA6C;IACxDC,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,KAAKT,UAAUC,IAAI;YACnBS,SAAS;QACX;IACF;IACAC,WAAW;QAAC;QAAM;QAAM;QAAM;QAAM;QAAM;KAAK;AACjD,EAAC"}
+{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '../../../../../heading/server/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateHeadingConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'heading',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'heading',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      tag: slateNode.type as 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6', // Slate puts the tag (h1 / h2 / ...) inside of node.type\n      version: 1,\n    } as const as SerializedHeadingNode\n  },\n  nodeTypes: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],\n}\n"],"names":["convertSlateNodesToLexical","SlateHeadingConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","tag","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,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,KAAKT,UAAUC,IAAI;YACnBS,SAAS;QACX;IACF;IACAC,WAAW;QAAC;QAAM;QAAM;QAAM;QAAM;QAAM;KAAK;AACjD,EAAC"}

package/dist/features/migrations/slateToLexical/converter/converters/indent/converter.d.ts

@@ -1,3 +1,3 @@
 import type { SlateNodeConverter } from '../../types.js';
-export declare const _SlateIndentConverter: SlateNodeConverter;
+export declare const SlateIndentConverter: SlateNodeConverter;
 //# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/indent/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/converter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,qBAAqB,EAAE,kBAgCnC,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/converter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,oBAAoB,EAAE,kBAgClC,CAAA"}

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

@@ -1,5 +1,5 @@
 import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateIndentConverter = {
+export const SlateIndentConverter = {
     converter ({ converters, slateNode }) {
         const convertChildren = (node, indentLevel = 0)=>{
             if (node?.type && (!node.children || node.type !== 'indent') || !node?.type && node?.text) {

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/converter.ts"],"sourcesContent":["import type { SerializedLexicalNode, SerializedParagraphNode } from 'lexical'\n\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const _SlateIndentConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    const convertChildren = (node: any, indentLevel: number = 0): SerializedLexicalNode => {\n      if (\n        (node?.type && (!node.children || node.type !== 'indent')) ||\n        (!node?.type && node?.text)\n      ) {\n        return {\n          ...convertSlateNodesToLexical({\n            canContainParagraphs: false,\n            converters,\n            parentNodeType: 'indent',\n            slateNodes: [node],\n          })[0],\n          indent: indentLevel,\n        } as const as SerializedLexicalNode\n      }\n\n      const children = node.children.map((child: any) => convertChildren(child, indentLevel + 1))\n      return {\n        type: 'paragraph',\n        children,\n        direction: 'ltr',\n        format: '',\n        indent: indentLevel,\n        version: 1,\n      } as const as SerializedParagraphNode\n    }\n\n    return convertChildren(slateNode)\n  },\n  nodeTypes: ['indent'],\n}\n"],"names":["convertSlateNodesToLexical","_SlateIndentConverter","converter","converters","slateNode","convertChildren","node","indentLevel","type","children","text","canContainParagraphs","parentNodeType","slateNodes","indent","map","child","direction","format","version","nodeTypes"],"mappings":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,wBAA4C;IACvDC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,MAAMC,kBAAkB,CAACC,MAAWC,cAAsB,CAAC;YACzD,IACE,AAACD,MAAME,QAAS,CAAA,CAACF,KAAKG,QAAQ,IAAIH,KAAKE,IAAI,KAAK,QAAO,KACtD,CAACF,MAAME,QAAQF,MAAMI,MACtB;gBACA,OAAO;oBACL,GAAGV,2BAA2B;wBAC5BW,sBAAsB;wBACtBR;wBACAS,gBAAgB;wBAChBC,YAAY;4BAACP;yBAAK;oBACpB,EAAE,CAAC,EAAE;oBACLQ,QAAQP;gBACV;YACF;YAEA,MAAME,WAAWH,KAAKG,QAAQ,CAACM,GAAG,CAAC,CAACC,QAAeX,gBAAgBW,OAAOT,cAAc;YACxF,OAAO;gBACLC,MAAM;gBACNC;gBACAQ,WAAW;gBACXC,QAAQ;gBACRJ,QAAQP;gBACRY,SAAS;YACX;QACF;QAEA,OAAOd,gBAAgBD;IACzB;IACAgB,WAAW;QAAC;KAAS;AACvB,EAAC"}
+{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/converter.ts"],"sourcesContent":["import type { SerializedLexicalNode, SerializedParagraphNode } from 'lexical'\n\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateIndentConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    const convertChildren = (node: any, indentLevel: number = 0): SerializedLexicalNode => {\n      if (\n        (node?.type && (!node.children || node.type !== 'indent')) ||\n        (!node?.type && node?.text)\n      ) {\n        return {\n          ...convertSlateNodesToLexical({\n            canContainParagraphs: false,\n            converters,\n            parentNodeType: 'indent',\n            slateNodes: [node],\n          })[0],\n          indent: indentLevel,\n        } as const as SerializedLexicalNode\n      }\n\n      const children = node.children.map((child: any) => convertChildren(child, indentLevel + 1))\n      return {\n        type: 'paragraph',\n        children,\n        direction: 'ltr',\n        format: '',\n        indent: indentLevel,\n        version: 1,\n      } as const as SerializedParagraphNode\n    }\n\n    return convertChildren(slateNode)\n  },\n  nodeTypes: ['indent'],\n}\n"],"names":["convertSlateNodesToLexical","SlateIndentConverter","converter","converters","slateNode","convertChildren","node","indentLevel","type","children","text","canContainParagraphs","parentNodeType","slateNodes","indent","map","child","direction","format","version","nodeTypes"],"mappings":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,uBAA2C;IACtDC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,MAAMC,kBAAkB,CAACC,MAAWC,cAAsB,CAAC;YACzD,IACE,AAACD,MAAME,QAAS,CAAA,CAACF,KAAKG,QAAQ,IAAIH,KAAKE,IAAI,KAAK,QAAO,KACtD,CAACF,MAAME,QAAQF,MAAMI,MACtB;gBACA,OAAO;oBACL,GAAGV,2BAA2B;wBAC5BW,sBAAsB;wBACtBR;wBACAS,gBAAgB;wBAChBC,YAAY;4BAACP;yBAAK;oBACpB,EAAE,CAAC,EAAE;oBACLQ,QAAQP;gBACV;YACF;YAEA,MAAME,WAAWH,KAAKG,QAAQ,CAACM,GAAG,CAAC,CAACC,QAAeX,gBAAgBW,OAAOT,cAAc;YACxF,OAAO;gBACLC,MAAM;gBACNC;gBACAQ,WAAW;gBACXC,QAAQ;gBACRJ,QAAQP;gBACRY,SAAS;YACX;QACF;QAEA,OAAOd,gBAAgBD;IACzB;IACAgB,WAAW;QAAC;KAAS;AACvB,EAAC"}

package/dist/features/migrations/slateToLexical/converter/converters/link/converter.d.ts

@@ -1,3 +1,3 @@
 import type { SlateNodeConverter } from '../../types.js';
-export declare const _SlateLinkConverter: SlateNodeConverter;
+export declare const SlateLinkConverter: SlateNodeConverter;
 //# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/link/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/link/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,mBAAmB,EAAE,kBAwBjC,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/link/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,kBAAkB,EAAE,kBAwBhC,CAAA"}

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

@@ -1,5 +1,5 @@
 import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateLinkConverter = {
+export const SlateLinkConverter = {
     converter ({ converters, slateNode }) {
         return {
             type: 'link',

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/link/converter.ts"],"sourcesContent":["import type { SerializedLinkNode } from '../../../../../link/nodes/types.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const _SlateLinkConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'link',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'link',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      fields: {\n        ...(slateNode.fields || {}),\n        doc: slateNode.doc || null,\n        linkType: slateNode.linkType || 'custom',\n        newTab: slateNode.newTab || false,\n        url: slateNode.url || undefined,\n      },\n      format: '',\n      indent: 0,\n      version: 2,\n    } as const as SerializedLinkNode\n  },\n  nodeTypes: ['link'],\n}\n"],"names":["convertSlateNodesToLexical","_SlateLinkConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","fields","doc","linkType","newTab","url","undefined","format","indent","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,sBAA0C;IACrDC,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;gBACN,GAAIP,UAAUO,MAAM,IAAI,CAAC,CAAC;gBAC1BC,KAAKR,UAAUQ,GAAG,IAAI;gBACtBC,UAAUT,UAAUS,QAAQ,IAAI;gBAChCC,QAAQV,UAAUU,MAAM,IAAI;gBAC5BC,KAAKX,UAAUW,GAAG,IAAIC;YACxB;YACAC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAO;AACrB,EAAC"}
+{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/link/converter.ts"],"sourcesContent":["import type { SerializedLinkNode } from '../../../../../link/nodes/types.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateLinkConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'link',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'link',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      fields: {\n        ...(slateNode.fields || {}),\n        doc: slateNode.doc || null,\n        linkType: slateNode.linkType || 'custom',\n        newTab: slateNode.newTab || false,\n        url: slateNode.url || undefined,\n      },\n      format: '',\n      indent: 0,\n      version: 2,\n    } as const as SerializedLinkNode\n  },\n  nodeTypes: ['link'],\n}\n"],"names":["convertSlateNodesToLexical","SlateLinkConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","fields","doc","linkType","newTab","url","undefined","format","indent","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,qBAAyC;IACpDC,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;gBACN,GAAIP,UAAUO,MAAM,IAAI,CAAC,CAAC;gBAC1BC,KAAKR,UAAUQ,GAAG,IAAI;gBACtBC,UAAUT,UAAUS,QAAQ,IAAI;gBAChCC,QAAQV,UAAUU,MAAM,IAAI;gBAC5BC,KAAKX,UAAUW,GAAG,IAAIC;YACxB;YACAC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAO;AACrB,EAAC"}

package/dist/features/migrations/slateToLexical/converter/converters/listItem/converter.d.ts

@@ -1,3 +1,3 @@
 import type { SlateNodeConverter } from '../../types.js';
-export declare const _SlateListItemConverter: SlateNodeConverter;
+export declare const SlateListItemConverter: SlateNodeConverter;
 //# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/listItem/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,uBAAuB,EAAE,kBAmBrC,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,sBAAsB,EAAE,kBAmBpC,CAAA"}

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

@@ -1,5 +1,5 @@
 import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateListItemConverter = {
+export const SlateListItemConverter = {
     converter ({ childIndex, converters, slateNode }) {
         return {
             type: 'listitem',

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const _SlateListItemConverter: SlateNodeConverter = {\n  converter({ childIndex, converters, slateNode }) {\n    return {\n      type: 'listitem',\n      checked: undefined,\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'listitem',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      value: childIndex + 1,\n      version: 1,\n    } as const as SerializedListItemNode\n  },\n  nodeTypes: ['li'],\n}\n"],"names":["convertSlateNodesToLexical","_SlateListItemConverter","converter","childIndex","converters","slateNode","type","checked","undefined","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","value","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,0BAA8C;IACzDC,WAAU,EAAEC,UAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QAC7C,OAAO;YACLC,MAAM;YACNC,SAASC;YACTC,UAAUT,2BAA2B;gBACnCU,sBAAsB;gBACtBN;gBACAO,gBAAgB;gBAChBC,YAAYP,UAAUI,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,OAAOb,aAAa;YACpBc,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAK;AACnB,EAAC"}
+{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateListItemConverter: SlateNodeConverter = {\n  converter({ childIndex, converters, slateNode }) {\n    return {\n      type: 'listitem',\n      checked: undefined,\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'listitem',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      value: childIndex + 1,\n      version: 1,\n    } as const as SerializedListItemNode\n  },\n  nodeTypes: ['li'],\n}\n"],"names":["convertSlateNodesToLexical","SlateListItemConverter","converter","childIndex","converters","slateNode","type","checked","undefined","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","value","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,yBAA6C;IACxDC,WAAU,EAAEC,UAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QAC7C,OAAO;YACLC,MAAM;YACNC,SAASC;YACTC,UAAUT,2BAA2B;gBACnCU,sBAAsB;gBACtBN;gBACAO,gBAAgB;gBAChBC,YAAYP,UAAUI,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,OAAOb,aAAa;YACpBc,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAK;AACnB,EAAC"}

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.d.ts

@@ -1,3 +1,3 @@
 import type { SlateNodeConverter } from '../../types.js';
-export declare const _SlateOrderedListConverter: SlateNodeConverter;
+export declare const SlateOrderedListConverter: SlateNodeConverter;
 //# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,0BAA0B,EAAE,kBAoBxC,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,yBAAyB,EAAE,kBAoBvC,CAAA"}

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

@@ -1,5 +1,5 @@
 import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateOrderedListConverter = {
+export const SlateOrderedListConverter = {
     converter ({ converters, slateNode }) {
         return {
             type: 'list',

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/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 _SlateOrderedListConverter: 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: 'number',\n      start: 1,\n      tag: 'ol',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ol'],\n}\n"],"names":["convertSlateNodesToLexical","_SlateOrderedListConverter","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,6BAAiD;IAC5DC,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,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/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 SlateOrderedListConverter: 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: 'number',\n      start: 1,\n      tag: 'ol',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ol'],\n}\n"],"names":["convertSlateNodesToLexical","SlateOrderedListConverter","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,4BAAgD;IAC3DC,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"}

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.d.ts

@@ -1,3 +1,3 @@
 import type { SlateNodeConverter } from '../../types.js';
-export declare const _SlateRelationshipConverter: SlateNodeConverter;
+export declare const SlateRelationshipConverter: SlateNodeConverter;
 //# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAExD,eAAO,MAAM,2BAA2B,EAAE,kBAWzC,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAExD,eAAO,MAAM,0BAA0B,EAAE,kBAWxC,CAAA"}

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

@@ -1,4 +1,4 @@
-export const _SlateRelationshipConverter = {
+export const SlateRelationshipConverter = {
     converter ({ slateNode }) {
         return {
             type: 'relationship',

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"sourcesContent":["import type { SerializedRelationshipNode } from '../../../../../relationship/nodes/RelationshipNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const _SlateRelationshipConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'relationship',\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode?.value?.id || '',\n      version: 2,\n    } as const as SerializedRelationshipNode\n  },\n  nodeTypes: ['relationship'],\n}\n"],"names":["_SlateRelationshipConverter","converter","slateNode","type","format","relationTo","value","id","version","nodeTypes"],"mappings":"AAGA,OAAO,MAAMA,8BAAkD;IAC7DC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;YACRC,YAAYH,UAAUG,UAAU;YAChCC,OAAOJ,WAAWI,OAAOC,MAAM;YAC/BC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAe;AAC7B,EAAC"}
+{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"sourcesContent":["import type { SerializedRelationshipNode } from '../../../../../relationship/server/nodes/RelationshipNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const SlateRelationshipConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'relationship',\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode?.value?.id || '',\n      version: 2,\n    } as const as SerializedRelationshipNode\n  },\n  nodeTypes: ['relationship'],\n}\n"],"names":["SlateRelationshipConverter","converter","slateNode","type","format","relationTo","value","id","version","nodeTypes"],"mappings":"AAGA,OAAO,MAAMA,6BAAiD;IAC5DC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;YACRC,YAAYH,UAAUG,UAAU;YAChCC,OAAOJ,WAAWI,OAAOC,MAAM;YAC/BC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAe;AAC7B,EAAC"}

package/dist/features/migrations/slateToLexical/converter/converters/unknown/converter.d.ts

@@ -1,3 +1,3 @@
 import type { SlateNodeConverter } from '../../types.js';
-export declare const _SlateUnknownConverter: SlateNodeConverter;
+export declare const SlateUnknownConverter: SlateNodeConverter;
 //# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/unknown/converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,sBAAsB,EAAE,kBAqBpC,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,qBAAqB,EAAE,kBAqBnC,CAAA"}

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

@@ -1,5 +1,5 @@
 import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateUnknownConverter = {
+export const SlateUnknownConverter = {
     converter ({ converters, slateNode }) {
         return {
             type: 'unknownConverted',

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,yBAA6C;IACxDC,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,"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"}