@payloadcms/richtext-lexical 0.1.7 → 0.1.9

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

@@ -0,0 +1 @@
+{"version":3,"file":"relationship.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/features/migrations/SlateToLexical/converter/converters/relationship.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAElD,eAAO,MAAM,qBAAqB,EAAE,kBAanC,CAAA"}

package/dist/field/features/migrations/SlateToLexical/converter/converters/relationship.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RelationshipConverter", {
+    enumerable: true,
+    get: function() {
+        return RelationshipConverter;
+    }
+});
+const RelationshipConverter = {
+    converter ({ slateNode }) {
+        return {
+            format: '',
+            relationTo: slateNode.relationTo,
+            type: 'relationship',
+            value: {
+                id: slateNode?.value?.id || ''
+            },
+            version: 1
+        };
+    },
+    nodeTypes: [
+        'relationship'
+    ]
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL1NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3JlbGF0aW9uc2hpcC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNlcmlhbGl6ZWRSZWxhdGlvbnNoaXBOb2RlIH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vLi4nXG5pbXBvcnQgdHlwZSB7IFNsYXRlTm9kZUNvbnZlcnRlciB9IGZyb20gJy4uL3R5cGVzJ1xuXG5leHBvcnQgY29uc3QgUmVsYXRpb25zaGlwQ29udmVydGVyOiBTbGF0ZU5vZGVDb252ZXJ0ZXIgPSB7XG4gIGNvbnZlcnRlcih7IHNsYXRlTm9kZSB9KSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGZvcm1hdDogJycsXG4gICAgICByZWxhdGlvblRvOiBzbGF0ZU5vZGUucmVsYXRpb25UbyxcbiAgICAgIHR5cGU6ICdyZWxhdGlvbnNoaXAnLFxuICAgICAgdmFsdWU6IHtcbiAgICAgICAgaWQ6IHNsYXRlTm9kZT8udmFsdWU/LmlkIHx8ICcnLFxuICAgICAgfSxcbiAgICAgIHZlcnNpb246IDEsXG4gICAgfSBhcyBjb25zdCBhcyBTZXJpYWxpemVkUmVsYXRpb25zaGlwTm9kZVxuICB9LFxuICBub2RlVHlwZXM6IFsncmVsYXRpb25zaGlwJ10sXG59XG4iXSwibmFtZXMiOlsiUmVsYXRpb25zaGlwQ29udmVydGVyIiwiY29udmVydGVyIiwic2xhdGVOb2RlIiwiZm9ybWF0IiwicmVsYXRpb25UbyIsInR5cGUiLCJ2YWx1ZSIsImlkIiwidmVyc2lvbiIsIm5vZGVUeXBlcyJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFHYUE7OztlQUFBQTs7O0FBQU4sTUFBTUEsd0JBQTRDO0lBQ3ZEQyxXQUFVLEVBQUVDLFNBQVMsRUFBRTtRQUNyQixPQUFPO1lBQ0xDLFFBQVE7WUFDUkMsWUFBWUYsVUFBVUUsVUFBVTtZQUNoQ0MsTUFBTTtZQUNOQyxPQUFPO2dCQUNMQyxJQUFJTCxXQUFXSSxPQUFPQyxNQUFNO1lBQzlCO1lBQ0FDLFNBQVM7UUFDWDtJQUNGO0lBQ0FDLFdBQVc7UUFBQztLQUFlO0FBQzdCIn0=

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

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from '../types';
+export declare const UnknownConverter: SlateNodeConverter;
+//# sourceMappingURL=unknown.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unknown.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/features/migrations/SlateToLexical/converter/converters/unknown.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAIlD,eAAO,MAAM,gBAAgB,EAAE,kBAqB9B,CAAA"}

package/dist/field/features/migrations/SlateToLexical/converter/converters/unknown.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UnknownConverter", {
+    enumerable: true,
+    get: function() {
+        return UnknownConverter;
+    }
+});
+const _ = require("..");
+const UnknownConverter = {
+    converter ({ converters, slateNode }) {
+        return {
+            children: (0, _.convertSlateNodesToLexical)({
+                canContainParagraphs: false,
+                converters,
+                parentNodeType: 'unknownConverted',
+                slateNodes: slateNode.children || []
+            }),
+            data: {
+                nodeData: slateNode,
+                nodeType: slateNode.type
+            },
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            type: 'unknownConverted',
+            version: 1
+        };
+    },
+    nodeTypes: [
+        'unknown'
+    ]
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/migrations/SlateToLexical/converter/converters/unorderedList.d.ts

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from '../types';
+export declare const UnorderedListConverter: SlateNodeConverter;
+//# sourceMappingURL=unorderedList.d.ts.map

package/dist/field/features/migrations/SlateToLexical/converter/converters/unorderedList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unorderedList.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/features/migrations/SlateToLexical/converter/converters/unorderedList.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAIlD,eAAO,MAAM,sBAAsB,EAAE,kBAoBpC,CAAA"}

package/dist/field/features/migrations/SlateToLexical/converter/converters/unorderedList.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UnorderedListConverter", {
+    enumerable: true,
+    get: function() {
+        return UnorderedListConverter;
+    }
+});
+const _ = require("..");
+const UnorderedListConverter = {
+    converter ({ converters, slateNode }) {
+        return {
+            children: (0, _.convertSlateNodesToLexical)({
+                canContainParagraphs: false,
+                converters,
+                parentNodeType: 'list',
+                slateNodes: slateNode.children || []
+            }),
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            listType: 'bullet',
+            start: 1,
+            tag: 'ul',
+            type: 'list',
+            version: 1
+        };
+    },
+    nodeTypes: [
+        'ul'
+    ]
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL1NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3Vub3JkZXJlZExpc3QudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTZXJpYWxpemVkTGlzdE5vZGUgfSBmcm9tICdAbGV4aWNhbC9saXN0J1xuXG5pbXBvcnQgdHlwZSB7IFNsYXRlTm9kZUNvbnZlcnRlciB9IGZyb20gJy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBjb252ZXJ0U2xhdGVOb2Rlc1RvTGV4aWNhbCB9IGZyb20gJy4uJ1xuXG5leHBvcnQgY29uc3QgVW5vcmRlcmVkTGlzdENvbnZlcnRlcjogU2xhdGVOb2RlQ29udmVydGVyID0ge1xuICBjb252ZXJ0ZXIoeyBjb252ZXJ0ZXJzLCBzbGF0ZU5vZGUgfSkge1xuICAgIHJldHVybiB7XG4gICAgICBjaGlsZHJlbjogY29udmVydFNsYXRlTm9kZXNUb0xleGljYWwoe1xuICAgICAgICBjYW5Db250YWluUGFyYWdyYXBoczogZmFsc2UsXG4gICAgICAgIGNvbnZlcnRlcnMsXG4gICAgICAgIHBhcmVudE5vZGVUeXBlOiAnbGlzdCcsXG4gICAgICAgIHNsYXRlTm9kZXM6IHNsYXRlTm9kZS5jaGlsZHJlbiB8fCBbXSxcbiAgICAgIH0pLFxuICAgICAgZGlyZWN0aW9uOiAnbHRyJyxcbiAgICAgIGZvcm1hdDogJycsXG4gICAgICBpbmRlbnQ6IDAsXG4gICAgICBsaXN0VHlwZTogJ2J1bGxldCcsXG4gICAgICBzdGFydDogMSxcbiAgICAgIHRhZzogJ3VsJyxcbiAgICAgIHR5cGU6ICdsaXN0JyxcbiAgICAgIHZlcnNpb246IDEsXG4gICAgfSBhcyBjb25zdCBhcyBTZXJpYWxpemVkTGlzdE5vZGVcbiAgfSxcbiAgbm9kZVR5cGVzOiBbJ3VsJ10sXG59XG4iXSwibmFtZXMiOlsiVW5vcmRlcmVkTGlzdENvbnZlcnRlciIsImNvbnZlcnRlciIsImNvbnZlcnRlcnMiLCJzbGF0ZU5vZGUiLCJjaGlsZHJlbiIsImNvbnZlcnRTbGF0ZU5vZGVzVG9MZXhpY2FsIiwiY2FuQ29udGFpblBhcmFncmFwaHMiLCJwYXJlbnROb2RlVHlwZSIsInNsYXRlTm9kZXMiLCJkaXJlY3Rpb24iLCJmb3JtYXQiLCJpbmRlbnQiLCJsaXN0VHlwZSIsInN0YXJ0IiwidGFnIiwidHlwZSIsInZlcnNpb24iLCJub2RlVHlwZXMiXSwibWFwcGluZ3MiOiI7Ozs7K0JBTWFBOzs7ZUFBQUE7OztrQkFGOEI7QUFFcEMsTUFBTUEseUJBQTZDO0lBQ3hEQyxXQUFVLEVBQUVDLFVBQVUsRUFBRUMsU0FBUyxFQUFFO1FBQ2pDLE9BQU87WUFDTEMsVUFBVUMsSUFBQUEsNEJBQTBCLEVBQUM7Z0JBQ25DQyxzQkFBc0I7Z0JBQ3RCSjtnQkFDQUssZ0JBQWdCO2dCQUNoQkMsWUFBWUwsVUFBVUMsUUFBUSxJQUFJLEVBQUU7WUFDdEM7WUFDQUssV0FBVztZQUNYQyxRQUFRO1lBQ1JDLFFBQVE7WUFDUkMsVUFBVTtZQUNWQyxPQUFPO1lBQ1BDLEtBQUs7WUFDTEMsTUFBTTtZQUNOQyxTQUFTO1FBQ1g7SUFDRjtJQUNBQyxXQUFXO1FBQUM7S0FBSztBQUNuQiJ9

package/dist/field/features/migrations/SlateToLexical/converter/converters/upload.d.ts

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from '../types';
+export declare const UploadConverter: SlateNodeConverter;
+//# sourceMappingURL=upload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/features/migrations/SlateToLexical/converter/converters/upload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAElD,eAAO,MAAM,eAAe,EAAE,kBAgB7B,CAAA"}

package/dist/field/features/migrations/SlateToLexical/converter/converters/upload.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UploadConverter", {
+    enumerable: true,
+    get: function() {
+        return UploadConverter;
+    }
+});
+const UploadConverter = {
+    converter ({ slateNode }) {
+        return {
+            fields: {
+                ...slateNode.fields
+            },
+            format: '',
+            relationTo: slateNode.relationTo,
+            type: 'upload',
+            value: {
+                id: slateNode.value?.id || ''
+            },
+            version: 1
+        };
+    },
+    nodeTypes: [
+        'upload'
+    ]
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL1NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3VwbG9hZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNlcmlhbGl6ZWRVcGxvYWROb2RlIH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vLi4nXG5pbXBvcnQgdHlwZSB7IFNsYXRlTm9kZUNvbnZlcnRlciB9IGZyb20gJy4uL3R5cGVzJ1xuXG5leHBvcnQgY29uc3QgVXBsb2FkQ29udmVydGVyOiBTbGF0ZU5vZGVDb252ZXJ0ZXIgPSB7XG4gIGNvbnZlcnRlcih7IHNsYXRlTm9kZSB9KSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGZpZWxkczoge1xuICAgICAgICAuLi5zbGF0ZU5vZGUuZmllbGRzLFxuICAgICAgfSxcbiAgICAgIGZvcm1hdDogJycsXG4gICAgICByZWxhdGlvblRvOiBzbGF0ZU5vZGUucmVsYXRpb25UbyxcbiAgICAgIHR5cGU6ICd1cGxvYWQnLFxuICAgICAgdmFsdWU6IHtcbiAgICAgICAgaWQ6IHNsYXRlTm9kZS52YWx1ZT8uaWQgfHwgJycsXG4gICAgICB9LFxuICAgICAgdmVyc2lvbjogMSxcbiAgICB9IGFzIGNvbnN0IGFzIFNlcmlhbGl6ZWRVcGxvYWROb2RlXG4gIH0sXG4gIG5vZGVUeXBlczogWyd1cGxvYWQnXSxcbn1cbiJdLCJuYW1lcyI6WyJVcGxvYWRDb252ZXJ0ZXIiLCJjb252ZXJ0ZXIiLCJzbGF0ZU5vZGUiLCJmaWVsZHMiLCJmb3JtYXQiLCJyZWxhdGlvblRvIiwidHlwZSIsInZhbHVlIiwiaWQiLCJ2ZXJzaW9uIiwibm9kZVR5cGVzIl0sIm1hcHBpbmdzIjoiOzs7OytCQUdhQTs7O2VBQUFBOzs7QUFBTixNQUFNQSxrQkFBc0M7SUFDakRDLFdBQVUsRUFBRUMsU0FBUyxFQUFFO1FBQ3JCLE9BQU87WUFDTEMsUUFBUTtnQkFDTixHQUFHRCxVQUFVQyxNQUFNO1lBQ3JCO1lBQ0FDLFFBQVE7WUFDUkMsWUFBWUgsVUFBVUcsVUFBVTtZQUNoQ0MsTUFBTTtZQUNOQyxPQUFPO2dCQUNMQyxJQUFJTixVQUFVSyxLQUFLLEVBQUVDLE1BQU07WUFDN0I7WUFDQUMsU0FBUztRQUNYO0lBQ0Y7SUFDQUMsV0FBVztRQUFDO0tBQVM7QUFDdkIifQ==

package/dist/field/features/migrations/SlateToLexical/converter/defaultConverters.d.ts

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from './types';
+export declare const defaultConverters: SlateNodeConverter[];
+//# sourceMappingURL=defaultConverters.d.ts.map

package/dist/field/features/migrations/SlateToLexical/converter/defaultConverters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/migrations/SlateToLexical/converter/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAYjD,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,EAUjD,CAAA"}

package/dist/field/features/migrations/SlateToLexical/converter/defaultConverters.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "defaultConverters", {
+    enumerable: true,
+    get: function() {
+        return defaultConverters;
+    }
+});
+const _heading = require("./converters/heading");
+const _indent = require("./converters/indent");
+const _link = require("./converters/link");
+const _listItem = require("./converters/listItem");
+const _orderedList = require("./converters/orderedList");
+const _relationship = require("./converters/relationship");
+const _unknown = require("./converters/unknown");
+const _unorderedList = require("./converters/unorderedList");
+const _upload = require("./converters/upload");
+const defaultConverters = [
+    _unknown.UnknownConverter,
+    _upload.UploadConverter,
+    _unorderedList.UnorderedListConverter,
+    _orderedList.OrderedListConverter,
+    _relationship.RelationshipConverter,
+    _listItem.ListItemConverter,
+    _link.LinkConverter,
+    _heading.HeadingConverter,
+    _indent.IndentConverter
+];
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL1NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9kZWZhdWx0Q29udmVydGVycy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNsYXRlTm9kZUNvbnZlcnRlciB9IGZyb20gJy4vdHlwZXMnXG5cbmltcG9ydCB7IEhlYWRpbmdDb252ZXJ0ZXIgfSBmcm9tICcuL2NvbnZlcnRlcnMvaGVhZGluZydcbmltcG9ydCB7IEluZGVudENvbnZlcnRlciB9IGZyb20gJy4vY29udmVydGVycy9pbmRlbnQnXG5pbXBvcnQgeyBMaW5rQ29udmVydGVyIH0gZnJvbSAnLi9jb252ZXJ0ZXJzL2xpbmsnXG5pbXBvcnQgeyBMaXN0SXRlbUNvbnZlcnRlciB9IGZyb20gJy4vY29udmVydGVycy9saXN0SXRlbSdcbmltcG9ydCB7IE9yZGVyZWRMaXN0Q29udmVydGVyIH0gZnJvbSAnLi9jb252ZXJ0ZXJzL29yZGVyZWRMaXN0J1xuaW1wb3J0IHsgUmVsYXRpb25zaGlwQ29udmVydGVyIH0gZnJvbSAnLi9jb252ZXJ0ZXJzL3JlbGF0aW9uc2hpcCdcbmltcG9ydCB7IFVua25vd25Db252ZXJ0ZXIgfSBmcm9tICcuL2NvbnZlcnRlcnMvdW5rbm93bidcbmltcG9ydCB7IFVub3JkZXJlZExpc3RDb252ZXJ0ZXIgfSBmcm9tICcuL2NvbnZlcnRlcnMvdW5vcmRlcmVkTGlzdCdcbmltcG9ydCB7IFVwbG9hZENvbnZlcnRlciB9IGZyb20gJy4vY29udmVydGVycy91cGxvYWQnXG5cbmV4cG9ydCBjb25zdCBkZWZhdWx0Q29udmVydGVyczogU2xhdGVOb2RlQ29udmVydGVyW10gPSBbXG4gIFVua25vd25Db252ZXJ0ZXIsXG4gIFVwbG9hZENvbnZlcnRlcixcbiAgVW5vcmRlcmVkTGlzdENvbnZlcnRlcixcbiAgT3JkZXJlZExpc3RDb252ZXJ0ZXIsXG4gIFJlbGF0aW9uc2hpcENvbnZlcnRlcixcbiAgTGlzdEl0ZW1Db252ZXJ0ZXIsXG4gIExpbmtDb252ZXJ0ZXIsXG4gIEhlYWRpbmdDb252ZXJ0ZXIsXG4gIEluZGVudENvbnZlcnRlcixcbl1cbiJdLCJuYW1lcyI6WyJkZWZhdWx0Q29udmVydGVycyIsIlVua25vd25Db252ZXJ0ZXIiLCJVcGxvYWRDb252ZXJ0ZXIiLCJVbm9yZGVyZWRMaXN0Q29udmVydGVyIiwiT3JkZXJlZExpc3RDb252ZXJ0ZXIiLCJSZWxhdGlvbnNoaXBDb252ZXJ0ZXIiLCJMaXN0SXRlbUNvbnZlcnRlciIsIkxpbmtDb252ZXJ0ZXIiLCJIZWFkaW5nQ29udmVydGVyIiwiSW5kZW50Q29udmVydGVyIl0sIm1hcHBpbmdzIjoiOzs7OytCQVlhQTs7O2VBQUFBOzs7eUJBVm9CO3dCQUNEO3NCQUNGOzBCQUNJOzZCQUNHOzhCQUNDO3lCQUNMOytCQUNNO3dCQUNQO0FBRXpCLE1BQU1BLG9CQUEwQztJQUNyREMseUJBQWdCO0lBQ2hCQyx1QkFBZTtJQUNmQyxxQ0FBc0I7SUFDdEJDLGlDQUFvQjtJQUNwQkMsbUNBQXFCO0lBQ3JCQywyQkFBaUI7SUFDakJDLG1CQUFhO0lBQ2JDLHlCQUFnQjtJQUNoQkMsdUJBQWU7Q0FDaEIifQ==

