@payloadcms/richtext-lexical 3.0.0-alpha.60 → 3.0.0-alpha.62

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.ts"],"sourcesContent":["import type { SerializedUnknownConvertedNode } from '../../../nodes/unknownConvertedNode/index.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const _UnknownConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode }) {\n    return {\n      type: 'unknownConverted',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'unknownConverted',\n      }),\n      data: {\n        nodeData: lexicalPluginNode,\n        nodeType: lexicalPluginNode.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":["convertLexicalPluginNodesToLexical","_UnknownConverter","converter","converters","lexicalPluginNode","type","children","lexicalPluginNodes","parentNodeType","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"mappings":"AAGA,SAASA,kCAAkC,QAAQ,iBAAgB;AAEnE,OAAO,MAAMC,oBAAgD;IAC3DC,WAAU,EAAEC,UAAU,EAAEC,iBAAiB,EAAE;QACzC,OAAO;YACLC,MAAM;YACNC,UAAUN,mCAAmC;gBAC3CG;gBACAI,oBAAoBH,kBAAkBE,QAAQ;gBAC9CE,gBAAgB;YAClB;YACAC,MAAM;gBACJC,UAAUN;gBACVO,UAAUP,kBAAkBC,IAAI;YAClC;YACAO,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAU;AACxB,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.ts"],"sourcesContent":["import type { SerializedUnknownConvertedNode } from '../../../nodes/unknownConvertedNode/index.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const _UnknownConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode }) {\n    return {\n      type: 'unknownConverted',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'unknownConverted',\n      }),\n      data: {\n        nodeData: lexicalPluginNode,\n        nodeType: lexicalPluginNode.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":["convertLexicalPluginNodesToLexical","_UnknownConverter","converter","converters","lexicalPluginNode","type","children","lexicalPluginNodes","parentNodeType","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,SAASA,kCAAkC,QAAQ,iBAAgB;AAEnE,OAAO,MAAMC,oBAAgD;IAC3DC,WAAU,EAAEC,UAAU,EAAEC,iBAAiB,EAAE;QACzC,OAAO;YACLC,MAAM;YACNC,UAAUN,mCAAmC;gBAC3CG;gBACAI,oBAAoBH,kBAAkBE,QAAQ;gBAC9CE,gBAAgB;YAClB;YACAC,MAAM;gBACJC,UAAUN;gBACVO,UAAUP,kBAAkBC,IAAI;YAClC;YACAO,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAU;AACxB,EAAC"}

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/unknown/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/unknown/index.ts"],"sourcesContent":["import type { LexicalPluginNodeConverterProvider } from '../../types.js'\n\nimport { UnknownConverterClient } from './client.js'\nimport { _UnknownConverter } from './converter.js'\n\nexport const UnknownConverter: LexicalPluginNodeConverterProvider = {\n  ClientComponent: UnknownConverterClient,\n  converter: _UnknownConverter,\n}\n"],"names":["UnknownConverterClient","_UnknownConverter","UnknownConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,sBAAsB,QAAQ,cAAa;AACpD,SAASC,iBAAiB,QAAQ,iBAAgB;AAElD,OAAO,MAAMC,mBAAuD;IAClEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/unknown/index.ts"],"sourcesContent":["import type { LexicalPluginNodeConverterProvider } from '../../types.js'\n\nimport { UnknownConverterClient } from './client.js'\nimport { _UnknownConverter } from './converter.js'\n\nexport const UnknownConverter: LexicalPluginNodeConverterProvider = {\n  ClientComponent: UnknownConverterClient,\n  converter: _UnknownConverter,\n}\n"],"names":["UnknownConverterClient","_UnknownConverter","UnknownConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,sBAAsB,QAAQ,cAAa;AACpD,SAASC,iBAAiB,QAAQ,iBAAgB;AAElD,OAAO,MAAMC,mBAAuD;IAClEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/client.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _UploadConverter } from './converter.js'\n\nexport const UploadConverterClient = createFeaturePropComponent(_UploadConverter)\n"],"names":["createFeaturePropComponent","_UploadConverter","UploadConverterClient"],"mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,gBAAgB,QAAQ,iBAAgB;AAEjD,OAAO,MAAMC,wBAAwBF,2BAA2BC,kBAAiB"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _UploadConverter } from './converter.js'\n\nexport const UploadConverterClient = createFeaturePropComponent(_UploadConverter)\n"],"names":["createFeaturePropComponent","_UploadConverter","UploadConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,gBAAgB,QAAQ,iBAAgB;AAEjD,OAAO,MAAMC,wBAAwBF,2BAA2BC,kBAAiB"}

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedUploadNode } from '../../../../../upload/nodes/UploadNode.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nexport const _UploadConverter: LexicalPluginNodeConverter = {\n  converter({ lexicalPluginNode }) {\n    let fields = {}\n    if ((lexicalPluginNode as any)?.caption?.editorState) {\n      fields = {\n        caption: (lexicalPluginNode as any)?.caption,\n      }\n    }\n    return {\n      type: 'upload',\n      fields,\n      format: (lexicalPluginNode as any)?.format || '',\n      relationTo: (lexicalPluginNode as any)?.rawImagePayload?.relationTo,\n      value: {\n        id: (lexicalPluginNode as any)?.rawImagePayload?.value?.id || '',\n      },\n      version: 1,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"names":["_UploadConverter","converter","lexicalPluginNode","fields","caption","editorState","type","format","relationTo","rawImagePayload","value","id","version","nodeTypes"],"mappings":"AAAA,qDAAqD,GAKrD,OAAO,MAAMA,mBAA+C;IAC1DC,WAAU,EAAEC,iBAAiB,EAAE;QAC7B,IAAIC,SAAS,CAAC;QACd,IAAKD,mBAA2BE,SAASC,aAAa;YACpDF,SAAS;gBACPC,SAAUF,mBAA2BE;YACvC;QACF;QACA,OAAO;YACLE,MAAM;YACNH;YACAI,QAAQ,AAACL,mBAA2BK,UAAU;YAC9CC,YAAaN,mBAA2BO,iBAAiBD;YACzDE,OAAO;gBACLC,IAAI,AAACT,mBAA2BO,iBAAiBC,OAAOC,MAAM;YAChE;YACAC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedUploadNode } from '../../../../../upload/nodes/UploadNode.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nexport const _UploadConverter: LexicalPluginNodeConverter = {\n  converter({ lexicalPluginNode }) {\n    let fields = {}\n    if ((lexicalPluginNode as any)?.caption?.editorState) {\n      fields = {\n        caption: (lexicalPluginNode as any)?.caption,\n      }\n    }\n    return {\n      type: 'upload',\n      fields,\n      format: (lexicalPluginNode as any)?.format || '',\n      relationTo: (lexicalPluginNode as any)?.rawImagePayload?.relationTo,\n      value: {\n        id: (lexicalPluginNode as any)?.rawImagePayload?.value?.id || '',\n      },\n      version: 1,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"names":["_UploadConverter","converter","lexicalPluginNode","fields","caption","editorState","type","format","relationTo","rawImagePayload","value","id","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,qDAAqD,GAKrD,OAAO,MAAMA,mBAA+C;IAC1DC,WAAU,EAAEC,iBAAiB,EAAE;QAC7B,IAAIC,SAAS,CAAC;QACd,IAAKD,mBAA2BE,SAASC,aAAa;YACpDF,SAAS;gBACPC,SAAUF,mBAA2BE;YACvC;QACF;QACA,OAAO;YACLE,MAAM;YACNH;YACAI,QAAQ,AAACL,mBAA2BK,UAAU;YAC9CC,YAAaN,mBAA2BO,iBAAiBD;YACzDE,OAAO;gBACLC,IAAI,AAACT,mBAA2BO,iBAAiBC,OAAOC,MAAM;YAChE;YACAC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/index.ts"],"sourcesContent":["import type { LexicalPluginNodeConverterProvider } from '../../types.js'\n\nimport { UploadConverterClient } from './client.js'\nimport { _UploadConverter } from './converter.js'\n\nexport const UploadConverter: LexicalPluginNodeConverterProvider = {\n  ClientComponent: UploadConverterClient,\n  converter: _UploadConverter,\n}\n"],"names":["UploadConverterClient","_UploadConverter","UploadConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,qBAAqB,QAAQ,cAAa;AACnD,SAASC,gBAAgB,QAAQ,iBAAgB;AAEjD,OAAO,MAAMC,kBAAsD;IACjEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/index.ts"],"sourcesContent":["import type { LexicalPluginNodeConverterProvider } from '../../types.js'\n\nimport { UploadConverterClient } from './client.js'\nimport { _UploadConverter } from './converter.js'\n\nexport const UploadConverter: LexicalPluginNodeConverterProvider = {\n  ClientComponent: UploadConverterClient,\n  converter: _UploadConverter,\n}\n"],"names":["UploadConverterClient","_UploadConverter","UploadConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,qBAAqB,QAAQ,cAAa;AACnD,SAASC,gBAAgB,QAAQ,iBAAgB;AAEjD,OAAO,MAAMC,kBAAsD;IACjEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/field/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/field/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"],"rangeMappings":";;;;;;;;;;;;;;;","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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/field/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/field/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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/field/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: SerializedLexicalNode & { children?: 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  ClientComponent: LexicalPluginNodeConverterClientComponent\n  converter: LexicalPluginNodeConverter\n}\n"],"names":[],"mappings":"AAiCA,WAGC"}
+{"version":3,"sources":["../../../../../../src/field/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: SerializedLexicalNode & { children?: 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  ClientComponent: LexicalPluginNodeConverterClientComponent\n  converter: LexicalPluginNodeConverter\n}\n"],"names":[],"rangeMappings":"","mappings":"AAiCA,WAGC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from '../../types.js'\nimport type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './converter/types.js'\n\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { convertLexicalPluginToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nconst LexicalPluginToLexicalFeatureClient: FeatureProviderProviderClient<null> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: ({ clientFunctions, resolvedFeatures }) => {\n      const converters: LexicalPluginNodeConverter[] = Object.values(clientFunctions)\n\n      return {\n        clientFeatureProps: props,\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  }\n}\n\nexport const LexicalPluginToLexicalFeatureClientComponent = createClientComponent(\n  LexicalPluginToLexicalFeatureClient,\n)\n"],"names":["createClientComponent","convertLexicalPluginToLexical","UnknownConvertedNode","LexicalPluginToLexicalFeatureClient","props","clientFeatureProps","feature","clientFunctions","resolvedFeatures","converters","Object","values","hooks","load","incomingEditorState","lexicalPluginData","nodes","LexicalPluginToLexicalFeatureClientComponent"],"mappings":"AAAA;AAKA,SAASA,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,6BAA6B,QAAQ,uBAAsB;AACpE,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,MAAMC,sCAA2E,CAACC;IAChF,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,CAAC,EAAEC,eAAe,EAAEC,gBAAgB,EAAE;YAC7C,MAAMC,aAA2CC,OAAOC,MAAM,CAACJ;YAE/D,OAAO;gBACLF,oBAAoBD;gBACpBQ,OAAO;oBACLC,MAAK,EAAEC,mBAAmB,EAAE;wBAC1B,IAAI,CAACA,uBAAuB,CAAE,CAAA,iBAAiBA,mBAAkB,GAAI;4BACnE,sDAAsD;4BACtD,OAAOA;wBACT;wBACA,uCAAuC;wBAEvC,OAAOb,8BAA8B;4BACnCQ;4BACAM,mBAAmBD;wBACrB;oBACF;gBACF;gBACAE,OAAO;oBAACd;iBAAqB;YAC/B;QACF;IACF;AACF;AAEA,OAAO,MAAMe,+CAA+CjB,sBAC1DG,qCACD"}
+{"version":3,"sources":["../../../../../src/field/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from '../../types.js'\nimport type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './converter/types.js'\n\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { convertLexicalPluginToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nconst LexicalPluginToLexicalFeatureClient: FeatureProviderProviderClient<null> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: ({ clientFunctions, resolvedFeatures }) => {\n      const converters: LexicalPluginNodeConverter[] = Object.values(clientFunctions)\n\n      return {\n        clientFeatureProps: props,\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  }\n}\n\nexport const LexicalPluginToLexicalFeatureClientComponent = createClientComponent(\n  LexicalPluginToLexicalFeatureClient,\n)\n"],"names":["createClientComponent","convertLexicalPluginToLexical","UnknownConvertedNode","LexicalPluginToLexicalFeatureClient","props","clientFeatureProps","feature","clientFunctions","resolvedFeatures","converters","Object","values","hooks","load","incomingEditorState","lexicalPluginData","nodes","LexicalPluginToLexicalFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAKA,SAASA,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,6BAA6B,QAAQ,uBAAsB;AACpE,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,MAAMC,sCAA2E,CAACC;IAChF,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,CAAC,EAAEC,eAAe,EAAEC,gBAAgB,EAAE;YAC7C,MAAMC,aAA2CC,OAAOC,MAAM,CAACJ;YAE/D,OAAO;gBACLF,oBAAoBD;gBACpBQ,OAAO;oBACLC,MAAK,EAAEC,mBAAmB,EAAE;wBAC1B,IAAI,CAACA,uBAAuB,CAAE,CAAA,iBAAiBA,mBAAkB,GAAI;4BACnE,sDAAsD;4BACtD,OAAOA;wBACT;wBACA,uCAAuC;wBAEvC,OAAOb,8BAA8B;4BACnCQ;4BACAM,mBAAmBD;wBACrB;oBACF;gBACF;gBACAE,OAAO;oBAACd;iBAAqB;YAC/B;QACF;IACF;AACF;AAEA,OAAO,MAAMe,+CAA+CjB,sBAC1DG,qCACD"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/features/migrations/lexicalPluginToLexical/feature.server.ts"],"sourcesContent":["import type React from 'react'\n\nimport type { FeatureProviderProviderServer } from '../../types.js'\nimport type { LexicalPluginNodeConverterProvider } from './converter/types.js'\n\nimport { defaultConverters } from './converter/defaultConverters.js'\nimport { LexicalPluginToLexicalFeatureClientComponent } from './feature.client.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: FeatureProviderProviderServer<\n  LexicalPluginToLexicalFeatureProps,\n  null\n> = (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    feature: () => {\n      return {\n        ClientComponent: LexicalPluginToLexicalFeatureClientComponent,\n        clientFeatureProps: null,\n        generateComponentMap: () => {\n          const map: {\n            [key: string]: React.FC\n          } = {}\n\n          for (const converter of converters) {\n            if (converter.ClientComponent) {\n              const key = converter.converter.nodeTypes.join('-')\n              map[key] = converter.ClientComponent\n            }\n          }\n\n          return map\n        },\n        nodes: [\n          {\n            node: UnknownConvertedNode,\n          },\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'lexicalPluginToLexical',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["defaultConverters","LexicalPluginToLexicalFeatureClientComponent","UnknownConvertedNode","LexicalPluginToLexicalFeature","props","converters","feature","ClientComponent","clientFeatureProps","generateComponentMap","map","converter","key","nodeTypes","join","nodes","node","serverFeatureProps"],"mappings":"AAKA,SAASA,iBAAiB,QAAQ,mCAAkC;AACpE,SAASC,4CAA4C,QAAQ,sBAAqB;AAClF,SAASC,oBAAoB,QAAQ,wCAAuC;AAY5E,OAAO,MAAMC,gCAGT,CAACC;IACH,IAAI,CAACA,OAAO;QACVA,QAAQ,CAAC;IACX;IAEA,IAAIC,aAAmD,EAAE;IAEzD,IAAID,OAAOC,cAAc,OAAOD,OAAOC,eAAe,YAAY;QAChEA,aAAaD,MAAMC,UAAU,CAAC;YAAEL;QAAkB;IACpD,OAAO,IAAII,MAAMC,UAAU,IAAI,OAAOD,OAAOC,eAAe,YAAY;QACtEA,aAAaD,MAAMC,UAAU;IAC/B,OAAO;QACLA,aAAaL;IACf;IAEAI,MAAMC,UAAU,GAAGA;IAEnB,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,iBAAiBN;gBACjBO,oBAAoB;gBACpBC,sBAAsB;oBACpB,MAAMC,MAEF,CAAC;oBAEL,KAAK,MAAMC,aAAaN,WAAY;wBAClC,IAAIM,UAAUJ,eAAe,EAAE;4BAC7B,MAAMK,MAAMD,UAAUA,SAAS,CAACE,SAAS,CAACC,IAAI,CAAC;4BAC/CJ,GAAG,CAACE,IAAI,GAAGD,UAAUJ,eAAe;wBACtC;oBACF;oBAEA,OAAOG;gBACT;gBACAK,OAAO;oBACL;wBACEC,MAAMd;oBACR;iBACD;gBACDe,oBAAoBb;YACtB;QACF;QACAQ,KAAK;QACLK,oBAAoBb;IACtB;AACF,EAAC"}
+{"version":3,"sources":["../../../../../src/field/features/migrations/lexicalPluginToLexical/feature.server.ts"],"sourcesContent":["import type React from 'react'\n\nimport type { FeatureProviderProviderServer } from '../../types.js'\nimport type { LexicalPluginNodeConverterProvider } from './converter/types.js'\n\nimport { defaultConverters } from './converter/defaultConverters.js'\nimport { LexicalPluginToLexicalFeatureClientComponent } from './feature.client.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: FeatureProviderProviderServer<\n  LexicalPluginToLexicalFeatureProps,\n  null\n> = (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    feature: () => {\n      return {\n        ClientComponent: LexicalPluginToLexicalFeatureClientComponent,\n        clientFeatureProps: null,\n        generateComponentMap: () => {\n          const map: {\n            [key: string]: React.FC\n          } = {}\n\n          for (const converter of converters) {\n            if (converter.ClientComponent) {\n              const key = converter.converter.nodeTypes.join('-')\n              map[key] = converter.ClientComponent\n            }\n          }\n\n          return map\n        },\n        nodes: [\n          {\n            node: UnknownConvertedNode,\n          },\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'lexicalPluginToLexical',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["defaultConverters","LexicalPluginToLexicalFeatureClientComponent","UnknownConvertedNode","LexicalPluginToLexicalFeature","props","converters","feature","ClientComponent","clientFeatureProps","generateComponentMap","map","converter","key","nodeTypes","join","nodes","node","serverFeatureProps"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,SAASA,iBAAiB,QAAQ,mCAAkC;AACpE,SAASC,4CAA4C,QAAQ,sBAAqB;AAClF,SAASC,oBAAoB,QAAQ,wCAAuC;AAY5E,OAAO,MAAMC,gCAGT,CAACC;IACH,IAAI,CAACA,OAAO;QACVA,QAAQ,CAAC;IACX;IAEA,IAAIC,aAAmD,EAAE;IAEzD,IAAID,OAAOC,cAAc,OAAOD,OAAOC,eAAe,YAAY;QAChEA,aAAaD,MAAMC,UAAU,CAAC;YAAEL;QAAkB;IACpD,OAAO,IAAII,MAAMC,UAAU,IAAI,OAAOD,OAAOC,eAAe,YAAY;QACtEA,aAAaD,MAAMC,UAAU;IAC/B,OAAO;QACLA,aAAaL;IACf;IAEAI,MAAMC,UAAU,GAAGA;IAEnB,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,iBAAiBN;gBACjBO,oBAAoB;gBACpBC,sBAAsB;oBACpB,MAAMC,MAEF,CAAC;oBAEL,KAAK,MAAMC,aAAaN,WAAY;wBAClC,IAAIM,UAAUJ,eAAe,EAAE;4BAC7B,MAAMK,MAAMD,UAAUA,SAAS,CAACE,SAAS,CAACC,IAAI,CAAC;4BAC/CJ,GAAG,CAACE,IAAI,GAAGD,UAAUJ,eAAe;wBACtC;oBACF;oBAEA,OAAOG;gBACT;gBACAK,OAAO;oBACL;wBACEC,MAAMd;oBACR;iBACD;gBACDe,oBAAoBb;YACtB;QACF;QACAQ,KAAK;QACLK,oBAAoBb;IACtB;AACF,EAAC"}

package/dist/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["import React from 'react'\n\nimport type { UnknownConvertedNodeData } from './index.js'\n\nimport './index.scss'\n\ntype Props = {\n  data: UnknownConvertedNodeData\n}\n\nexport const UnknownConvertedNodeComponent: React.FC<Props> = (props) => {\n  const { data } = props\n\n  return (\n    <div>\n      Unknown converted payload-plugin-lexical node: <strong>{data?.nodeType}</strong>\n    </div>\n  )\n}\n"],"names":["React","UnknownConvertedNodeComponent","props","data","div","strong","nodeType"],"mappings":"AAAA,OAAOA,WAAW,QAAO;AAIzB,OAAO,eAAc;AAMrB,OAAO,MAAMC,gCAAiD,CAACC;IAC7D,MAAM,EAAEC,IAAI,EAAE,GAAGD;IAEjB,qBACE,oBAACE,aAAI,iEAC4C,oBAACC,gBAAQF,MAAMG;AAGpE,EAAC"}
+{"version":3,"sources":["../../../../../../../src/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["import React from 'react'\n\nimport type { UnknownConvertedNodeData } from './index.js'\n\nimport './index.scss'\n\ntype Props = {\n  data: UnknownConvertedNodeData\n}\n\nexport const UnknownConvertedNodeComponent: React.FC<Props> = (props) => {\n  const { data } = props\n\n  return (\n    <div>\n      Unknown converted payload-plugin-lexical node: <strong>{data?.nodeType}</strong>\n    </div>\n  )\n}\n"],"names":["React","UnknownConvertedNodeComponent","props","data","div","strong","nodeType"],"rangeMappings":";;;;;","mappings":"AAAA,OAAOA,WAAW,QAAO;AAIzB,OAAO,eAAc;AAMrB,OAAO,MAAMC,gCAAiD,CAACC;IAC7D,MAAM,EAAEC,IAAI,EAAE,GAAGD;IAEjB,qBACE,oBAACE,aAAI,iEAC4C,oBAACC,gBAAQF,MAAMG;AAGpE,EAAC"}

package/dist/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { SerializedLexicalNode, Spread } from 'lexical'\n\nimport lexicalUtilsImport from '@lexical/utils'\nconst { addClassNamesToElement } = lexicalUtilsImport\n\nimport lexicalImport from 'lexical'\nconst { DecoratorNode } = lexicalImport\n\nimport type { EditorConfig, LexicalNode, NodeKey } from 'lexical'\n\nimport * as React from 'react'\n\nexport type UnknownConvertedNodeData = {\n  nodeData: unknown\n  nodeType: string\n}\n\nexport type SerializedUnknownConvertedNode = Spread<\n  {\n    data: UnknownConvertedNodeData\n  },\n  SerializedLexicalNode\n>\n\nconst Component = React.lazy(() =>\n  import('./Component.js').then((module) => ({\n    default: module.UnknownConvertedNodeComponent,\n  })),\n)\n\n/** @noInheritDoc */\nexport class UnknownConvertedNode extends DecoratorNode<JSX.Element> {\n  __data: UnknownConvertedNodeData\n\n  constructor({ data, key }: { data: UnknownConvertedNodeData; key?: NodeKey }) {\n    super(key)\n    this.__data = data\n  }\n\n  static clone(node: UnknownConvertedNode): UnknownConvertedNode {\n    return new UnknownConvertedNode({\n      data: node.__data,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'unknownConverted'\n  }\n\n  static importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode {\n    const node = $createUnknownConvertedNode({ data: serializedNode.data })\n    return node\n  }\n\n  canInsertTextAfter(): true {\n    return true\n  }\n\n  canInsertTextBefore(): true {\n    return true\n  }\n\n  createDOM(config: EditorConfig): HTMLElement {\n    const element = document.createElement('span')\n    addClassNamesToElement(element, 'unknownConverted')\n    return element\n  }\n\n  decorate(): JSX.Element | null {\n    return <Component data={this.__data} />\n  }\n\n  exportJSON(): SerializedUnknownConvertedNode {\n    return {\n      type: this.getType(),\n      data: this.__data,\n      version: 1,\n    }\n  }\n\n  // Mutation\n\n  isInline(): boolean {\n    return true\n  }\n\n  updateDOM(prevNode: UnknownConvertedNode, dom: HTMLElement): boolean {\n    return false\n  }\n}\n\nexport function $createUnknownConvertedNode({\n  data,\n}: {\n  data: UnknownConvertedNodeData\n}): UnknownConvertedNode {\n  return new UnknownConvertedNode({\n    data,\n  })\n}\n\nexport function $isUnknownConvertedNode(\n  node: LexicalNode | null | undefined,\n): node is UnknownConvertedNode {\n  return node instanceof UnknownConvertedNode\n}\n"],"names":["lexicalUtilsImport","addClassNamesToElement","lexicalImport","DecoratorNode","React","Component","lazy","then","module","default","UnknownConvertedNodeComponent","UnknownConvertedNode","__data","constructor","data","key","clone","node","__key","getType","importJSON","serializedNode","$createUnknownConvertedNode","canInsertTextAfter","canInsertTextBefore","createDOM","config","element","document","createElement","decorate","exportJSON","type","version","isInline","updateDOM","prevNode","dom","$isUnknownConvertedNode"],"mappings":"AAEA,OAAOA,wBAAwB,iBAAgB;AAC/C,MAAM,EAAEC,sBAAsB,EAAE,GAAGD;AAEnC,OAAOE,mBAAmB,UAAS;AACnC,MAAM,EAAEC,aAAa,EAAE,GAAGD;AAI1B,YAAYE,WAAW,QAAO;AAc9B,MAAMC,0BAAYD,MAAME,IAAI,CAAC,IAC3B,MAAM,CAAC,kBAAkBC,IAAI,CAAC,CAACC,SAAY,CAAA;YACzCC,SAASD,OAAOE,6BAA6B;QAC/C,CAAA;AAGF,kBAAkB,GAClB,OAAO,MAAMC,6BAA6BR;IACxCS,OAAgC;IAEhCC,YAAY,EAAEC,IAAI,EAAEC,GAAG,EAAqD,CAAE;QAC5E,KAAK,CAACA;QACN,IAAI,CAACH,MAAM,GAAGE;IAChB;IAEA,OAAOE,MAAMC,IAA0B,EAAwB;QAC7D,OAAO,IAAIN,qBAAqB;YAC9BG,MAAMG,KAAKL,MAAM;YACjBG,KAAKE,KAAKC,KAAK;QACjB;IACF;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA,OAAOC,WAAWC,cAA8C,EAAwB;QACtF,MAAMJ,OAAOK,4BAA4B;YAAER,MAAMO,eAAeP,IAAI;QAAC;QACrE,OAAOG;IACT;IAEAM,qBAA2B;QACzB,OAAO;IACT;IAEAC,sBAA4B;QAC1B,OAAO;IACT;IAEAC,UAAUC,MAAoB,EAAe;QAC3C,MAAMC,UAAUC,SAASC,aAAa,CAAC;QACvC5B,uBAAuB0B,SAAS;QAChC,OAAOA;IACT;IAEAG,WAA+B;QAC7B,qBAAO,oBAACzB;YAAUS,MAAM,IAAI,CAACF,MAAM;;IACrC;IAEAmB,aAA6C;QAC3C,OAAO;YACLC,MAAM,IAAI,CAACb,OAAO;YAClBL,MAAM,IAAI,CAACF,MAAM;YACjBqB,SAAS;QACX;IACF;IAEA,WAAW;IAEXC,WAAoB;QAClB,OAAO;IACT;IAEAC,UAAUC,QAA8B,EAAEC,GAAgB,EAAW;QACnE,OAAO;IACT;AACF;AAEA,OAAO,SAASf,4BAA4B,EAC1CR,IAAI,EAGL;IACC,OAAO,IAAIH,qBAAqB;QAC9BG;IACF;AACF;AAEA,OAAO,SAASwB,wBACdrB,IAAoC;IAEpC,OAAOA,gBAAgBN;AACzB"}
+{"version":3,"sources":["../../../../../../../src/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { SerializedLexicalNode, Spread } from 'lexical'\n\nimport lexicalUtilsImport from '@lexical/utils'\nconst { addClassNamesToElement } = lexicalUtilsImport\n\nimport lexicalImport from 'lexical'\nconst { DecoratorNode } = lexicalImport\n\nimport type { EditorConfig, LexicalNode, NodeKey } from 'lexical'\n\nimport * as React from 'react'\n\nexport type UnknownConvertedNodeData = {\n  nodeData: unknown\n  nodeType: string\n}\n\nexport type SerializedUnknownConvertedNode = Spread<\n  {\n    data: UnknownConvertedNodeData\n  },\n  SerializedLexicalNode\n>\n\nconst Component = React.lazy(() =>\n  import('./Component.js').then((module) => ({\n    default: module.UnknownConvertedNodeComponent,\n  })),\n)\n\n/** @noInheritDoc */\nexport class UnknownConvertedNode extends DecoratorNode<JSX.Element> {\n  __data: UnknownConvertedNodeData\n\n  constructor({ data, key }: { data: UnknownConvertedNodeData; key?: NodeKey }) {\n    super(key)\n    this.__data = data\n  }\n\n  static clone(node: UnknownConvertedNode): UnknownConvertedNode {\n    return new UnknownConvertedNode({\n      data: node.__data,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'unknownConverted'\n  }\n\n  static importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode {\n    const node = $createUnknownConvertedNode({ data: serializedNode.data })\n    return node\n  }\n\n  canInsertTextAfter(): true {\n    return true\n  }\n\n  canInsertTextBefore(): true {\n    return true\n  }\n\n  createDOM(config: EditorConfig): HTMLElement {\n    const element = document.createElement('span')\n    addClassNamesToElement(element, 'unknownConverted')\n    return element\n  }\n\n  decorate(): JSX.Element | null {\n    return <Component data={this.__data} />\n  }\n\n  exportJSON(): SerializedUnknownConvertedNode {\n    return {\n      type: this.getType(),\n      data: this.__data,\n      version: 1,\n    }\n  }\n\n  // Mutation\n\n  isInline(): boolean {\n    return true\n  }\n\n  updateDOM(prevNode: UnknownConvertedNode, dom: HTMLElement): boolean {\n    return false\n  }\n}\n\nexport function $createUnknownConvertedNode({\n  data,\n}: {\n  data: UnknownConvertedNodeData\n}): UnknownConvertedNode {\n  return new UnknownConvertedNode({\n    data,\n  })\n}\n\nexport function $isUnknownConvertedNode(\n  node: LexicalNode | null | undefined,\n): node is UnknownConvertedNode {\n  return node instanceof UnknownConvertedNode\n}\n"],"names":["lexicalUtilsImport","addClassNamesToElement","lexicalImport","DecoratorNode","React","Component","lazy","then","module","default","UnknownConvertedNodeComponent","UnknownConvertedNode","__data","constructor","data","key","clone","node","__key","getType","importJSON","serializedNode","$createUnknownConvertedNode","canInsertTextAfter","canInsertTextBefore","createDOM","config","element","document","createElement","decorate","exportJSON","type","version","isInline","updateDOM","prevNode","dom","$isUnknownConvertedNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAOA,wBAAwB,iBAAgB;AAC/C,MAAM,EAAEC,sBAAsB,EAAE,GAAGD;AAEnC,OAAOE,mBAAmB,UAAS;AACnC,MAAM,EAAEC,aAAa,EAAE,GAAGD;AAI1B,YAAYE,WAAW,QAAO;AAc9B,MAAMC,0BAAYD,MAAME,IAAI,CAAC,IAC3B,MAAM,CAAC,kBAAkBC,IAAI,CAAC,CAACC,SAAY,CAAA;YACzCC,SAASD,OAAOE,6BAA6B;QAC/C,CAAA;AAGF,kBAAkB,GAClB,OAAO,MAAMC,6BAA6BR;IACxCS,OAAgC;IAEhCC,YAAY,EAAEC,IAAI,EAAEC,GAAG,EAAqD,CAAE;QAC5E,KAAK,CAACA;QACN,IAAI,CAACH,MAAM,GAAGE;IAChB;IAEA,OAAOE,MAAMC,IAA0B,EAAwB;QAC7D,OAAO,IAAIN,qBAAqB;YAC9BG,MAAMG,KAAKL,MAAM;YACjBG,KAAKE,KAAKC,KAAK;QACjB;IACF;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA,OAAOC,WAAWC,cAA8C,EAAwB;QACtF,MAAMJ,OAAOK,4BAA4B;YAAER,MAAMO,eAAeP,IAAI;QAAC;QACrE,OAAOG;IACT;IAEAM,qBAA2B;QACzB,OAAO;IACT;IAEAC,sBAA4B;QAC1B,OAAO;IACT;IAEAC,UAAUC,MAAoB,EAAe;QAC3C,MAAMC,UAAUC,SAASC,aAAa,CAAC;QACvC5B,uBAAuB0B,SAAS;QAChC,OAAOA;IACT;IAEAG,WAA+B;QAC7B,qBAAO,oBAACzB;YAAUS,MAAM,IAAI,CAACF,MAAM;;IACrC;IAEAmB,aAA6C;QAC3C,OAAO;YACLC,MAAM,IAAI,CAACb,OAAO;YAClBL,MAAM,IAAI,CAACF,MAAM;YACjBqB,SAAS;QACX;IACF;IAEA,WAAW;IAEXC,WAAoB;QAClB,OAAO;IACT;IAEAC,UAAUC,QAA8B,EAAEC,GAAgB,EAAW;QACnE,OAAO;IACT;AACF;AAEA,OAAO,SAASf,4BAA4B,EAC1CR,IAAI,EAGL;IACC,OAAO,IAAIH,qBAAqB;QAC9BG;IACF;AACF;AAEA,OAAO,SAASwB,wBACdrB,IAAoC;IAEpC,OAAOA,gBAAgBN;AACzB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/blockquote/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateBlockquoteConverter } from './converter.js'\n\nexport const BlockQuoteConverterClient = createFeaturePropComponent(_SlateBlockquoteConverter)\n"],"names":["createFeaturePropComponent","_SlateBlockquoteConverter","BlockQuoteConverterClient"],"mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,yBAAyB,QAAQ,iBAAgB;AAE1D,OAAO,MAAMC,4BAA4BF,2BAA2BC,2BAA0B"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/blockquote/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateBlockquoteConverter } from './converter.js'\n\nexport const BlockQuoteConverterClient = createFeaturePropComponent(_SlateBlockquoteConverter)\n"],"names":["createFeaturePropComponent","_SlateBlockquoteConverter","BlockQuoteConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,yBAAyB,QAAQ,iBAAgB;AAE1D,OAAO,MAAMC,4BAA4BF,2BAA2BC,2BAA0B"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '@lexical/rich-text'\n\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":"AAIA,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/field/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '@lexical/rich-text'\n\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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/blockquote/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { BlockQuoteConverterClient } from './client.js'\nimport { _SlateBlockquoteConverter } from './converter.js'\n\nexport const SlateBlockquoteConverter: SlateNodeConverterProvider = {\n  ClientComponent: BlockQuoteConverterClient,\n  converter: _SlateBlockquoteConverter,\n}\n"],"names":["BlockQuoteConverterClient","_SlateBlockquoteConverter","SlateBlockquoteConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,yBAAyB,QAAQ,cAAa;AACvD,SAASC,yBAAyB,QAAQ,iBAAgB;AAE1D,OAAO,MAAMC,2BAAuD;IAClEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/blockquote/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { BlockQuoteConverterClient } from './client.js'\nimport { _SlateBlockquoteConverter } from './converter.js'\n\nexport const SlateBlockquoteConverter: SlateNodeConverterProvider = {\n  ClientComponent: BlockQuoteConverterClient,\n  converter: _SlateBlockquoteConverter,\n}\n"],"names":["BlockQuoteConverterClient","_SlateBlockquoteConverter","SlateBlockquoteConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,yBAAyB,QAAQ,cAAa;AACvD,SAASC,yBAAyB,QAAQ,iBAAgB;AAE1D,OAAO,MAAMC,2BAAuD;IAClEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/heading/client.ts"],"sourcesContent":["'use client'\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateHeadingConverter } from './converter.js'\n\nexport const HeadingConverterClient = createFeaturePropComponent(_SlateHeadingConverter)\n"],"names":["createFeaturePropComponent","_SlateHeadingConverter","HeadingConverterClient"],"mappings":"AAAA;AACA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,yBAAyBF,2BAA2BC,wBAAuB"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/heading/client.ts"],"sourcesContent":["'use client'\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateHeadingConverter } from './converter.js'\n\nexport const HeadingConverterClient = createFeaturePropComponent(_SlateHeadingConverter)\n"],"names":["createFeaturePropComponent","_SlateHeadingConverter","HeadingConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AACA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,yBAAyBF,2BAA2BC,wBAAuB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '@lexical/rich-text'\n\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":"AAIA,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/field/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '@lexical/rich-text'\n\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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/heading/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { HeadingConverterClient } from './client.js'\nimport { _SlateHeadingConverter } from './converter.js'\n\nexport const SlateHeadingConverter: SlateNodeConverterProvider = {\n  ClientComponent: HeadingConverterClient,\n  converter: _SlateHeadingConverter,\n}\n"],"names":["HeadingConverterClient","_SlateHeadingConverter","SlateHeadingConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,sBAAsB,QAAQ,cAAa;AACpD,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,wBAAoD;IAC/DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/heading/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { HeadingConverterClient } from './client.js'\nimport { _SlateHeadingConverter } from './converter.js'\n\nexport const SlateHeadingConverter: SlateNodeConverterProvider = {\n  ClientComponent: HeadingConverterClient,\n  converter: _SlateHeadingConverter,\n}\n"],"names":["HeadingConverterClient","_SlateHeadingConverter","SlateHeadingConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,sBAAsB,QAAQ,cAAa;AACpD,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,wBAAoD;IAC/DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/indent/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateIndentConverter } from './converter.js'\n\nexport const IndentConverterClient = createFeaturePropComponent(_SlateIndentConverter)\n"],"names":["createFeaturePropComponent","_SlateIndentConverter","IndentConverterClient"],"mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,wBAAwBF,2BAA2BC,uBAAsB"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/indent/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateIndentConverter } from './converter.js'\n\nexport const IndentConverterClient = createFeaturePropComponent(_SlateIndentConverter)\n"],"names":["createFeaturePropComponent","_SlateIndentConverter","IndentConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,wBAAwBF,2BAA2BC,uBAAsB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/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/field/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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/indent/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { IndentConverterClient } from './client.js'\nimport { _SlateIndentConverter } from './converter.js'\n\nexport const SlateIndentConverter: SlateNodeConverterProvider = {\n  ClientComponent: IndentConverterClient,\n  converter: _SlateIndentConverter,\n}\n"],"names":["IndentConverterClient","_SlateIndentConverter","SlateIndentConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,qBAAqB,QAAQ,cAAa;AACnD,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,uBAAmD;IAC9DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/indent/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { IndentConverterClient } from './client.js'\nimport { _SlateIndentConverter } from './converter.js'\n\nexport const SlateIndentConverter: SlateNodeConverterProvider = {\n  ClientComponent: IndentConverterClient,\n  converter: _SlateIndentConverter,\n}\n"],"names":["IndentConverterClient","_SlateIndentConverter","SlateIndentConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,qBAAqB,QAAQ,cAAa;AACnD,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,uBAAmD;IAC9DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/link/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateLinkConverter } from './converter.js'\n\nexport const LinkConverterClient = createFeaturePropComponent(_SlateLinkConverter)\n"],"names":["createFeaturePropComponent","_SlateLinkConverter","LinkConverterClient"],"mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,mBAAmB,QAAQ,iBAAgB;AAEpD,OAAO,MAAMC,sBAAsBF,2BAA2BC,qBAAoB"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/link/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateLinkConverter } from './converter.js'\n\nexport const LinkConverterClient = createFeaturePropComponent(_SlateLinkConverter)\n"],"names":["createFeaturePropComponent","_SlateLinkConverter","LinkConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,mBAAmB,QAAQ,iBAAgB;AAEpD,OAAO,MAAMC,sBAAsBF,2BAA2BC,qBAAoB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/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/field/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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/link/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { LinkConverterClient } from './client.js'\nimport { _SlateLinkConverter } from './converter.js'\n\nexport const SlateLinkConverter: SlateNodeConverterProvider = {\n  ClientComponent: LinkConverterClient,\n  converter: _SlateLinkConverter,\n}\n"],"names":["LinkConverterClient","_SlateLinkConverter","SlateLinkConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,mBAAmB,QAAQ,cAAa;AACjD,SAASC,mBAAmB,QAAQ,iBAAgB;AAEpD,OAAO,MAAMC,qBAAiD;IAC5DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/link/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { LinkConverterClient } from './client.js'\nimport { _SlateLinkConverter } from './converter.js'\n\nexport const SlateLinkConverter: SlateNodeConverterProvider = {\n  ClientComponent: LinkConverterClient,\n  converter: _SlateLinkConverter,\n}\n"],"names":["LinkConverterClient","_SlateLinkConverter","SlateLinkConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,mBAAmB,QAAQ,cAAa;AACjD,SAASC,mBAAmB,QAAQ,iBAAgB;AAEpD,OAAO,MAAMC,qBAAiD;IAC5DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/listItem/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateListItemConverter } from './converter.js'\n\nexport const ListItemConverterClient = createFeaturePropComponent(_SlateListItemConverter)\n"],"names":["createFeaturePropComponent","_SlateListItemConverter","ListItemConverterClient"],"mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,uBAAuB,QAAQ,iBAAgB;AAExD,OAAO,MAAMC,0BAA0BF,2BAA2BC,yBAAwB"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/listItem/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateListItemConverter } from './converter.js'\n\nexport const ListItemConverterClient = createFeaturePropComponent(_SlateListItemConverter)\n"],"names":["createFeaturePropComponent","_SlateListItemConverter","ListItemConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,uBAAuB,QAAQ,iBAAgB;AAExD,OAAO,MAAMC,0BAA0BF,2BAA2BC,yBAAwB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '@lexical/list'\n\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":"AAIA,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/field/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '@lexical/list'\n\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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/listItem/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { ListItemConverterClient } from './client.js'\nimport { _SlateListItemConverter } from './converter.js'\n\nexport const SlateListItemConverter: SlateNodeConverterProvider = {\n  ClientComponent: ListItemConverterClient,\n  converter: _SlateListItemConverter,\n}\n"],"names":["ListItemConverterClient","_SlateListItemConverter","SlateListItemConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,uBAAuB,QAAQ,cAAa;AACrD,SAASC,uBAAuB,QAAQ,iBAAgB;AAExD,OAAO,MAAMC,yBAAqD;IAChEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/listItem/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { ListItemConverterClient } from './client.js'\nimport { _SlateListItemConverter } from './converter.js'\n\nexport const SlateListItemConverter: SlateNodeConverterProvider = {\n  ClientComponent: ListItemConverterClient,\n  converter: _SlateListItemConverter,\n}\n"],"names":["ListItemConverterClient","_SlateListItemConverter","SlateListItemConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,uBAAuB,QAAQ,cAAa;AACrD,SAASC,uBAAuB,QAAQ,iBAAgB;AAExD,OAAO,MAAMC,yBAAqD;IAChEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/orderedList/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateOrderedListConverter } from './converter.js'\n\nexport const OrderedListConverterClient = createFeaturePropComponent(_SlateOrderedListConverter)\n"],"names":["createFeaturePropComponent","_SlateOrderedListConverter","OrderedListConverterClient"],"mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,6BAA6BF,2BAA2BC,4BAA2B"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/orderedList/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateOrderedListConverter } from './converter.js'\n\nexport const OrderedListConverterClient = createFeaturePropComponent(_SlateOrderedListConverter)\n"],"names":["createFeaturePropComponent","_SlateOrderedListConverter","OrderedListConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,6BAA6BF,2BAA2BC,4BAA2B"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '@lexical/list'\n\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":"AAIA,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/field/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '@lexical/list'\n\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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/orderedList/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { OrderedListConverterClient } from './client.js'\nimport { _SlateOrderedListConverter } from './converter.js'\n\nexport const SlateOrderedListConverter: SlateNodeConverterProvider = {\n  ClientComponent: OrderedListConverterClient,\n  converter: _SlateOrderedListConverter,\n}\n"],"names":["OrderedListConverterClient","_SlateOrderedListConverter","SlateOrderedListConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,0BAA0B,QAAQ,cAAa;AACxD,SAASC,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,4BAAwD;IACnEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/orderedList/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { OrderedListConverterClient } from './client.js'\nimport { _SlateOrderedListConverter } from './converter.js'\n\nexport const SlateOrderedListConverter: SlateNodeConverterProvider = {\n  ClientComponent: OrderedListConverterClient,\n  converter: _SlateOrderedListConverter,\n}\n"],"names":["OrderedListConverterClient","_SlateOrderedListConverter","SlateOrderedListConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,0BAA0B,QAAQ,cAAa;AACxD,SAASC,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,4BAAwD;IACnEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/relationship/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateRelationshipConverter } from './converter.js'\n\nexport const RelationshipConverterClient = createFeaturePropComponent(_SlateRelationshipConverter)\n"],"names":["createFeaturePropComponent","_SlateRelationshipConverter","RelationshipConverterClient"],"mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,2BAA2B,QAAQ,iBAAgB;AAE5D,OAAO,MAAMC,8BAA8BF,2BAA2BC,6BAA4B"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/relationship/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateRelationshipConverter } from './converter.js'\n\nexport const RelationshipConverterClient = createFeaturePropComponent(_SlateRelationshipConverter)\n"],"names":["createFeaturePropComponent","_SlateRelationshipConverter","RelationshipConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,2BAA2B,QAAQ,iBAAgB;AAE5D,OAAO,MAAMC,8BAA8BF,2BAA2BC,6BAA4B"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/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: {\n        id: slateNode?.value?.id || '',\n      },\n      version: 1,\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,OAAO;gBACLC,IAAIL,WAAWI,OAAOC,MAAM;YAC9B;YACAC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAe;AAC7B,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/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: {\n        id: slateNode?.value?.id || '',\n      },\n      version: 1,\n    } as const as SerializedRelationshipNode\n  },\n  nodeTypes: ['relationship'],\n}\n"],"names":["_SlateRelationshipConverter","converter","slateNode","type","format","relationTo","value","id","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":"AAGA,OAAO,MAAMA,8BAAkD;IAC7DC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;YACRC,YAAYH,UAAUG,UAAU;YAChCC,OAAO;gBACLC,IAAIL,WAAWI,OAAOC,MAAM;YAC9B;YACAC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAe;AAC7B,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/relationship/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { RelationshipConverterClient } from './client.js'\nimport { _SlateRelationshipConverter } from './converter.js'\n\nexport const SlateRelationshipConverter: SlateNodeConverterProvider = {\n  ClientComponent: RelationshipConverterClient,\n  converter: _SlateRelationshipConverter,\n}\n"],"names":["RelationshipConverterClient","_SlateRelationshipConverter","SlateRelationshipConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,2BAA2B,QAAQ,cAAa;AACzD,SAASC,2BAA2B,QAAQ,iBAAgB;AAE5D,OAAO,MAAMC,6BAAyD;IACpEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/relationship/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { RelationshipConverterClient } from './client.js'\nimport { _SlateRelationshipConverter } from './converter.js'\n\nexport const SlateRelationshipConverter: SlateNodeConverterProvider = {\n  ClientComponent: RelationshipConverterClient,\n  converter: _SlateRelationshipConverter,\n}\n"],"names":["RelationshipConverterClient","_SlateRelationshipConverter","SlateRelationshipConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,2BAA2B,QAAQ,cAAa;AACzD,SAASC,2BAA2B,QAAQ,iBAAgB;AAE5D,OAAO,MAAMC,6BAAyD;IACpEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/unknown/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateUnknownConverter } from './converter.js'\n\nexport const UnknownConverterClient = createFeaturePropComponent(_SlateUnknownConverter)\n"],"names":["createFeaturePropComponent","_SlateUnknownConverter","UnknownConverterClient"],"mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,yBAAyBF,2BAA2BC,wBAAuB"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/unknown/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateUnknownConverter } from './converter.js'\n\nexport const UnknownConverterClient = createFeaturePropComponent(_SlateUnknownConverter)\n"],"names":["createFeaturePropComponent","_SlateUnknownConverter","UnknownConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,yBAAyBF,2BAA2BC,wBAAuB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/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/field/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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/unknown/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { UnknownConverterClient } from './client.js'\nimport { _SlateUnknownConverter } from './converter.js'\n\nexport const SlateUnknownConverter: SlateNodeConverterProvider = {\n  ClientComponent: UnknownConverterClient,\n  converter: _SlateUnknownConverter,\n}\n"],"names":["UnknownConverterClient","_SlateUnknownConverter","SlateUnknownConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,sBAAsB,QAAQ,cAAa;AACpD,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,wBAAoD;IAC/DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/unknown/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { UnknownConverterClient } from './client.js'\nimport { _SlateUnknownConverter } from './converter.js'\n\nexport const SlateUnknownConverter: SlateNodeConverterProvider = {\n  ClientComponent: UnknownConverterClient,\n  converter: _SlateUnknownConverter,\n}\n"],"names":["UnknownConverterClient","_SlateUnknownConverter","SlateUnknownConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,sBAAsB,QAAQ,cAAa;AACpD,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,wBAAoD;IAC/DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/unorderedList/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateUnorderedListConverter } from './converter.js'\n\nexport const UnorderedListConverterClient = createFeaturePropComponent(_SlateUnorderedListConverter)\n"],"names":["createFeaturePropComponent","_SlateUnorderedListConverter","UnorderedListConverterClient"],"mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,4BAA4B,QAAQ,iBAAgB;AAE7D,OAAO,MAAMC,+BAA+BF,2BAA2BC,8BAA6B"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/unorderedList/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateUnorderedListConverter } from './converter.js'\n\nexport const UnorderedListConverterClient = createFeaturePropComponent(_SlateUnorderedListConverter)\n"],"names":["createFeaturePropComponent","_SlateUnorderedListConverter","UnorderedListConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,4BAA4B,QAAQ,iBAAgB;AAE7D,OAAO,MAAMC,+BAA+BF,2BAA2BC,8BAA6B"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/unorderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '@lexical/list'\n\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":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,+BAAmD;IAC9DC,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/field/features/migrations/slateToLexical/converter/converters/unorderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '@lexical/list'\n\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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,+BAAmD;IAC9DC,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/field/features/migrations/slateToLexical/converter/converters/unorderedList/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/unorderedList/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { UnorderedListConverterClient } from './client.js'\nimport { _SlateUnorderedListConverter } from './converter.js'\n\nexport const SlateUnorderedListConverter: SlateNodeConverterProvider = {\n  ClientComponent: UnorderedListConverterClient,\n  converter: _SlateUnorderedListConverter,\n}\n"],"names":["UnorderedListConverterClient","_SlateUnorderedListConverter","SlateUnorderedListConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,4BAA4B,QAAQ,cAAa;AAC1D,SAASC,4BAA4B,QAAQ,iBAAgB;AAE7D,OAAO,MAAMC,8BAA0D;IACrEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/unorderedList/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { UnorderedListConverterClient } from './client.js'\nimport { _SlateUnorderedListConverter } from './converter.js'\n\nexport const SlateUnorderedListConverter: SlateNodeConverterProvider = {\n  ClientComponent: UnorderedListConverterClient,\n  converter: _SlateUnorderedListConverter,\n}\n"],"names":["UnorderedListConverterClient","_SlateUnorderedListConverter","SlateUnorderedListConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,4BAA4B,QAAQ,cAAa;AAC1D,SAASC,4BAA4B,QAAQ,iBAAgB;AAE7D,OAAO,MAAMC,8BAA0D;IACrEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/upload/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateUploadConverter } from './converter.js'\n\nexport const UploadConverterClient = createFeaturePropComponent(_SlateUploadConverter)\n"],"names":["createFeaturePropComponent","_SlateUploadConverter","UploadConverterClient"],"mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,wBAAwBF,2BAA2BC,uBAAsB"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/upload/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateUploadConverter } from './converter.js'\n\nexport const UploadConverterClient = createFeaturePropComponent(_SlateUploadConverter)\n"],"names":["createFeaturePropComponent","_SlateUploadConverter","UploadConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,wBAAwBF,2BAA2BC,uBAAsB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["import type { SerializedUploadNode } from '../../../../../upload/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: {\n        id: slateNode.value?.id || '',\n      },\n      version: 1,\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,wBAA4C;IACvDC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;gBACN,GAAGF,UAAUE,MAAM;YACrB;YACAC,QAAQ;YACRC,YAAYJ,UAAUI,UAAU;YAChCC,OAAO;gBACLC,IAAIN,UAAUK,KAAK,EAAEC,MAAM;YAC7B;YACAC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["import type { SerializedUploadNode } from '../../../../../upload/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: {\n        id: slateNode.value?.id || '',\n      },\n      version: 1,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"names":["_SlateUploadConverter","converter","slateNode","type","fields","format","relationTo","value","id","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":"AAGA,OAAO,MAAMA,wBAA4C;IACvDC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;gBACN,GAAGF,UAAUE,MAAM;YACrB;YACAC,QAAQ;YACRC,YAAYJ,UAAUI,UAAU;YAChCC,OAAO;gBACLC,IAAIN,UAAUK,KAAK,EAAEC,MAAM;YAC7B;YACAC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/upload/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { UploadConverterClient } from './client.js'\nimport { _SlateUploadConverter } from './converter.js'\n\nexport const SlateUploadConverter: SlateNodeConverterProvider = {\n  ClientComponent: UploadConverterClient,\n  converter: _SlateUploadConverter,\n}\n"],"names":["UploadConverterClient","_SlateUploadConverter","SlateUploadConverter","ClientComponent","converter"],"mappings":"AAEA,SAASA,qBAAqB,QAAQ,cAAa;AACnD,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,uBAAmD;IAC9DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/upload/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { UploadConverterClient } from './client.js'\nimport { _SlateUploadConverter } from './converter.js'\n\nexport const SlateUploadConverter: SlateNodeConverterProvider = {\n  ClientComponent: UploadConverterClient,\n  converter: _SlateUploadConverter,\n}\n"],"names":["UploadConverterClient","_SlateUploadConverter","SlateUploadConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,qBAAqB,QAAQ,cAAa;AACnD,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,uBAAmD;IAC9DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/field/features/migrations/slateToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from './types.js'\n\nimport { SlateBlockquoteConverter } from './converters/blockquote/index.js'\nimport { SlateHeadingConverter } from './converters/heading/index.js'\nimport { SlateIndentConverter } from './converters/indent/index.js'\nimport { SlateLinkConverter } from './converters/link/index.js'\nimport { SlateListItemConverter } from './converters/listItem/index.js'\nimport { SlateOrderedListConverter } from './converters/orderedList/index.js'\nimport { SlateRelationshipConverter } from './converters/relationship/index.js'\nimport { SlateUnknownConverter } from './converters/unknown/index.js'\nimport { SlateUnorderedListConverter } from './converters/unorderedList/index.js'\nimport { SlateUploadConverter } from './converters/upload/index.js'\n\nexport const defaultSlateConverters: SlateNodeConverterProvider[] = [\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,mCAAkC;AAC3E,SAASC,qBAAqB,QAAQ,gCAA+B;AACrE,SAASC,oBAAoB,QAAQ,+BAA8B;AACnE,SAASC,kBAAkB,QAAQ,6BAA4B;AAC/D,SAASC,sBAAsB,QAAQ,iCAAgC;AACvE,SAASC,yBAAyB,QAAQ,oCAAmC;AAC7E,SAASC,0BAA0B,QAAQ,qCAAoC;AAC/E,SAASC,qBAAqB,QAAQ,gCAA+B;AACrE,SAASC,2BAA2B,QAAQ,sCAAqC;AACjF,SAASC,oBAAoB,QAAQ,+BAA8B;AAEnE,OAAO,MAAMC,yBAAuD;IAClEV;IACAC;IACAC;IACAC;IACAC;IACAC;IACAC;IACAE;IACAC;IACAF;CACD,CAAA"}
+{"version":3,"sources":["../../../../../../src/field/features/migrations/slateToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from './types.js'\n\nimport { SlateBlockquoteConverter } from './converters/blockquote/index.js'\nimport { SlateHeadingConverter } from './converters/heading/index.js'\nimport { SlateIndentConverter } from './converters/indent/index.js'\nimport { SlateLinkConverter } from './converters/link/index.js'\nimport { SlateListItemConverter } from './converters/listItem/index.js'\nimport { SlateOrderedListConverter } from './converters/orderedList/index.js'\nimport { SlateRelationshipConverter } from './converters/relationship/index.js'\nimport { SlateUnknownConverter } from './converters/unknown/index.js'\nimport { SlateUnorderedListConverter } from './converters/unorderedList/index.js'\nimport { SlateUploadConverter } from './converters/upload/index.js'\n\nexport const defaultSlateConverters: SlateNodeConverterProvider[] = [\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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,wBAAwB,QAAQ,mCAAkC;AAC3E,SAASC,qBAAqB,QAAQ,gCAA+B;AACrE,SAASC,oBAAoB,QAAQ,+BAA8B;AACnE,SAASC,kBAAkB,QAAQ,6BAA4B;AAC/D,SAASC,sBAAsB,QAAQ,iCAAgC;AACvE,SAASC,yBAAyB,QAAQ,oCAAmC;AAC7E,SAASC,0BAA0B,QAAQ,qCAAoC;AAC/E,SAASC,qBAAqB,QAAQ,gCAA+B;AACrE,SAASC,2BAA2B,QAAQ,sCAAqC;AACjF,SAASC,oBAAoB,QAAQ,+BAA8B;AAEnE,OAAO,MAAMC,yBAAuD;IAClEV;IACAC;IACAC;IACAC;IACAC;IACAC;IACAC;IACAE;IACAC;IACAF;CACD,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/field/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) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  return (\n    slateNodes.map((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          // This is a simple text node. canContainParagraphs may be false if this is nested inside of 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) => converter.nodeTypes.includes(slateNode.type))\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    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","map","slateNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node","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":"AASA,SAASA,UAAU,QAAQ,0CAAyC;AAEpE,OAAO,SAASC,sBAAsB,EACpCC,UAAU,EACVC,SAAS,EAIV;IACC,OAAO;QACLC,MAAM;YACJC,MAAM;YACNC,UAAUC,2BAA2B;gBACnCC,sBAAsB;gBACtBN;gBACAO,gBAAgB;gBAChBC,YAAYP;YACd;YACAQ,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;AACF;AAEA,OAAO,SAASP,2BAA2B,EACzCC,oBAAoB,EACpBN,UAAU,EACVO,cAAc,EACdC,UAAU,EASX;IACC,IAAI,CAACR,YAAYa,QAAQ;QACvB,OAAO,EAAE;IACX;IACA,MAAMC,mBAAmBd,WAAWe,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IACrF,OACEV,WAAWW,GAAG,CAAC,CAACC,WAAWC;QACzB,IAAI,CAAE,CAAA,UAAUD,SAAQ,GAAI;YAC1B,IAAId,sBAAsB;gBACxB,sEAAsE;gBACtE,OAAOgB,qBAAqBtB,YAAYoB;YAC1C,OAAO;gBACL,4JAA4J;gBAC5J,OAAOG,gBAAgBH;YACzB;QACF;QACA,IAAIA,UAAUjB,IAAI,KAAK,KAAK;YAC1B,OAAOmB,qBAAqBtB,YAAYoB;QAC1C;QAEA,MAAMJ,YAAYhB,WAAWe,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAACE,UAAUjB,IAAI;QAE5F,IAAIa,WAAW;YACb,OAAOA,UAAUA,SAAS,CAAC;gBAAEQ,YAAYH;gBAAGrB;gBAAYO;gBAAgBa;YAAU;QACpF;QAEAK,QAAQC,IAAI,CAAC,wDAAwDN,UAAUjB,IAAI;QACnF,OAAOW,kBAAkBE,UAAU;YACjCQ,YAAYH;YACZrB;YACAO;YACAa;QACF;IACF,MAAM,EAAE;AAEZ;AAEA,OAAO,SAASE,qBACdtB,UAAgC,EAChC2B,IAAe;IAEf,OAAO;QACLxB,MAAM;QACNC,UAAUC,2BAA2B;YACnCC,sBAAsB;YACtBN;YACAO,gBAAgB;YAChBC,YAAYmB,KAAKvB,QAAQ,IAAI,EAAE;QACjC;QACAK,WAAW;QACXC,QAAQ;QACRC,QAAQ;QACRC,SAAS;IACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAAe;IAC7C,OAAO;QACLxB,MAAM;QACNyB,QAAQ;QACRlB,QAAQmB,oBAAoBF;QAC5BG,MAAM;QACNC,OAAO;QACPC,MAAML,KAAKK,IAAI;QACfpB,SAAS;IACX;AACF;AAEA,OAAO,SAASiB,oBAAoBF,IAAe;IACjD,IAAIjB,SAAS;IACb,IAAIiB,KAAKM,IAAI,EAAE;QACbvB,SAASA,SAASZ,WAAWoC,OAAO;IACtC;IACA,IAAIP,KAAKQ,MAAM,EAAE;QACfzB,SAASA,SAASZ,WAAWsC,SAAS;IACxC;IACA,IAAIT,KAAKU,aAAa,EAAE;QACtB3B,SAASA,SAASZ,WAAWwC,gBAAgB;IAC/C;IACA,IAAIX,KAAKY,SAAS,EAAE;QAClB7B,SAASA,SAASZ,WAAW0C,YAAY;IAC3C;IACA,IAAIb,KAAKc,SAAS,EAAE;QAClB/B,SAASA,SAASZ,WAAW4C,YAAY;IAC3C;IACA,IAAIf,KAAKgB,WAAW,EAAE;QACpBjC,SAASA,SAASZ,WAAW8C,cAAc;IAC7C;IACA,IAAIjB,KAAKkB,IAAI,EAAE;QACbnC,SAASA,SAASZ,WAAWgD,OAAO;IACtC;IACA,OAAOpC;AACT"}
+{"version":3,"sources":["../../../../../../src/field/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) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  return (\n    slateNodes.map((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          // This is a simple text node. canContainParagraphs may be false if this is nested inside of 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) => converter.nodeTypes.includes(slateNode.type))\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    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","map","slateNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node","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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AASA,SAASA,UAAU,QAAQ,0CAAyC;AAEpE,OAAO,SAASC,sBAAsB,EACpCC,UAAU,EACVC,SAAS,EAIV;IACC,OAAO;QACLC,MAAM;YACJC,MAAM;YACNC,UAAUC,2BAA2B;gBACnCC,sBAAsB;gBACtBN;gBACAO,gBAAgB;gBAChBC,YAAYP;YACd;YACAQ,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;AACF;AAEA,OAAO,SAASP,2BAA2B,EACzCC,oBAAoB,EACpBN,UAAU,EACVO,cAAc,EACdC,UAAU,EASX;IACC,IAAI,CAACR,YAAYa,QAAQ;QACvB,OAAO,EAAE;IACX;IACA,MAAMC,mBAAmBd,WAAWe,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IACrF,OACEV,WAAWW,GAAG,CAAC,CAACC,WAAWC;QACzB,IAAI,CAAE,CAAA,UAAUD,SAAQ,GAAI;YAC1B,IAAId,sBAAsB;gBACxB,sEAAsE;gBACtE,OAAOgB,qBAAqBtB,YAAYoB;YAC1C,OAAO;gBACL,4JAA4J;gBAC5J,OAAOG,gBAAgBH;YACzB;QACF;QACA,IAAIA,UAAUjB,IAAI,KAAK,KAAK;YAC1B,OAAOmB,qBAAqBtB,YAAYoB;QAC1C;QAEA,MAAMJ,YAAYhB,WAAWe,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAACE,UAAUjB,IAAI;QAE5F,IAAIa,WAAW;YACb,OAAOA,UAAUA,SAAS,CAAC;gBAAEQ,YAAYH;gBAAGrB;gBAAYO;gBAAgBa;YAAU;QACpF;QAEAK,QAAQC,IAAI,CAAC,wDAAwDN,UAAUjB,IAAI;QACnF,OAAOW,kBAAkBE,UAAU;YACjCQ,YAAYH;YACZrB;YACAO;YACAa;QACF;IACF,MAAM,EAAE;AAEZ;AAEA,OAAO,SAASE,qBACdtB,UAAgC,EAChC2B,IAAe;IAEf,OAAO;QACLxB,MAAM;QACNC,UAAUC,2BAA2B;YACnCC,sBAAsB;YACtBN;YACAO,gBAAgB;YAChBC,YAAYmB,KAAKvB,QAAQ,IAAI,EAAE;QACjC;QACAK,WAAW;QACXC,QAAQ;QACRC,QAAQ;QACRC,SAAS;IACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAAe;IAC7C,OAAO;QACLxB,MAAM;QACNyB,QAAQ;QACRlB,QAAQmB,oBAAoBF;QAC5BG,MAAM;QACNC,OAAO;QACPC,MAAML,KAAKK,IAAI;QACfpB,SAAS;IACX;AACF;AAEA,OAAO,SAASiB,oBAAoBF,IAAe;IACjD,IAAIjB,SAAS;IACb,IAAIiB,KAAKM,IAAI,EAAE;QACbvB,SAASA,SAASZ,WAAWoC,OAAO;IACtC;IACA,IAAIP,KAAKQ,MAAM,EAAE;QACfzB,SAASA,SAASZ,WAAWsC,SAAS;IACxC;IACA,IAAIT,KAAKU,aAAa,EAAE;QACtB3B,SAASA,SAASZ,WAAWwC,gBAAgB;IAC/C;IACA,IAAIX,KAAKY,SAAS,EAAE;QAClB7B,SAASA,SAASZ,WAAW0C,YAAY;IAC3C;IACA,IAAIb,KAAKc,SAAS,EAAE;QAClB/B,SAASA,SAASZ,WAAW4C,YAAY;IAC3C;IACA,IAAIf,KAAKgB,WAAW,EAAE;QACpBjC,SAASA,SAASZ,WAAW8C,cAAc;IAC7C;IACA,IAAIjB,KAAKkB,IAAI,EAAE;QACbnC,SAASA,SAASZ,WAAWgD,OAAO;IACtC;IACA,OAAOpC;AACT"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/field/features/migrations/slateToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type React from 'react'\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\nexport type SlateNodeConverterClientComponent = React.FC<{\n  componentKey: string\n  featureKey: string\n}>\n\nexport type SlateNodeConverterProvider = {\n  ClientComponent: SlateNodeConverterClientComponent\n  converter: SlateNodeConverter\n}\n"],"names":[],"mappings":"AA6BA,WAGC"}
+{"version":3,"sources":["../../../../../../src/field/features/migrations/slateToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type React from 'react'\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\nexport type SlateNodeConverterClientComponent = React.FC<{\n  componentKey: string\n  featureKey: string\n}>\n\nexport type SlateNodeConverterProvider = {\n  ClientComponent: SlateNodeConverterClientComponent\n  converter: SlateNodeConverter\n}\n"],"names":[],"rangeMappings":"","mappings":"AA6BA,WAGC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/features/migrations/slateToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from '../../types.js'\nimport type { SlateNodeConverter } from './converter/types.js'\n\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { convertSlateToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nconst SlateToLexicalFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: ({ clientFunctions }) => {\n      const converters: SlateNodeConverter[] = Object.values(clientFunctions)\n\n      return {\n        clientFeatureProps: props,\n        hooks: {\n          load({ incomingEditorState }) {\n            if (\n              !incomingEditorState ||\n              !Array.isArray(incomingEditorState) ||\n              'root' in incomingEditorState\n            ) {\n              // incomingEditorState null or not from Slate\n              return incomingEditorState\n            }\n            // Slate => convert to lexical\n\n            return convertSlateToLexical({\n              converters,\n              slateData: incomingEditorState,\n            })\n          },\n        },\n        nodes: [UnknownConvertedNode],\n      }\n    },\n  }\n}\n\nexport const SlateToLexicalFeatureClientComponent = createClientComponent(\n  SlateToLexicalFeatureClient,\n)\n"],"names":["createClientComponent","convertSlateToLexical","UnknownConvertedNode","SlateToLexicalFeatureClient","props","clientFeatureProps","feature","clientFunctions","converters","Object","values","hooks","load","incomingEditorState","Array","isArray","slateData","nodes","SlateToLexicalFeatureClientComponent"],"mappings":"AAAA;AAKA,SAASA,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,qBAAqB,QAAQ,uBAAsB;AAC5D,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,MAAMC,8BAAwE,CAACC;IAC7E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,CAAC,EAAEC,eAAe,EAAE;YAC3B,MAAMC,aAAmCC,OAAOC,MAAM,CAACH;YAEvD,OAAO;gBACLF,oBAAoBD;gBACpBO,OAAO;oBACLC,MAAK,EAAEC,mBAAmB,EAAE;wBAC1B,IACE,CAACA,uBACD,CAACC,MAAMC,OAAO,CAACF,wBACf,UAAUA,qBACV;4BACA,6CAA6C;4BAC7C,OAAOA;wBACT;wBACA,8BAA8B;wBAE9B,OAAOZ,sBAAsB;4BAC3BO;4BACAQ,WAAWH;wBACb;oBACF;gBACF;gBACAI,OAAO;oBAACf;iBAAqB;YAC/B;QACF;IACF;AACF;AAEA,OAAO,MAAMgB,uCAAuClB,sBAClDG,6BACD"}
+{"version":3,"sources":["../../../../../src/field/features/migrations/slateToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from '../../types.js'\nimport type { SlateNodeConverter } from './converter/types.js'\n\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { convertSlateToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nconst SlateToLexicalFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: ({ clientFunctions }) => {\n      const converters: SlateNodeConverter[] = Object.values(clientFunctions)\n\n      return {\n        clientFeatureProps: props,\n        hooks: {\n          load({ incomingEditorState }) {\n            if (\n              !incomingEditorState ||\n              !Array.isArray(incomingEditorState) ||\n              'root' in incomingEditorState\n            ) {\n              // incomingEditorState null or not from Slate\n              return incomingEditorState\n            }\n            // Slate => convert to lexical\n\n            return convertSlateToLexical({\n              converters,\n              slateData: incomingEditorState,\n            })\n          },\n        },\n        nodes: [UnknownConvertedNode],\n      }\n    },\n  }\n}\n\nexport const SlateToLexicalFeatureClientComponent = createClientComponent(\n  SlateToLexicalFeatureClient,\n)\n"],"names":["createClientComponent","convertSlateToLexical","UnknownConvertedNode","SlateToLexicalFeatureClient","props","clientFeatureProps","feature","clientFunctions","converters","Object","values","hooks","load","incomingEditorState","Array","isArray","slateData","nodes","SlateToLexicalFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAKA,SAASA,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,qBAAqB,QAAQ,uBAAsB;AAC5D,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,MAAMC,8BAAwE,CAACC;IAC7E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,CAAC,EAAEC,eAAe,EAAE;YAC3B,MAAMC,aAAmCC,OAAOC,MAAM,CAACH;YAEvD,OAAO;gBACLF,oBAAoBD;gBACpBO,OAAO;oBACLC,MAAK,EAAEC,mBAAmB,EAAE;wBAC1B,IACE,CAACA,uBACD,CAACC,MAAMC,OAAO,CAACF,wBACf,UAAUA,qBACV;4BACA,6CAA6C;4BAC7C,OAAOA;wBACT;wBACA,8BAA8B;wBAE9B,OAAOZ,sBAAsB;4BAC3BO;4BACAQ,WAAWH;wBACb;oBACF;gBACF;gBACAI,OAAO;oBAACf;iBAAqB;YAC/B;QACF;IACF;AACF;AAEA,OAAO,MAAMgB,uCAAuClB,sBAClDG,6BACD"}