@payloadcms/richtext-lexical 0.7.0 → 3.0.0-alpha.18

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SlateUnknownConverter", {
+    enumerable: true,
+    get: function() {
+        return SlateUnknownConverter;
+    }
+});
+const _client = require("./client");
+const _converter = require("./converter");
+const SlateUnknownConverter = {
+    ClientComponent: _client.UnknownConverterClient,
+    converter: _converter._SlateUnknownConverter
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3Vua25vd24vaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTbGF0ZU5vZGVDb252ZXJ0ZXJQcm92aWRlciB9IGZyb20gJy4uLy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBVbmtub3duQ29udmVydGVyQ2xpZW50IH0gZnJvbSAnLi9jbGllbnQnXG5pbXBvcnQgeyBfU2xhdGVVbmtub3duQ29udmVydGVyIH0gZnJvbSAnLi9jb252ZXJ0ZXInXG5cbmV4cG9ydCBjb25zdCBTbGF0ZVVua25vd25Db252ZXJ0ZXI6IFNsYXRlTm9kZUNvbnZlcnRlclByb3ZpZGVyID0ge1xuICBDbGllbnRDb21wb25lbnQ6IFVua25vd25Db252ZXJ0ZXJDbGllbnQsXG4gIGNvbnZlcnRlcjogX1NsYXRlVW5rbm93bkNvbnZlcnRlcixcbn1cbiJdLCJuYW1lcyI6WyJTbGF0ZVVua25vd25Db252ZXJ0ZXIiLCJDbGllbnRDb21wb25lbnQiLCJVbmtub3duQ29udmVydGVyQ2xpZW50IiwiY29udmVydGVyIiwiX1NsYXRlVW5rbm93bkNvbnZlcnRlciJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFLYUE7OztlQUFBQTs7O3dCQUgwQjsyQkFDQTtBQUVoQyxNQUFNQSx3QkFBb0Q7SUFDL0RDLGlCQUFpQkMsOEJBQXNCO0lBQ3ZDQyxXQUFXQyxpQ0FBc0I7QUFDbkMifQ==

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

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

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

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

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

@@ -0,0 +1,16 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UnorderedListConverterClient", {
+    enumerable: true,
+    get: function() {
+        return UnorderedListConverterClient;
+    }
+});
+const _createFeaturePropComponent = require("../../../../../createFeaturePropComponent");
+const _converter = require("./converter");
+const UnorderedListConverterClient = (0, _createFeaturePropComponent.createFeaturePropComponent)(_converter._SlateUnorderedListConverter);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3Vub3JkZXJlZExpc3QvY2xpZW50LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIid1c2UgY2xpZW50J1xuXG5pbXBvcnQgeyBjcmVhdGVGZWF0dXJlUHJvcENvbXBvbmVudCB9IGZyb20gJy4uLy4uLy4uLy4uLy4uL2NyZWF0ZUZlYXR1cmVQcm9wQ29tcG9uZW50J1xuaW1wb3J0IHsgX1NsYXRlVW5vcmRlcmVkTGlzdENvbnZlcnRlciB9IGZyb20gJy4vY29udmVydGVyJ1xuXG5leHBvcnQgY29uc3QgVW5vcmRlcmVkTGlzdENvbnZlcnRlckNsaWVudCA9IGNyZWF0ZUZlYXR1cmVQcm9wQ29tcG9uZW50KF9TbGF0ZVVub3JkZXJlZExpc3RDb252ZXJ0ZXIpXG4iXSwibmFtZXMiOlsiVW5vcmRlcmVkTGlzdENvbnZlcnRlckNsaWVudCIsImNyZWF0ZUZlYXR1cmVQcm9wQ29tcG9uZW50IiwiX1NsYXRlVW5vcmRlcmVkTGlzdENvbnZlcnRlciJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OytCQUthQTs7O2VBQUFBOzs7NENBSDhCOzJCQUNFO0FBRXRDLE1BQU1BLCtCQUErQkMsSUFBQUEsc0RBQTBCLEVBQUNDLHVDQUE0QiJ9

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/unorderedList/converter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAIrD,eAAO,MAAM,4BAA4B,EAAE,kBAoB1C,CAAA"}

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/unorderedList/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAA;AAK7D,eAAO,MAAM,2BAA2B,EAAE,0BAGzC,CAAA"}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SlateUnorderedListConverter", {
+    enumerable: true,
+    get: function() {
+        return SlateUnorderedListConverter;
+    }
+});
+const _client = require("./client");
+const _converter = require("./converter");
+const SlateUnorderedListConverter = {
+    ClientComponent: _client.UnorderedListConverterClient,
+    converter: _converter._SlateUnorderedListConverter
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3Vub3JkZXJlZExpc3QvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTbGF0ZU5vZGVDb252ZXJ0ZXJQcm92aWRlciB9IGZyb20gJy4uLy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBVbm9yZGVyZWRMaXN0Q29udmVydGVyQ2xpZW50IH0gZnJvbSAnLi9jbGllbnQnXG5pbXBvcnQgeyBfU2xhdGVVbm9yZGVyZWRMaXN0Q29udmVydGVyIH0gZnJvbSAnLi9jb252ZXJ0ZXInXG5cbmV4cG9ydCBjb25zdCBTbGF0ZVVub3JkZXJlZExpc3RDb252ZXJ0ZXI6IFNsYXRlTm9kZUNvbnZlcnRlclByb3ZpZGVyID0ge1xuICBDbGllbnRDb21wb25lbnQ6IFVub3JkZXJlZExpc3RDb252ZXJ0ZXJDbGllbnQsXG4gIGNvbnZlcnRlcjogX1NsYXRlVW5vcmRlcmVkTGlzdENvbnZlcnRlcixcbn1cbiJdLCJuYW1lcyI6WyJTbGF0ZVVub3JkZXJlZExpc3RDb252ZXJ0ZXIiLCJDbGllbnRDb21wb25lbnQiLCJVbm9yZGVyZWRMaXN0Q29udmVydGVyQ2xpZW50IiwiY29udmVydGVyIiwiX1NsYXRlVW5vcmRlcmVkTGlzdENvbnZlcnRlciJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFLYUE7OztlQUFBQTs7O3dCQUhnQzsyQkFDQTtBQUV0QyxNQUFNQSw4QkFBMEQ7SUFDckVDLGlCQUFpQkMsb0NBQTRCO0lBQzdDQyxXQUFXQyx1Q0FBNEI7QUFDekMifQ==

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

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

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

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

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

@@ -0,0 +1,16 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UploadConverterClient", {
+    enumerable: true,
+    get: function() {
+        return UploadConverterClient;
+    }
+});
+const _createFeaturePropComponent = require("../../../../../createFeaturePropComponent");
+const _converter = require("./converter");
+const UploadConverterClient = (0, _createFeaturePropComponent.createFeaturePropComponent)(_converter._SlateUploadConverter);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3VwbG9hZC9jbGllbnQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBjbGllbnQnXG5cbmltcG9ydCB7IGNyZWF0ZUZlYXR1cmVQcm9wQ29tcG9uZW50IH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vY3JlYXRlRmVhdHVyZVByb3BDb21wb25lbnQnXG5pbXBvcnQgeyBfU2xhdGVVcGxvYWRDb252ZXJ0ZXIgfSBmcm9tICcuL2NvbnZlcnRlcidcblxuZXhwb3J0IGNvbnN0IFVwbG9hZENvbnZlcnRlckNsaWVudCA9IGNyZWF0ZUZlYXR1cmVQcm9wQ29tcG9uZW50KF9TbGF0ZVVwbG9hZENvbnZlcnRlcilcbiJdLCJuYW1lcyI6WyJVcGxvYWRDb252ZXJ0ZXJDbGllbnQiLCJjcmVhdGVGZWF0dXJlUHJvcENvbXBvbmVudCIsIl9TbGF0ZVVwbG9hZENvbnZlcnRlciJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OytCQUthQTs7O2VBQUFBOzs7NENBSDhCOzJCQUNMO0FBRS9CLE1BQU1BLHdCQUF3QkMsSUFBQUEsc0RBQTBCLEVBQUNDLGdDQUFxQiJ9

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/upload/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErD,eAAO,MAAM,qBAAqB,EAAE,kBAgBnC,CAAA"}

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

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SlateUploadConverter", {
+    enumerable: true,
+    get: function() {
+        return SlateUploadConverter;
+    }
+});
+const _client = require("./client");
+const _converter = require("./converter");
+const SlateUploadConverter = {
+    ClientComponent: _client.UploadConverterClient,
+    converter: _converter._SlateUploadConverter
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3VwbG9hZC9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNsYXRlTm9kZUNvbnZlcnRlclByb3ZpZGVyIH0gZnJvbSAnLi4vLi4vdHlwZXMnXG5cbmltcG9ydCB7IFVwbG9hZENvbnZlcnRlckNsaWVudCB9IGZyb20gJy4vY2xpZW50J1xuaW1wb3J0IHsgX1NsYXRlVXBsb2FkQ29udmVydGVyIH0gZnJvbSAnLi9jb252ZXJ0ZXInXG5cbmV4cG9ydCBjb25zdCBTbGF0ZVVwbG9hZENvbnZlcnRlcjogU2xhdGVOb2RlQ29udmVydGVyUHJvdmlkZXIgPSB7XG4gIENsaWVudENvbXBvbmVudDogVXBsb2FkQ29udmVydGVyQ2xpZW50LFxuICBjb252ZXJ0ZXI6IF9TbGF0ZVVwbG9hZENvbnZlcnRlcixcbn1cbiJdLCJuYW1lcyI6WyJTbGF0ZVVwbG9hZENvbnZlcnRlciIsIkNsaWVudENvbXBvbmVudCIsIlVwbG9hZENvbnZlcnRlckNsaWVudCIsImNvbnZlcnRlciIsIl9TbGF0ZVVwbG9hZENvbnZlcnRlciJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFLYUE7OztlQUFBQTs7O3dCQUh5QjsyQkFDQTtBQUUvQixNQUFNQSx1QkFBbUQ7SUFDOURDLGlCQUFpQkMsNkJBQXFCO0lBQ3RDQyxXQUFXQyxnQ0FBcUI7QUFDbEMifQ==

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

@@ -0,0 +1,3 @@
+import type { SlateNodeConverterProvider } from './types';
+export declare const defaultSlateConverters: SlateNodeConverterProvider[];
+//# 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,0BAA0B,EAAE,MAAM,SAAS,CAAA;AAazD,eAAO,MAAM,sBAAsB,EAAE,0BAA0B,EAW9D,CAAA"}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "defaultSlateConverters", {
+    enumerable: true,
+    get: function() {
+        return defaultSlateConverters;
+    }
+});
+const _blockquote = require("./converters/blockquote");
+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 defaultSlateConverters = [
+    _blockquote.SlateBlockquoteConverter,
+    _heading.SlateHeadingConverter,
+    _indent.SlateIndentConverter,
+    _link.SlateLinkConverter,
+    _listItem.SlateListItemConverter,
+    _orderedList.SlateOrderedListConverter,
+    _relationship.SlateRelationshipConverter,
+    _unorderedList.SlateUnorderedListConverter,
+    _upload.SlateUploadConverter,
+    _unknown.SlateUnknownConverter
+];
+
+//# sourceMappingURL=data:application/json;base64,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

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[] | undefined;
+    /**
+     * 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,GAAG,SAAS,CAAA;IAC5C;;OAEG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,SAAS,EAAE,CAAA;CACxB,GAAG,qBAAqB,EAAE,CAmC1B;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,134 @@
+"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, {
+    convertNodeToFormat: function() {
+        return convertNodeToFormat;
+    },
+    convertParagraphNode: function() {
+        return convertParagraphNode;
+    },
+    convertSlateNodesToLexical: function() {
+        return convertSlateNodesToLexical;
+    },
+    convertSlateToLexical: function() {
+        return convertSlateToLexical;
+    },
+    convertTextNode: function() {
+        return convertTextNode;
+    }
+});
+const _nodeFormat = require("../../../../lexical/utils/nodeFormat");
+function convertSlateToLexical({ converters, slateData }) {
+    return {
+        root: {
+            type: 'root',
+            children: convertSlateNodesToLexical({
+                canContainParagraphs: true,
+                converters,
+                parentNodeType: 'root',
+                slateNodes: slateData
+            }),
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+        }
+    };
+}
+function convertSlateNodesToLexical({ canContainParagraphs, converters, parentNodeType, slateNodes }) {
+    if (!converters?.length) {
+        return [];
+    }
+    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 {
+        type: 'paragraph',
+        children: convertSlateNodesToLexical({
+            canContainParagraphs: false,
+            converters,
+            parentNodeType: 'paragraph',
+            slateNodes: node.children || []
+        }),
+        direction: 'ltr',
+        format: '',
+        indent: 0,
+        version: 1
+    };
+}
+function convertTextNode(node) {
+    return {
+        type: 'text',
+        detail: 0,
+        format: convertNodeToFormat(node),
+        mode: 'normal',
+        style: '',
+        text: node.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      type: 'root',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: true,\n        converters,\n        parentNodeType: 'root',\n        slateNodes: slateData,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n}\n\nexport function convertSlateNodesToLexical({\n  canContainParagraphs,\n  converters,\n  parentNodeType,\n  slateNodes,\n}: {\n  canContainParagraphs: boolean\n  converters: SlateNodeConverter[] | undefined\n  /**\n   * Type of the parent lexical node (not the type of the original, parent slate type)\n   */\n  parentNodeType: string\n  slateNodes: SlateNode[]\n}): SerializedLexicalNode[] {\n  if (!converters?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  return (\n    slateNodes.map((slateNode, i) => {\n      if (!('type' in slateNode)) {\n        if (canContainParagraphs) {\n          // This is a paragraph node. They do not have a type property in Slate\n          return convertParagraphNode(converters, slateNode)\n        } else {\n          // This is a simple text node. canContainParagraphs may be false if this is nested inside of a paragraph already, since paragraphs cannot contain paragraphs\n          return convertTextNode(slateNode)\n        }\n      }\n      if (slateNode.type === 'p') {\n        return convertParagraphNode(converters, slateNode)\n      }\n\n      const converter = converters.find((converter) => converter.nodeTypes.includes(slateNode.type))\n\n      if (converter) {\n        return converter.converter({ childIndex: i, converters, parentNodeType, slateNode })\n      }\n\n      console.warn('slateToLexical > No converter found for node type: ' + slateNode.type)\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        parentNodeType,\n        slateNode,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: SlateNodeConverter[],\n  node: SlateNode,\n): SerializedParagraphNode {\n  return {\n    type: 'paragraph',\n    children: convertSlateNodesToLexical({\n      canContainParagraphs: false,\n      converters,\n      parentNodeType: 'paragraph',\n      slateNodes: node.children || [],\n    }),\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    version: 1,\n  }\n}\nexport function convertTextNode(node: SlateNode): SerializedTextNode {\n  return {\n    type: 'text',\n    detail: 0,\n    format: convertNodeToFormat(node),\n    mode: 'normal',\n    style: '',\n    text: node.text,\n    version: 1,\n  }\n}\n\nexport function convertNodeToFormat(node: SlateNode): number {\n  let format = 0\n  if (node.bold) {\n    format = format | NodeFormat.IS_BOLD\n  }\n  if (node.italic) {\n    format = format | NodeFormat.IS_ITALIC\n  }\n  if (node.strikethrough) {\n    format = format | NodeFormat.IS_STRIKETHROUGH\n  }\n  if (node.underline) {\n    format = format | NodeFormat.IS_UNDERLINE\n  }\n  if (node.subscript) {\n    format = format | NodeFormat.IS_SUBSCRIPT\n  }\n  if (node.superscript) {\n    format = format | NodeFormat.IS_SUPERSCRIPT\n  }\n  if (node.code) {\n    format = format | NodeFormat.IS_CODE\n  }\n  return format\n}\n"],"names":["convertNodeToFormat","convertParagraphNode","convertSlateNodesToLexical","convertSlateToLexical","convertTextNode","converters","slateData","root","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","length","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":"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"}

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

@@ -0,0 +1,25 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type React from 'react';
+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;
+};
+export type SlateNodeConverterClientComponent = React.FC<{
+    componentKey: string;
+    featureKey: string;
+}>;
+export type SlateNodeConverterProvider = {
+    ClientComponent: SlateNodeConverterClientComponent;
+    converter: SlateNodeConverter;
+};
+//# 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;AACpD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,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;AAED,MAAM,MAAM,iCAAiC,GAAG,KAAK,CAAC,EAAE,CAAC;IACvD,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,eAAe,EAAE,iCAAiC,CAAA;IAClD,SAAS,EAAE,kBAAkB,CAAA;CAC9B,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/feature.client.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const SlateToLexicalFeatureClientComponent: import("react").FC<undefined>;
+//# sourceMappingURL=feature.client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/migrations/slateToLexical/feature.client.tsx"],"names":[],"mappings":";AAyCA,eAAO,MAAM,oCAAoC,+BAEhD,CAAA"}

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

@@ -0,0 +1,44 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SlateToLexicalFeatureClientComponent", {
+    enumerable: true,
+    get: function() {
+        return SlateToLexicalFeatureClientComponent;
+    }
+});
+const _createClientComponent = require("../../createClientComponent");
+const _converter = require("./converter");
+const _unknownConvertedNode = require("./nodes/unknownConvertedNode");
+const SlateToLexicalFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ({ clientFunctions })=>{
+            const converters = Object.values(clientFunctions);
+            return {
+                clientFeatureProps: props,
+                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,
+                            slateData: incomingEditorState
+                        });
+                    }
+                },
+                nodes: [
+                    _unknownConvertedNode.UnknownConvertedNode
+                ]
+            };
+        }
+    };
+};
+const SlateToLexicalFeatureClientComponent = (0, _createClientComponent.createClientComponent)(SlateToLexicalFeatureClient);
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/migrations/slateToLexical/feature.server.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/migrations/slateToLexical/feature.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAChE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAA;AAMnE,MAAM,MAAM,0BAA0B,GAAG;IACvC,UAAU,CAAC,EACP,CAAC,CAAC,EACA,iBAAiB,GAClB,EAAE;QACD,iBAAiB,EAAE,0BAA0B,EAAE,CAAA;KAChD,KAAK,0BAA0B,EAAE,CAAC,GACnC,0BAA0B,EAAE,CAAA;CACjC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,6BAA6B,CAC/D,0BAA0B,EAC1B,SAAS,CA+CV,CAAA"}