package/dist/field/features/migrations/SlateToLexical/converter/index.d.ts

@@ -0,0 +1,19 @@
+import type { SerializedEditorState, SerializedLexicalNode, SerializedParagraphNode, SerializedTextNode } from 'lexical';
+import type { SlateNode, SlateNodeConverter } from './types';
+export declare function convertSlateToLexical({ converters, slateData, }: {
+    converters: SlateNodeConverter[];
+    slateData: SlateNode[];
+}): SerializedEditorState;
+export declare function convertSlateNodesToLexical({ canContainParagraphs, converters, parentNodeType, slateNodes, }: {
+    canContainParagraphs: boolean;
+    converters: SlateNodeConverter[];
+    /**
+     * Type of the parent lexical node (not the type of the original, parent slate type)
+     */
+    parentNodeType: string;
+    slateNodes: SlateNode[];
+}): SerializedLexicalNode[];
+export declare function convertParagraphNode(converters: SlateNodeConverter[], node: SlateNode): SerializedParagraphNode;
+export declare function convertTextNode(node: SlateNode): SerializedTextNode;
+export declare function convertNodeToFormat(node: SlateNode): number;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/migrations/SlateToLexical/converter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/migrations/SlateToLexical/converter/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EACnB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAI5D,wBAAgB,qBAAqB,CAAC,EACpC,UAAU,EACV,SAAS,GACV,EAAE;IACD,UAAU,EAAE,kBAAkB,EAAE,CAAA;IAChC,SAAS,EAAE,SAAS,EAAE,CAAA;CACvB,GAAG,qBAAqB,CAgBxB;AAED,wBAAgB,0BAA0B,CAAC,EACzC,oBAAoB,EACpB,UAAU,EACV,cAAc,EACd,UAAU,GACX,EAAE;IACD,oBAAoB,EAAE,OAAO,CAAA;IAC7B,UAAU,EAAE,kBAAkB,EAAE,CAAA;IAChC;;OAEG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,SAAS,EAAE,CAAA;CACxB,GAAG,qBAAqB,EAAE,CAgC1B;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,kBAAkB,EAAE,EAChC,IAAI,EAAE,SAAS,GACd,uBAAuB,CAczB;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,kBAAkB,CAUnE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAwB3D"}

