@payloadcms/richtext-lexical 3.0.0-beta.13 → 3.0.0-beta.130

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,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAK5D,OAAO,aAAa,MAAM,SAAS,CAAA;AACnC,QAAA,MAAQ,aAAa,oCAAkB,CAAA;AAEvC,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAIjE,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

@@ -1,70 +0,0 @@
-import lexicalUtilsImport from '@lexical/utils';
-const { addClassNamesToElement } = lexicalUtilsImport;
-import lexicalImport from 'lexical';
-const { DecoratorNode } = lexicalImport;
-import * as React from 'react';
-const Component = /*#__PURE__*/ React.lazy(()=>import('./Component.js').then((module)=>({
-            default: module.UnknownConvertedNodeComponent
-        })));
-/** @noInheritDoc */ export class UnknownConvertedNode extends 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');
-        addClassNamesToElement(element, 'unknownConverted');
-        return element;
-    }
-    decorate() {
-        return /*#__PURE__*/ React.createElement(Component, {
-            data: this.__data
-        });
-    }
-    exportJSON() {
-        return {
-            type: this.getType(),
-            data: this.__data,
-            version: 1
-        };
-    }
-    // Mutation
-    isInline() {
-        return true;
-    }
-    updateDOM(prevNode, dom) {
-        return false;
-    }
-}
-export function $createUnknownConvertedNode({ data }) {
-    return new UnknownConvertedNode({
-        data
-    });
-}
-export function $isUnknownConvertedNode(node) {
-    return node instanceof UnknownConvertedNode;
-}
-
-//# sourceMappingURL=index.js.map

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

package/dist/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.scss

@@ -1,14 +0,0 @@
-span.unknownConverted {
-  text-transform: uppercase;
-  font-family: 'Roboto Mono', monospace;
-  letter-spacing: 2px;
-  font-size: calc(var(--base) * 0.5);
-  margin: 0 0 var(--base);
-  background: red;
-  color: white;
-  display: inline-block;
-
-  div {
-    background: red;
-  }
-}

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

@@ -1,6 +0,0 @@
-'use client';
-import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js';
-import { _SlateBlockquoteConverter } from './converter.js';
-export const BlockQuoteConverterClient = createFeaturePropComponent(_SlateBlockquoteConverter);
-
-//# sourceMappingURL=client.js.map

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

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

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

@@ -1,23 +0,0 @@
-import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateBlockquoteConverter = {
-    converter ({ converters, slateNode }) {
-        return {
-            type: 'quote',
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: false,
-                converters,
-                parentNodeType: 'quote',
-                slateNodes: slateNode.children
-            }),
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            version: 1
-        };
-    },
-    nodeTypes: [
-        'blockquote'
-    ]
-};
-
-//# sourceMappingURL=converter.js.map

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

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

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"}

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

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

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

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

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

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

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

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

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

@@ -1,6 +0,0 @@
-'use client';
-import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js';
-import { _SlateHeadingConverter } from './converter.js';
-export const HeadingConverterClient = createFeaturePropComponent(_SlateHeadingConverter);
-
-//# sourceMappingURL=client.js.map

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

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

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

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

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

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

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

@@ -1,29 +0,0 @@
-import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateHeadingConverter = {
-    converter ({ converters, slateNode }) {
-        return {
-            type: 'heading',
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: false,
-                converters,
-                parentNodeType: 'heading',
-                slateNodes: slateNode.children
-            }),
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            tag: slateNode.type,
-            version: 1
-        };
-    },
-    nodeTypes: [
-        'h1',
-        'h2',
-        'h3',
-        'h4',
-        'h5',
-        'h6'
-    ]
-};
-
-//# sourceMappingURL=converter.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '@lexical/rich-text'\n\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const _SlateHeadingConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'heading',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'heading',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      tag: slateNode.type as 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6', // Slate puts the tag (h1 / h2 / ...) inside of node.type\n      version: 1,\n    } as const as SerializedHeadingNode\n  },\n  nodeTypes: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],\n}\n"],"names":["convertSlateNodesToLexical","_SlateHeadingConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","tag","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,yBAA6C;IACxDC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,KAAKT,UAAUC,IAAI;YACnBS,SAAS;QACX;IACF;IACAC,WAAW;QAAC;QAAM;QAAM;QAAM;QAAM;QAAM;KAAK;AACjD,EAAC"}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +0,0 @@
-'use client';
-import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js';
-import { _SlateIndentConverter } from './converter.js';
-export const IndentConverterClient = createFeaturePropComponent(_SlateIndentConverter);
-
-//# sourceMappingURL=client.js.map

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

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

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

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

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

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

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

