@payloadcms/richtext-lexical 3.0.0-beta.52 → 3.0.0-beta.54

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/heading/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,gBAAgB,CAAA;AAKxE,eAAO,MAAM,gBAAgB,EAAE,kCAG9B,CAAA"}

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

@@ -1,8 +0,0 @@
-import { HeadingConverterClient } from './client.js';
-import { _HeadingConverter } from './converter.js';
-export const HeadingConverter = {
-    ClientComponent: HeadingConverterClient,
-    converter: _HeadingConverter
-};
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/heading/index.ts"],"sourcesContent":["import type { LexicalPluginNodeConverterProvider } from '../../types.js'\n\nimport { HeadingConverterClient } from './client.js'\nimport { _HeadingConverter } from './converter.js'\n\nexport const HeadingConverter: LexicalPluginNodeConverterProvider = {\n  ClientComponent: HeadingConverterClient,\n  converter: _HeadingConverter,\n}\n"],"names":["HeadingConverterClient","_HeadingConverter","HeadingConverter","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/link/client.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-export declare const LinkConverterClient: import("react").FC<{
-    componentKey: string;
-    featureKey: string;
-}>;
-//# sourceMappingURL=client.d.ts.map

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/link/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/link/client.ts"],"names":[],"mappings":";AAIA,eAAO,MAAM,mBAAmB;;;EAA6C,CAAA"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/link/converter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,cAAc,EAAE,0BA2B5B,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/link/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedLinkNode } from '../../../../../link/nodes/types.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const _LinkConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode }) {\n    return {\n      type: 'link',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'link',\n      }),\n      direction: (lexicalPluginNode as any).direction || 'ltr',\n      fields: {\n        doc: (lexicalPluginNode as any).attributes?.doc\n          ? {\n              relationTo: (lexicalPluginNode as any).attributes?.doc?.relationTo,\n              value: (lexicalPluginNode as any).attributes?.doc?.value,\n            }\n          : undefined,\n        linkType: (lexicalPluginNode as any).attributes?.linkType || 'custom',\n        newTab: (lexicalPluginNode as any).attributes?.newTab || false,\n        url: (lexicalPluginNode as any).attributes?.url || undefined,\n      },\n      format: (lexicalPluginNode as any).format || '',\n      indent: (lexicalPluginNode as any).indent || 0,\n      version: 2,\n    } as const as SerializedLinkNode\n  },\n  nodeTypes: ['link'],\n}\n"],"names":["convertLexicalPluginNodesToLexical","_LinkConverter","converter","converters","lexicalPluginNode","type","children","lexicalPluginNodes","parentNodeType","direction","fields","doc","attributes","relationTo","value","undefined","linkType","newTab","url","format","indent","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,qDAAqD,GAKrD,SAASA,kCAAkC,QAAQ,iBAAgB;AAEnE,OAAO,MAAMC,iBAA6C;IACxDC,WAAU,EAAEC,UAAU,EAAEC,iBAAiB,EAAE;QACzC,OAAO;YACLC,MAAM;YACNC,UAAUN,mCAAmC;gBAC3CG;gBACAI,oBAAoBH,kBAAkBE,QAAQ;gBAC9CE,gBAAgB;YAClB;YACAC,WAAW,AAACL,kBAA0BK,SAAS,IAAI;YACnDC,QAAQ;gBACNC,KAAK,AAACP,kBAA0BQ,UAAU,EAAED,MACxC;oBACEE,YAAY,AAACT,kBAA0BQ,UAAU,EAAED,KAAKE;oBACxDC,OAAO,AAACV,kBAA0BQ,UAAU,EAAED,KAAKG;gBACrD,IACAC;gBACJC,UAAU,AAACZ,kBAA0BQ,UAAU,EAAEI,YAAY;gBAC7DC,QAAQ,AAACb,kBAA0BQ,UAAU,EAAEK,UAAU;gBACzDC,KAAK,AAACd,kBAA0BQ,UAAU,EAAEM,OAAOH;YACrD;YACAI,QAAQ,AAACf,kBAA0Be,MAAM,IAAI;YAC7CC,QAAQ,AAAChB,kBAA0BgB,MAAM,IAAI;YAC7CC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAO;AACrB,EAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/link/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,gBAAgB,CAAA;AAKxE,eAAO,MAAM,aAAa,EAAE,kCAG3B,CAAA"}

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