package/dist/field/features/migrations/SlateToLexical/converter/index.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    convertSlateToLexical: function() {
+        return convertSlateToLexical;
+    },
+    convertSlateNodesToLexical: function() {
+        return convertSlateNodesToLexical;
+    },
+    convertParagraphNode: function() {
+        return convertParagraphNode;
+    },
+    convertTextNode: function() {
+        return convertTextNode;
+    },
+    convertNodeToFormat: function() {
+        return convertNodeToFormat;
+    }
+});
+const _nodeFormat = require("../../../../lexical/utils/nodeFormat");
+function convertSlateToLexical({ converters, slateData }) {
+    return {
+        root: {
+            children: convertSlateNodesToLexical({
+                canContainParagraphs: true,
+                converters,
+                parentNodeType: 'root',
+                slateNodes: slateData
+            }),
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            type: 'root',
+            version: 1
+        }
+    };
+}
+function convertSlateNodesToLexical({ canContainParagraphs, converters, parentNodeType, slateNodes }) {
+    const unknownConverter = converters.find((converter)=>converter.nodeTypes.includes('unknown'));
+    return slateNodes.map((slateNode, i)=>{
+        if (!('type' in slateNode)) {
+            if (canContainParagraphs) {
+                // This is a paragraph node. They do not have a type property in Slate
+                return convertParagraphNode(converters, slateNode);
+            } else {
+                // This is a simple text node. canContainParagraphs may be false if this is nested inside of a paragraph already, since paragraphs cannot contain paragraphs
+                return convertTextNode(slateNode);
+            }
+        }
+        if (slateNode.type === 'p') {
+            return convertParagraphNode(converters, slateNode);
+        }
+        const converter = converters.find((converter)=>converter.nodeTypes.includes(slateNode.type));
+        if (converter) {
+            return converter.converter({
+                childIndex: i,
+                converters,
+                parentNodeType,
+                slateNode
+            });
+        }
+        console.warn('slateToLexical > No converter found for node type: ' + slateNode.type);
+        return unknownConverter?.converter({
+            childIndex: i,
+            converters,
+            parentNodeType,
+            slateNode
+        });
+    }) || [];
+}
+function convertParagraphNode(converters, node) {
+    return {
+        children: convertSlateNodesToLexical({
+            canContainParagraphs: false,
+            converters,
+            parentNodeType: 'paragraph',
+            slateNodes: node.children || []
+        }),
+        direction: 'ltr',
+        format: '',
+        indent: 0,
+        type: 'paragraph',
+        version: 1
+    };
+}
+function convertTextNode(node) {
+    return {
+        detail: 0,
+        format: convertNodeToFormat(node),
+        mode: 'normal',
+        style: '',
+        text: node.text,
+        type: 'text',
+        version: 1
+    };
+}
+function convertNodeToFormat(node) {
+    let format = 0;
+    if (node.bold) {
+        format = format | _nodeFormat.NodeFormat.IS_BOLD;
+    }
+    if (node.italic) {
+        format = format | _nodeFormat.NodeFormat.IS_ITALIC;
+    }
+    if (node.strikethrough) {
+        format = format | _nodeFormat.NodeFormat.IS_STRIKETHROUGH;
+    }
+    if (node.underline) {
+        format = format | _nodeFormat.NodeFormat.IS_UNDERLINE;
+    }
+    if (node.subscript) {
+        format = format | _nodeFormat.NodeFormat.IS_SUBSCRIPT;
+    }
+    if (node.superscript) {
+        format = format | _nodeFormat.NodeFormat.IS_SUPERSCRIPT;
+    }
+    if (node.code) {
+        format = format | _nodeFormat.NodeFormat.IS_CODE;
+    }
+    return format;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"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'\n\nimport { NodeFormat } from '../../../../lexical/utils/nodeFormat'\n\nexport function convertSlateToLexical({\n  converters,\n  slateData,\n}: {\n  converters: SlateNodeConverter[]\n  slateData: SlateNode[]\n}): SerializedEditorState {\n  return {\n    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      type: 'root',\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[]\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  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    children: convertSlateNodesToLexical({\n      canContainParagraphs: false,\n      converters,\n      parentNodeType: 'paragraph',\n      slateNodes: node.children || [],\n    }),\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    type: 'paragraph',\n    version: 1,\n  }\n}\nexport function convertTextNode(node: SlateNode): SerializedTextNode {\n  return {\n    detail: 0,\n    format: convertNodeToFormat(node),\n    mode: 'normal',\n    style: '',\n    text: node.text,\n    type: '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":["convertSlateToLexical","convertSlateNodesToLexical","convertParagraphNode","convertTextNode","convertNodeToFormat","converters","slateData","root","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","type","version","unknownConverter","find","converter","nodeTypes","includes","map","slateNode","i","childIndex","console","warn","node","detail","mode","style","text","bold","NodeFormat","IS_BOLD","italic","IS_ITALIC","strikethrough","IS_STRIKETHROUGH","underline","IS_UNDERLINE","subscript","IS_SUBSCRIPT","superscript","IS_SUPERSCRIPT","code","IS_CODE"],"mappings":";;;;;;;;;;;IAWgBA,qBAAqB;eAArBA;;IAwBAC,0BAA0B;eAA1BA;;IA+CAC,oBAAoB;eAApBA;;IAkBAC,eAAe;eAAfA;;IAYAC,mBAAmB;eAAnBA;;;4BAvGW;AAEpB,SAASJ,sBAAsB,EACpCK,UAAU,EACVC,SAAS,EAIV;IACC,OAAO;QACLC,MAAM;YACJC,UAAUP,2BAA2B;gBACnCQ,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL;YACd;YACAM,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,MAAM;YACNC,SAAS;QACX;IACF;AACF;AAEO,SAASf,2BAA2B,EACzCQ,oBAAoB,EACpBJ,UAAU,EACVK,cAAc,EACdC,UAAU,EASX;IACC,MAAMM,mBAAmBZ,WAAWa,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,OAAOP,qBAAqBG,YAAYkB;YAC1C,OAAO;gBACL,4JAA4J;gBAC5J,OAAOpB,gBAAgBoB;YACzB;QACF;QACA,IAAIA,UAAUR,IAAI,KAAK,KAAK;YAC1B,OAAOb,qBAAqBG,YAAYkB;QAC1C;QAEA,MAAMJ,YAAYd,WAAWa,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAACE,UAAUR,IAAI;QAE5F,IAAII,WAAW;YACb,OAAOA,UAAUA,SAAS,CAAC;gBAAEM,YAAYD;gBAAGnB;gBAAYK;gBAAgBa;YAAU;QACpF;QAEAG,QAAQC,IAAI,CAAC,wDAAwDJ,UAAUR,IAAI;QACnF,OAAOE,kBAAkBE,UAAU;YACjCM,YAAYD;YACZnB;YACAK;YACAa;QACF;IACF,MAAM,EAAE;AAEZ;AAEO,SAASrB,qBACdG,UAAgC,EAChCuB,IAAe;IAEf,OAAO;QACLpB,UAAUP,2BAA2B;YACnCQ,sBAAsB;YACtBJ;YACAK,gBAAgB;YAChBC,YAAYiB,KAAKpB,QAAQ,IAAI,EAAE;QACjC;QACAI,WAAW;QACXC,QAAQ;QACRC,QAAQ;QACRC,MAAM;QACNC,SAAS;IACX;AACF;AACO,SAASb,gBAAgByB,IAAe;IAC7C,OAAO;QACLC,QAAQ;QACRhB,QAAQT,oBAAoBwB;QAC5BE,MAAM;QACNC,OAAO;QACPC,MAAMJ,KAAKI,IAAI;QACfjB,MAAM;QACNC,SAAS;IACX;AACF;AAEO,SAASZ,oBAAoBwB,IAAe;IACjD,IAAIf,SAAS;IACb,IAAIe,KAAKK,IAAI,EAAE;QACbpB,SAASA,SAASqB,sBAAU,CAACC,OAAO;IACtC;IACA,IAAIP,KAAKQ,MAAM,EAAE;QACfvB,SAASA,SAASqB,sBAAU,CAACG,SAAS;IACxC;IACA,IAAIT,KAAKU,aAAa,EAAE;QACtBzB,SAASA,SAASqB,sBAAU,CAACK,gBAAgB;IAC/C;IACA,IAAIX,KAAKY,SAAS,EAAE;QAClB3B,SAASA,SAASqB,sBAAU,CAACO,YAAY;IAC3C;IACA,IAAIb,KAAKc,SAAS,EAAE;QAClB7B,SAASA,SAASqB,sBAAU,CAACS,YAAY;IAC3C;IACA,IAAIf,KAAKgB,WAAW,EAAE;QACpB/B,SAASA,SAASqB,sBAAU,CAACW,cAAc;IAC7C;IACA,IAAIjB,KAAKkB,IAAI,EAAE;QACbjC,SAASA,SAASqB,sBAAU,CAACa,OAAO;IACtC;IACA,OAAOlC;AACT"}