@@ -1,35 +0,0 @@
-import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateIndentConverter = {
-    converter ({ converters, slateNode }) {
-        const convertChildren = (node, indentLevel = 0)=>{
-            if (node?.type && (!node.children || node.type !== 'indent') || !node?.type && node?.text) {
-                return {
-                    ...convertSlateNodesToLexical({
-                        canContainParagraphs: false,
-                        converters,
-                        parentNodeType: 'indent',
-                        slateNodes: [
-                            node
-                        ]
-                    })[0],
-                    indent: indentLevel
-                };
-            }
-            const children = node.children.map((child)=>convertChildren(child, indentLevel + 1));
-            return {
-                type: 'paragraph',
-                children,
-                direction: 'ltr',
-                format: '',
-                indent: indentLevel,
-                version: 1
-            };
-        };
-        return convertChildren(slateNode);
-    },
-    nodeTypes: [
-        'indent'
-    ]
-};
-
-//# sourceMappingURL=converter.js.map

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

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

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

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

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

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

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

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

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

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

package/dist/field/features/migrations/slateToLexical/converter/converters/link/client.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/slateToLexical/converter/converters/link/client.d.ts.map

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

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

@@ -1,6 +0,0 @@
-'use client';
-import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js';
-import { _SlateLinkConverter } from './converter.js';
-export const LinkConverterClient = createFeaturePropComponent(_SlateLinkConverter);
-
-//# sourceMappingURL=client.js.map

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

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

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

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

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

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

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

@@ -1,30 +0,0 @@
-import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateLinkConverter = {
-    converter ({ converters, slateNode }) {
-        return {
-            type: 'link',
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: false,
-                converters,
-                parentNodeType: 'link',
-                slateNodes: slateNode.children
-            }),
-            direction: 'ltr',
-            fields: {
-                ...slateNode.fields || {},
-                doc: slateNode.doc || null,
-                linkType: slateNode.linkType || 'custom',
-                newTab: slateNode.newTab || false,
-                url: slateNode.url || undefined
-            },
-            format: '',
-            indent: 0,
-            version: 2
-        };
-    },
-    nodeTypes: [
-        'link'
-    ]
-};
-
-//# sourceMappingURL=converter.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/link/converter.ts"],"sourcesContent":["import type { SerializedLinkNode } from '../../../../../link/nodes/types.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const _SlateLinkConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'link',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'link',\n        slateNodes: slateNode.children,\n      }),\n      direction: 'ltr',\n      fields: {\n        ...(slateNode.fields || {}),\n        doc: slateNode.doc || null,\n        linkType: slateNode.linkType || 'custom',\n        newTab: slateNode.newTab || false,\n        url: slateNode.url || undefined,\n      },\n      format: '',\n      indent: 0,\n      version: 2,\n    } as const as SerializedLinkNode\n  },\n  nodeTypes: ['link'],\n}\n"],"names":["convertSlateNodesToLexical","_SlateLinkConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","fields","doc","linkType","newTab","url","undefined","format","indent","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,sBAA0C;IACrDC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;gBACN,GAAIP,UAAUO,MAAM,IAAI,CAAC,CAAC;gBAC1BC,KAAKR,UAAUQ,GAAG,IAAI;gBACtBC,UAAUT,UAAUS,QAAQ,IAAI;gBAChCC,QAAQV,UAAUU,MAAM,IAAI;gBAC5BC,KAAKX,UAAUW,GAAG,IAAIC;YACxB;YACAC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAO;AACrB,EAAC"}

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

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

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

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

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

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

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

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

package/dist/field/features/migrations/slateToLexical/converter/converters/listItem/client.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/slateToLexical/converter/converters/listItem/client.d.ts.map

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

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

@@ -1,6 +0,0 @@
-'use client';
-import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js';
-import { _SlateListItemConverter } from './converter.js';
-export const ListItemConverterClient = createFeaturePropComponent(_SlateListItemConverter);
-
-//# sourceMappingURL=client.js.map

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

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

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

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

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

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

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

@@ -1,25 +0,0 @@
-import { convertSlateNodesToLexical } from '../../index.js';
-export const _SlateListItemConverter = {
-    converter ({ childIndex, converters, slateNode }) {
-        return {
-            type: 'listitem',
-            checked: undefined,
-            children: convertSlateNodesToLexical({
-                canContainParagraphs: false,
-                converters,
-                parentNodeType: 'listitem',
-                slateNodes: slateNode.children
-            }),
-            direction: 'ltr',
-            format: '',
-            indent: 0,
-            value: childIndex + 1,
-            version: 1
-        };
-    },
-    nodeTypes: [
-        'li'
-    ]
-};
-
-//# sourceMappingURL=converter.js.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +0,0 @@
-'use client';
-import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js';
-import { _SlateOrderedListConverter } from './converter.js';
-export const OrderedListConverterClient = createFeaturePropComponent(_SlateOrderedListConverter);
-
-//# sourceMappingURL=client.js.map