@@ -1,8 +0,0 @@
-import { LinkConverterClient } from './client.js';
-import { _LinkConverter } from './converter.js';
-export const LinkConverter = {
-    ClientComponent: LinkConverterClient,
-    converter: _LinkConverter
-};
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/link/index.ts"],"sourcesContent":["import type { LexicalPluginNodeConverterProvider } from '../../types.js'\n\nimport { LinkConverterClient } from './client.js'\nimport { _LinkConverter } from './converter.js'\n\nexport const LinkConverter: LexicalPluginNodeConverterProvider = {\n  ClientComponent: LinkConverterClient,\n  converter: _LinkConverter,\n}\n"],"names":["LinkConverterClient","_LinkConverter","LinkConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,mBAAmB,QAAQ,cAAa;AACjD,SAASC,cAAc,QAAQ,iBAAgB;AAE/C,OAAO,MAAMC,gBAAoD;IAC/DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/list/client.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-export declare const ListConverterClient: import("react").FC<{
-    componentKey: string;
-    featureKey: string;
-}>;
-//# sourceMappingURL=client.d.ts.map

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/list/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/list/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,mBAAmB;;;EAA6C,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/list/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _ListConverter } from './converter.js'\n\nexport const ListConverterClient = createFeaturePropComponent(_ListConverter)\n"],"names":["createFeaturePropComponent","_ListConverter","ListConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,cAAc,QAAQ,iBAAgB;AAE/C,OAAO,MAAMC,sBAAsBF,2BAA2BC,gBAAe"}

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/list/converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/list/converter.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,cAAc,EAAE,0BAgB5B,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/list/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedListNode } from '@lexical/list'\n\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const _ListConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode }) {\n    return {\n      ...lexicalPluginNode,\n      type: 'list',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'list',\n      }),\n      listType: (lexicalPluginNode as any)?.listType || 'number',\n      tag: (lexicalPluginNode as any)?.tag || 'ol',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['list'],\n}\n"],"names":["convertLexicalPluginNodesToLexical","_ListConverter","converter","converters","lexicalPluginNode","type","children","lexicalPluginNodes","parentNodeType","listType","tag","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":"AAAA,qDAAqD,GAMrD,SAASA,kCAAkC,QAAQ,iBAAgB;AAEnE,OAAO,MAAMC,iBAA6C;IACxDC,WAAU,EAAEC,UAAU,EAAEC,iBAAiB,EAAE;QACzC,OAAO;YACL,GAAGA,iBAAiB;YACpBC,MAAM;YACNC,UAAUN,mCAAmC;gBAC3CG;gBACAI,oBAAoBH,kBAAkBE,QAAQ;gBAC9CE,gBAAgB;YAClB;YACAC,UAAU,AAACL,mBAA2BK,YAAY;YAClDC,KAAK,AAACN,mBAA2BM,OAAO;YACxCC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAO;AACrB,EAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/list/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,gBAAgB,CAAA;AAKxE,eAAO,MAAM,aAAa,EAAE,kCAG3B,CAAA"}

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