package/dist/field/features/migrations/SlateToLexical/converter/types.d.ts

@@ -0,0 +1,16 @@
+import type { SerializedLexicalNode } from 'lexical';
+export type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
+    converter: ({ childIndex, converters, parentNodeType, slateNode, }: {
+        childIndex: number;
+        converters: SlateNodeConverter[];
+        parentNodeType: string;
+        slateNode: SlateNode;
+    }) => T;
+    nodeTypes: string[];
+};
+export type SlateNode = {
+    [key: string]: any;
+    children?: SlateNode[];
+    type?: string;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/field/features/migrations/SlateToLexical/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IACxF,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,SAAS,GACV,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,kBAAkB,EAAE,CAAA;QAChC,cAAc,EAAE,MAAM,CAAA;QACtB,SAAS,EAAE,SAAS,CAAA;KACrB,KAAK,CAAC,CAAA;IACP,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAClB,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAA;IACtB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA"}

package/dist/field/features/migrations/SlateToLexical/converter/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/field/features/migrations/SlateToLexical/index.d.ts

@@ -0,0 +1,10 @@
+import type { FeatureProvider } from '../../types';
+import type { SlateNodeConverter } from './converter/types';
+type Props = {
+    converters?: (({ defaultConverters }: {
+        defaultConverters: SlateNodeConverter[];
+    }) => SlateNodeConverter[]) | SlateNodeConverter[];
+};
+export declare const SlateToLexicalFeature: (props?: Props) => FeatureProvider;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/migrations/SlateToLexical/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/migrations/SlateToLexical/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAM3D,KAAK,KAAK,GAAG;IACX,UAAU,CAAC,EACP,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE;QAAE,iBAAiB,EAAE,kBAAkB,EAAE,CAAA;KAAE,KAAK,kBAAkB,EAAE,CAAC,GAC9F,kBAAkB,EAAE,CAAA;CACzB,CAAA;AAED,eAAO,MAAM,qBAAqB,WAAY,KAAK,KAAG,eA0CrD,CAAA"}

package/dist/field/features/migrations/SlateToLexical/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SlateToLexicalFeature", {
+    enumerable: true,
+    get: function() {
+        return SlateToLexicalFeature;
+    }
+});
+const _converter = require("./converter");
+const _defaultConverters = require("./converter/defaultConverters");
+const _unknownConvertedNode = require("./nodes/unknownConvertedNode");
+const SlateToLexicalFeature = (props)=>{
+    if (!props) {
+        props = {};
+    }
+    props.converters = props?.converters && typeof props?.converters === 'function' ? props.converters({
+        defaultConverters: _defaultConverters.defaultConverters
+    }) : (props?.converters) || _defaultConverters.defaultConverters;
+    return {
+        feature: ({ resolvedFeatures, unsanitizedEditorConfig })=>{
+            return {
+                hooks: {
+                    load ({ incomingEditorState }) {
+                        if (!incomingEditorState || !Array.isArray(incomingEditorState) || 'root' in incomingEditorState) {
+                            // incomingEditorState null or not from Slate
+                            return incomingEditorState;
+                        }
+                        // Slate => convert to lexical
+                        return (0, _converter.convertSlateToLexical)({
+                            converters: props.converters,
+                            slateData: incomingEditorState
+                        });
+                    }
+                },
+                nodes: [
+                    {
+                        node: _unknownConvertedNode.UnknownConvertedNode,
+                        type: _unknownConvertedNode.UnknownConvertedNode.getType()
+                    }
+                ],
+                props
+            };
+        },
+        key: 'slateToLexical'
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,34 @@
+/// <reference types="react" />
+import type { SerializedLexicalNode, Spread } from 'lexical';
+import { DecoratorNode, type EditorConfig, type LexicalNode, type NodeKey } from 'lexical';
+import './index.scss';
+export type UnknownConvertedNodeData = {
+    nodeData: unknown;
+    nodeType: string;
+};
+export type SerializedUnknownConvertedNode = Spread<{
+    data: UnknownConvertedNodeData;
+}, SerializedLexicalNode>;
+/** @noInheritDoc */
+export declare class UnknownConvertedNode extends DecoratorNode<JSX.Element> {
+    __data: UnknownConvertedNodeData;
+    constructor({ data, key }: {
+        data: UnknownConvertedNodeData;
+        key?: NodeKey;
+    });
+    static clone(node: UnknownConvertedNode): UnknownConvertedNode;
+    static getType(): string;
+    static importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode;
+    canInsertTextAfter(): true;
+    canInsertTextBefore(): true;
+    createDOM(config: EditorConfig): HTMLElement;
+    decorate(): JSX.Element | null;
+    exportJSON(): SerializedUnknownConvertedNode;
+    isInline(): boolean;
+    updateDOM(prevNode: UnknownConvertedNode, dom: HTMLElement): boolean;
+}
+export declare function $createUnknownConvertedNode({ data, }: {
+    data: UnknownConvertedNodeData;
+}): UnknownConvertedNode;
+export declare function $isUnknownConvertedNode(node: LexicalNode | null | undefined): node is UnknownConvertedNode;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/features/migrations/SlateToLexical/nodes/unknownConvertedNode/index.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAG5D,OAAO,EAAE,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,KAAK,OAAO,EAAE,MAAM,SAAS,CAAA;AAG1F,OAAO,cAAc,CAAA;AAErB,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;AAED,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/SlateToLexical/nodes/unknownConvertedNode/index.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    UnknownConvertedNode: function() {
+        return UnknownConvertedNode;
+    },
+    $createUnknownConvertedNode: function() {
+        return $createUnknownConvertedNode;
+    },
+    $isUnknownConvertedNode: function() {
+        return $isUnknownConvertedNode;
+    }
+});
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+require("./index.scss");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class UnknownConvertedNode extends _lexical.DecoratorNode {
+    __data;
+    constructor({ data, key }){
+        super(key);
+        this.__data = data;
+    }
+    static clone(node) {
+        return new UnknownConvertedNode({
+            data: node.__data,
+            key: node.__key
+        });
+    }
+    static getType() {
+        return 'unknownConverted';
+    }
+    static importJSON(serializedNode) {
+        const node = $createUnknownConvertedNode({
+            data: serializedNode.data
+        });
+        return node;
+    }
+    canInsertTextAfter() {
+        return true;
+    }
+    canInsertTextBefore() {
+        return true;
+    }
+    createDOM(config) {
+        const element = document.createElement('span');
+        (0, _utils.addClassNamesToElement)(element, 'unknownConverted');
+        return element;
+    }
+    decorate() {
+        return /*#__PURE__*/ _react.default.createElement("div", null, "Unknown converted Slate node: ", this.__data?.nodeType);
+    }
+    exportJSON() {
+        return {
+            data: this.__data,
+            type: this.getType(),
+            version: 1
+        };
+    }
+    // Mutation
+    isInline() {
+        return true;
+    }
+    updateDOM(prevNode, dom) {
+        return false;
+    }
+}
+function $createUnknownConvertedNode({ data }) {
+    return new UnknownConvertedNode({
+        data
+    });
+}
+function $isUnknownConvertedNode(node) {
+    return node instanceof UnknownConvertedNode;
+}
+
+//# sourceMappingURL=data:application/json;base64,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