@@ -1,8 +0,0 @@
-import { ListConverterClient } from './client.js';
-import { _ListConverter } from './converter.js';
-export const ListConverter = {
-    ClientComponent: ListConverterClient,
-    converter: _ListConverter
-};
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/list/index.ts"],"sourcesContent":["import type { LexicalPluginNodeConverterProvider } from '../../types.js'\n\nimport { ListConverterClient } from './client.js'\nimport { _ListConverter } from './converter.js'\n\nexport const ListConverter: LexicalPluginNodeConverterProvider = {\n  ClientComponent: ListConverterClient,\n  converter: _ListConverter,\n}\n"],"names":["ListConverterClient","_ListConverter","ListConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,mBAAmB,QAAQ,cAAa;AACjD,SAASC,cAAc,QAAQ,iBAAgB;AAE/C,OAAO,MAAMC,gBAAoD;IAC/DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/listItem/client.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-export declare const ListItemConverterClient: import("react").FC<{
-    componentKey: string;
-    featureKey: string;
-}>;
-//# sourceMappingURL=client.d.ts.map

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/listItem/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/listItem/client.ts"],"names":[],"mappings":";AAIA,eAAO,MAAM,uBAAuB;;;EAAiD,CAAA"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/listItem/converter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,kBAAkB,EAAE,0BAgBhC,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '@lexical/list'\n\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const _ListItemConverter: LexicalPluginNodeConverter = {\n  converter({ childIndex, converters, lexicalPluginNode }) {\n    return {\n      ...lexicalPluginNode,\n      type: 'listitem',\n      checked: undefined,\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'listitem',\n      }),\n      value: childIndex + 1,\n      version: 1,\n    } as const as SerializedListItemNode\n  },\n  nodeTypes: ['listitem'],\n}\n"],"names":["convertLexicalPluginNodesToLexical","_ListItemConverter","converter","childIndex","converters","lexicalPluginNode","type","checked","undefined","children","lexicalPluginNodes","parentNodeType","value","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,kCAAkC,QAAQ,iBAAgB;AAEnE,OAAO,MAAMC,qBAAiD;IAC5DC,WAAU,EAAEC,UAAU,EAAEC,UAAU,EAAEC,iBAAiB,EAAE;QACrD,OAAO;YACL,GAAGA,iBAAiB;YACpBC,MAAM;YACNC,SAASC;YACTC,UAAUT,mCAAmC;gBAC3CI;gBACAM,oBAAoBL,kBAAkBI,QAAQ;gBAC9CE,gBAAgB;YAClB;YACAC,OAAOT,aAAa;YACpBU,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAW;AACzB,EAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/listItem/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,gBAAgB,CAAA;AAKxE,eAAO,MAAM,iBAAiB,EAAE,kCAG/B,CAAA"}

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

@@ -1,8 +0,0 @@
-import { ListItemConverterClient } from './client.js';
-import { _ListItemConverter } from './converter.js';
-export const ListItemConverter = {
-    ClientComponent: ListItemConverterClient,
-    converter: _ListItemConverter
-};
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/listItem/index.ts"],"sourcesContent":["import type { LexicalPluginNodeConverterProvider } from '../../types.js'\n\nimport { ListItemConverterClient } from './client.js'\nimport { _ListItemConverter } from './converter.js'\n\nexport const ListItemConverter: LexicalPluginNodeConverterProvider = {\n  ClientComponent: ListItemConverterClient,\n  converter: _ListItemConverter,\n}\n"],"names":["ListItemConverterClient","_ListItemConverter","ListItemConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,uBAAuB,QAAQ,cAAa;AACrD,SAASC,kBAAkB,QAAQ,iBAAgB;AAEnD,OAAO,MAAMC,oBAAwD;IACnEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/quote/client.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-export declare const QuoteConverterClient: import("react").FC<{
-    componentKey: string;
-    featureKey: string;
-}>;
-//# sourceMappingURL=client.d.ts.map

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/quote/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/quote/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,oBAAoB;;;EAA8C,CAAA"}

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

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

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,eAAe,EAAE,0BAc7B,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '@lexical/rich-text'\n\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const _QuoteConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode }) {\n    return {\n      ...lexicalPluginNode,\n      type: 'quote',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'quote',\n      }),\n      version: 1,\n    } as const as SerializedQuoteNode\n  },\n  nodeTypes: ['quote'],\n}\n"],"names":["convertLexicalPluginNodesToLexical","_QuoteConverter","converter","converters","lexicalPluginNode","type","children","lexicalPluginNodes","parentNodeType","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,kCAAkC,QAAQ,iBAAgB;AAEnE,OAAO,MAAMC,kBAA8C;IACzDC,WAAU,EAAEC,UAAU,EAAEC,iBAAiB,EAAE;QACzC,OAAO;YACL,GAAGA,iBAAiB;YACpBC,MAAM;YACNC,UAAUN,mCAAmC;gBAC3CG;gBACAI,oBAAoBH,kBAAkBE,QAAQ;gBAC9CE,gBAAgB;YAClB;YACAC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAQ;AACtB,EAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/quote/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,gBAAgB,CAAA;AAKxE,eAAO,MAAM,cAAc,EAAE,kCAG5B,CAAA"}

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

@@ -1,8 +0,0 @@
-import { QuoteConverterClient } from './client.js';
-import { _QuoteConverter } from './converter.js';
-export const QuoteConverter = {
-    ClientComponent: QuoteConverterClient,
-    converter: _QuoteConverter
-};
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/quote/index.ts"],"sourcesContent":["import type { LexicalPluginNodeConverterProvider } from '../../types.js'\n\nimport { QuoteConverterClient } from './client.js'\nimport { _QuoteConverter } from './converter.js'\n\nexport const QuoteConverter: LexicalPluginNodeConverterProvider = {\n  ClientComponent: QuoteConverterClient,\n  converter: _QuoteConverter,\n}\n"],"names":["QuoteConverterClient","_QuoteConverter","QuoteConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,oBAAoB,QAAQ,cAAa;AAClD,SAASC,eAAe,QAAQ,iBAAgB;AAEhD,OAAO,MAAMC,iBAAqD;IAChEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/unknown/client.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-export declare const UnknownConverterClient: import("react").FC<{
-    componentKey: string;
-    featureKey: string;
-}>;
-//# sourceMappingURL=client.d.ts.map

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/unknown/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/unknown/client.ts"],"names":[],"mappings":";AAIA,eAAO,MAAM,sBAAsB;;;EAAgD,CAAA"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,iBAAiB,EAAE,0BAoB/B,CAAA"}

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

@@ -1 +0,0 @@
-{"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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/unknown/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,gBAAgB,CAAA;AAKxE,eAAO,MAAM,gBAAgB,EAAE,kCAG9B,CAAA"}

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

@@ -1,8 +0,0 @@
-import { UnknownConverterClient } from './client.js';
-import { _UnknownConverter } from './converter.js';
-export const UnknownConverter = {
-    ClientComponent: UnknownConverterClient,
-    converter: _UnknownConverter
-};
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"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.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-export declare const UploadConverterClient: import("react").FC<{
-    componentKey: string;
-    featureKey: string;
-}>;
-//# sourceMappingURL=client.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,qBAAqB;;;EAA+C,CAAA"}

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

@@ -1 +0,0 @@
-{"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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAEhE,eAAO,MAAM,gBAAgB,EAAE,0BAkB9B,CAAA"}

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

@@ -1 +0,0 @@
-{"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: (lexicalPluginNode as any)?.rawImagePayload?.value?.id || '',\n      version: 2,\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,AAACR,mBAA2BO,iBAAiBC,OAAOC,MAAM;YACjEC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,gBAAgB,CAAA;AAKxE,eAAO,MAAM,eAAe,EAAE,kCAG7B,CAAA"}

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

@@ -1,8 +0,0 @@
-import { UploadConverterClient } from './client.js';
-import { _UploadConverter } from './converter.js';
-export const UploadConverter = {
-    ClientComponent: UploadConverterClient,
-    converter: _UploadConverter
-};
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,YAAY,CAAA;AAUpE,eAAO,MAAM,iBAAiB,EAAE,kCAAkC,EAQjE,CAAA"}

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

@@ -1 +0,0 @@
-{"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.d.ts.map

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

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

@@ -1 +0,0 @@
-{"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.d.ts

@@ -1,31 +0,0 @@
-import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
-import type React from 'react';
-export type LexicalPluginNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
-    converter: ({ childIndex, converters, lexicalPluginNode, parentNodeType, }: {
-        childIndex: number;
-        converters: LexicalPluginNodeConverter[];
-        lexicalPluginNode: SerializedLexicalNode & {
-            children?: SerializedLexicalNode[];
-        };
-        parentNodeType: string;
-    }) => T;
-    nodeTypes: string[];
-};
-export type PayloadPluginLexicalData = {
-    characters: number;
-    comments: unknown[];
-    html?: string;
-    jsonContent: SerializedEditorState;
-    markdown?: string;
-    preview: string;
-    words: number;
-};
-export type LexicalPluginNodeConverterClientComponent = React.FC<{
-    componentKey: string;
-    featureKey: string;
-}>;
-export type LexicalPluginNodeConverterProvider = {
-    ClientComponent: LexicalPluginNodeConverterClientComponent;
-    converter: LexicalPluginNodeConverter;
-};
-//# sourceMappingURL=types.d.ts.map

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

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

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

@@ -1 +0,0 @@
-{"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.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-export declare const LexicalPluginToLexicalFeatureClientComponent: import("react").FC<{
-    featureKey: string;
-    order: number;
-}>;
-//# sourceMappingURL=feature.client.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"names":[],"mappings":";AAqCA,eAAO,MAAM,4CAA4C;;;EAExD,CAAA"}

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

@@ -1,34 +0,0 @@
-'use client';
-import { createClientComponent } from '../../createClientComponent.js';
-import { convertLexicalPluginToLexical } from './converter/index.js';
-import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
-const LexicalPluginToLexicalFeatureClient = (props)=>{
-    return {
-        clientFeatureProps: props,
-        feature: ({ clientFunctions, resolvedFeatures })=>{
-            const converters = Object.values(clientFunctions);
-            return {
-                clientFeatureProps: props,
-                hooks: {
-                    load ({ incomingEditorState }) {
-                        if (!incomingEditorState || !('jsonContent' in incomingEditorState)) {
-                            // incomingEditorState null or not from Lexical Plugin
-                            return incomingEditorState;
-                        }
-                        // Lexical Plugin => convert to lexical
-                        return convertLexicalPluginToLexical({
-                            converters,
-                            lexicalPluginData: incomingEditorState
-                        });
-                    }
-                },
-                nodes: [
-                    UnknownConvertedNode
-                ]
-            };
-        }
-    };
-};
-export const LexicalPluginToLexicalFeatureClientComponent = createClientComponent(LexicalPluginToLexicalFeatureClient);
-
-//# sourceMappingURL=feature.client.js.map

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

@@ -1 +0,0 @@
-{"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.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/migrations/lexicalPluginToLexical/feature.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAA;AACnE,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,sBAAsB,CAAA;AAO9E,MAAM,MAAM,kCAAkC,GAAG;IAC/C,UAAU,CAAC,EACP,CAAC,CAAC,EACA,iBAAiB,GAClB,EAAE;QACD,iBAAiB,EAAE,kCAAkC,EAAE,CAAA;KACxD,KAAK,kCAAkC,EAAE,CAAC,GAC3C,kCAAkC,EAAE,CAAA;CACzC,CAAA;AAED,eAAO,MAAM,6BAA6B,EAAE,6BAA6B,CACvE,kCAAkC,EAClC,IAAI,CAgDL,CAAA"}

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

@@ -1,48 +0,0 @@
-// eslint-disable-next-line payload/no-imports-from-exports-dir
-import { LexicalPluginToLexicalFeatureClientComponent } from '../../../../exports/client/index.js';
-import { defaultConverters } from './converter/defaultConverters.js';
-import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
-export const LexicalPluginToLexicalFeature = (props)=>{
-    if (!props) {
-        props = {};
-    }
-    let converters = [];
-    if (props?.converters && typeof props?.converters === 'function') {
-        converters = props.converters({
-            defaultConverters
-        });
-    } else if (props.converters && typeof props?.converters !== 'function') {
-        converters = props.converters;
-    } else {
-        converters = defaultConverters;
-    }
-    props.converters = converters;
-    return {
-        feature: ()=>{
-            return {
-                ClientComponent: LexicalPluginToLexicalFeatureClientComponent,
-                clientFeatureProps: null,
-                generateComponentMap: ()=>{
-                    const map = {};
-                    for (const converter of converters){
-                        if (converter.ClientComponent) {
-                            const key = converter.converter.nodeTypes.join('-');
-                            map[key] = converter.ClientComponent;
-                        }
-                    }
-                    return map;
-                },
-                nodes: [
-                    {
-                        node: UnknownConvertedNode
-                    }
-                ],
-                serverFeatureProps: props
-            };
-        },
-        key: 'lexicalPluginToLexical',
-        serverFeatureProps: props
-    };
-};
-
-//# sourceMappingURL=feature.server.js.map

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

@@ -1 +0,0 @@
-{"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\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { LexicalPluginToLexicalFeatureClientComponent } from '../../../../exports/client/index.js'\nimport { defaultConverters } from './converter/defaultConverters.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type LexicalPluginToLexicalFeatureProps = {\n  converters?:\n    | (({\n        defaultConverters,\n      }: {\n        defaultConverters: LexicalPluginNodeConverterProvider[]\n      }) => LexicalPluginNodeConverterProvider[])\n    | LexicalPluginNodeConverterProvider[]\n}\n\nexport const LexicalPluginToLexicalFeature: 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":["LexicalPluginToLexicalFeatureClientComponent","defaultConverters","UnknownConvertedNode","LexicalPluginToLexicalFeature","props","converters","feature","ClientComponent","clientFeatureProps","generateComponentMap","map","converter","key","nodeTypes","join","nodes","node","serverFeatureProps"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,+DAA+D;AAC/D,SAASA,4CAA4C,QAAQ,sCAAqC;AAClG,SAASC,iBAAiB,QAAQ,mCAAkC;AACpE,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;YAAEJ;QAAkB;IACpD,OAAO,IAAIG,MAAMC,UAAU,IAAI,OAAOD,OAAOC,eAAe,YAAY;QACtEA,aAAaD,MAAMC,UAAU;IAC/B,OAAO;QACLA,aAAaJ;IACf;IAEAG,MAAMC,UAAU,GAAGA;IAEnB,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,iBAAiBP;gBACjBQ,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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Component.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAE1D,OAAO,cAAc,CAAA;AAErB,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,wBAAwB,CAAA;CAC/B,CAAA;AAED,eAAO,MAAM,6BAA6B,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAQzD,CAAA"}

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

@@ -1 +0,0 @@
-{"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;AAUzB,OAAO,MAAMC,gCAAiD,CAACC;IAC7D,MAAM,EAAEC,IAAI,EAAE,GAAGD;IAEjB,qBACE,MAACE;;YAAI;0BAC4C,KAACC;0BAAQF,MAAMG;;;;AAGpE,EAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAGhC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAGvC,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG,MAAM,CACjD;IACE,IAAI,EAAE,wBAAwB,CAAA;CAC/B,EACD,qBAAqB,CACtB,CAAA;AAQD,oBAAoB;AACpB,qBAAa,oBAAqB,SAAQ,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC;IAClE,MAAM,EAAE,wBAAwB,CAAA;gBAEpB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QAAE,IAAI,EAAE,wBAAwB,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE;IAK5E,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,oBAAoB,GAAG,oBAAoB;IAO9D,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,8BAA8B,GAAG,oBAAoB;IAKvF,kBAAkB,IAAI,IAAI;IAI1B,mBAAmB,IAAI,IAAI;IAI3B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,QAAQ,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI;IAI9B,UAAU,IAAI,8BAA8B;IAU5C,QAAQ,IAAI,OAAO;IAInB,SAAS,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO;CAGrE;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,GACL,EAAE;IACD,IAAI,EAAE,wBAAwB,CAAA;CAC/B,GAAG,oBAAoB,CAIvB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,oBAAoB,CAE9B"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../src/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical'\nimport type { JSX } from 'react'\n\nimport { addClassNamesToElement } from '@lexical/utils'\nimport { DecoratorNode } from 'lexical'\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":["addClassNamesToElement","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":";AAGA,SAASA,sBAAsB,QAAQ,iBAAgB;AACvD,SAASC,aAAa,QAAQ,UAAS;AACvC,YAAYC,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;QACvC3B,uBAAuByB,SAAS;QAChC,OAAOA;IACT;IAEAG,WAA+B;QAC7B,qBAAO,KAACzB;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.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-export declare const BlockquoteConverterClient: import("react").FC<{
-    componentKey: string;
-    featureKey: string;
-}>;
-//# sourceMappingURL=client.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/blockquote/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,yBAAyB;;;EAAwD,CAAA"}

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

@@ -1 +0,0 @@
-{"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.d.ts.map

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

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

@@ -1 +0,0 @@
-{"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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/blockquote/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAKhE,eAAO,MAAM,wBAAwB,EAAE,0BAGtC,CAAA"}