@payloadcms/richtext-lexical 3.70.0 → 3.71.0-internal-debug.80dab4c

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

@@ -1,74 +1,73 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxDEV as _jsxDEV } from "react/jsx-dev-runtime";
 import { addClassNamesToElement } from '@lexical/utils';
 import { $applyNodeReplacement, DecoratorNode } from 'lexical';
 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 this({
-      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__*/_jsx(Component, {
-      data: this.__data
-    });
-  }
-  exportJSON() {
-    return {
-      type: this.getType(),
-      data: this.__data,
-      version: 1
-    };
-  }
-  // Mutation
-  isInline() {
-    return true;
-  }
-  updateDOM(prevNode, dom) {
-    return false;
-  }
+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 this({
+            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__*/ _jsxDEV(Component, {
+            data: this.__data
+        }, void 0, false, {
+            fileName: "src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx",
+            lineNumber: 66,
+            columnNumber: 12
+        }, this);
+    }
+    exportJSON() {
+        return {
+            type: this.getType(),
+            data: this.__data,
+            version: 1
+        };
+    }
+    // Mutation
+    isInline() {
+        return true;
+    }
+    updateDOM(prevNode, dom) {
+        return false;
+    }
 }
-export function $createUnknownConvertedNode({
-  data
-}) {
-  return $applyNodeReplacement(new UnknownConvertedNode({
-    data
-  }));
+export function $createUnknownConvertedNode({ data }) {
+    return $applyNodeReplacement(new UnknownConvertedNode({
+        data
+    }));
 }
 export function $isUnknownConvertedNode(node) {
-  return node instanceof UnknownConvertedNode;
+    return node instanceof UnknownConvertedNode;
 }
+
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["addClassNamesToElement","$applyNodeReplacement","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","_jsx","exportJSON","type","version","isInline","updateDOM","prevNode","dom","$isUnknownConvertedNode"],"sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical'\nimport type { JSX } from 'react'\n\nimport { addClassNamesToElement } from '@lexical/utils'\nimport { $applyNodeReplacement, DecoratorNode } from 'lexical'\nimport * as React from 'react'\n\nexport type UnknownConvertedNodeData = {\n  nodeData: unknown\n  nodeType: string\n}\n\nexport type SerializedUnknownConvertedNode = Spread<\n  {\n    data: UnknownConvertedNodeData\n  },\n  SerializedLexicalNode\n>\n\nconst Component = React.lazy(() =>\n  import('./Component.js').then((module) => ({\n    default: module.UnknownConvertedNodeComponent,\n  })),\n)\n\n/** @noInheritDoc */\nexport class UnknownConvertedNode extends DecoratorNode<JSX.Element> {\n  __data: UnknownConvertedNodeData\n\n  constructor({ data, key }: { data: UnknownConvertedNodeData; key?: NodeKey }) {\n    super(key)\n    this.__data = data\n  }\n\n  static override clone(node: UnknownConvertedNode): UnknownConvertedNode {\n    return new this({\n      data: node.__data,\n      key: node.__key,\n    })\n  }\n\n  static override getType(): string {\n    return 'unknownConverted'\n  }\n\n  static override 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  override createDOM(config: EditorConfig): HTMLElement {\n    const element = document.createElement('span')\n    addClassNamesToElement(element, 'unknownConverted')\n    return element\n  }\n\n  override decorate(): JSX.Element {\n    return <Component data={this.__data} />\n  }\n\n  override exportJSON(): SerializedUnknownConvertedNode {\n    return {\n      type: this.getType(),\n      data: this.__data,\n      version: 1,\n    }\n  }\n\n  // Mutation\n\n  override isInline(): boolean {\n    return true\n  }\n\n  override updateDOM(prevNode: this, dom: HTMLElement): boolean {\n    return false\n  }\n}\n\nexport function $createUnknownConvertedNode({\n  data,\n}: {\n  data: UnknownConvertedNodeData\n}): UnknownConvertedNode {\n  return $applyNodeReplacement(\n    new UnknownConvertedNode({\n      data,\n    }),\n  )\n}\n\nexport function $isUnknownConvertedNode(\n  node: LexicalNode | null | undefined,\n): node is UnknownConvertedNode {\n  return node instanceof UnknownConvertedNode\n}\n"],"mappings":";AAGA,SAASA,sBAAsB,QAAQ;AACvC,SAASC,qBAAqB,EAAEC,aAAa,QAAQ;AACrD,YAAYC,KAAA,MAAW;AAcvB,MAAMC,SAAA,gBAAYD,KAAA,CAAME,IAAI,CAAC,MAC3B,MAAM,CAAC,kBAAkBC,IAAI,CAAEC,MAAA,KAAY;EACzCC,OAAA,EAASD,MAAA,CAAOE;AAClB;AAGF;AACA,OAAO,MAAMC,oBAAA,SAA6BR,aAAA;EACxCS,MAAA;EAEAC,YAAY;IAAEC,IAAI;IAAEC;EAAG,CAAqD,EAAE;IAC5E,KAAK,CAACA,GAAA;IACN,IAAI,CAACH,MAAM,GAAGE,IAAA;EAChB;EAEA,OAAgBE,MAAMC,IAA0B,EAAwB;IACtE,OAAO,IAAI,IAAI,CAAC;MACdH,IAAA,EAAMG,IAAA,CAAKL,MAAM;MACjBG,GAAA,EAAKE,IAAA,CAAKC;IACZ;EACF;EAEA,OAAgBC,QAAA,EAAkB;IAChC,OAAO;EACT;EAEA,OAAgBC,WAAWC,cAA8C,EAAwB;IAC/F,MAAMJ,IAAA,GAAOK,2BAAA,CAA4B;MAAER,IAAA,EAAMO,cAAA,CAAeP;IAAK;IACrE,OAAOG,IAAA;EACT;EAEAM,mBAAA,EAA2B;IACzB,OAAO;EACT;EAEAC,oBAAA,EAA4B;IAC1B,OAAO;EACT;EAESC,UAAUC,MAAoB,EAAe;IACpD,MAAMC,OAAA,GAAUC,QAAA,CAASC,aAAa,CAAC;IACvC5B,sBAAA,CAAuB0B,OAAA,EAAS;IAChC,OAAOA,OAAA;EACT;EAESG,SAAA,EAAwB;IAC/B,oBAAOC,IAAA,CAAC1B,SAAA;MAAUS,IAAA,EAAM,IAAI,CAACF;;EAC/B;EAESoB,WAAA,EAA6C;IACpD,OAAO;MACLC,IAAA,EAAM,IAAI,CAACd,OAAO;MAClBL,IAAA,EAAM,IAAI,CAACF,MAAM;MACjBsB,OAAA,EAAS;IACX;EACF;EAEA;EAESC,SAAA,EAAoB;IAC3B,OAAO;EACT;EAESC,UAAUC,QAAc,EAAEC,GAAgB,EAAW;IAC5D,OAAO;EACT;AACF;AAEA,OAAO,SAAShB,4BAA4B;EAC1CR;AAAI,CAGL;EACC,OAAOZ,qBAAA,CACL,IAAIS,oBAAA,CAAqB;IACvBG;EACF;AAEJ;AAEA,OAAO,SAASyB,wBACdtB,IAAoC;EAEpC,OAAOA,IAAA,YAAgBN,oBAAA;AACzB","ignoreList":[]}
+{"version":3,"sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical'\nimport type { JSX } from 'react'\n\nimport { addClassNamesToElement } from '@lexical/utils'\nimport { $applyNodeReplacement, DecoratorNode } from 'lexical'\nimport * as React from 'react'\n\nexport type UnknownConvertedNodeData = {\n  nodeData: unknown\n  nodeType: string\n}\n\nexport type SerializedUnknownConvertedNode = Spread<\n  {\n    data: UnknownConvertedNodeData\n  },\n  SerializedLexicalNode\n>\n\nconst Component = React.lazy(() =>\n  import('./Component.js').then((module) => ({\n    default: module.UnknownConvertedNodeComponent,\n  })),\n)\n\n/** @noInheritDoc */\nexport class UnknownConvertedNode extends DecoratorNode<JSX.Element> {\n  __data: UnknownConvertedNodeData\n\n  constructor({ data, key }: { data: UnknownConvertedNodeData; key?: NodeKey }) {\n    super(key)\n    this.__data = data\n  }\n\n  static override clone(node: UnknownConvertedNode): UnknownConvertedNode {\n    return new this({\n      data: node.__data,\n      key: node.__key,\n    })\n  }\n\n  static override getType(): string {\n    return 'unknownConverted'\n  }\n\n  static override 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  override createDOM(config: EditorConfig): HTMLElement {\n    const element = document.createElement('span')\n    addClassNamesToElement(element, 'unknownConverted')\n    return element\n  }\n\n  override decorate(): JSX.Element {\n    return <Component data={this.__data} />\n  }\n\n  override exportJSON(): SerializedUnknownConvertedNode {\n    return {\n      type: this.getType(),\n      data: this.__data,\n      version: 1,\n    }\n  }\n\n  // Mutation\n\n  override isInline(): boolean {\n    return true\n  }\n\n  override updateDOM(prevNode: this, dom: HTMLElement): boolean {\n    return false\n  }\n}\n\nexport function $createUnknownConvertedNode({\n  data,\n}: {\n  data: UnknownConvertedNodeData\n}): UnknownConvertedNode {\n  return $applyNodeReplacement(\n    new UnknownConvertedNode({\n      data,\n    }),\n  )\n}\n\nexport function $isUnknownConvertedNode(\n  node: LexicalNode | null | undefined,\n): node is UnknownConvertedNode {\n  return node instanceof UnknownConvertedNode\n}\n"],"names":["addClassNamesToElement","$applyNodeReplacement","DecoratorNode","React","Component","lazy","then","module","default","UnknownConvertedNodeComponent","UnknownConvertedNode","__data","data","key","clone","node","__key","getType","importJSON","serializedNode","$createUnknownConvertedNode","canInsertTextAfter","canInsertTextBefore","createDOM","config","element","document","createElement","decorate","exportJSON","type","version","isInline","updateDOM","prevNode","dom","$isUnknownConvertedNode"],"mappings":";AAGA,SAASA,sBAAsB,QAAQ,iBAAgB;AACvD,SAASC,qBAAqB,EAAEC,aAAa,QAAQ,UAAS;AAC9D,YAAYC,WAAW,QAAO;AAc9B,MAAMC,0BAAYD,MAAME,IAAI,CAAC,IAC3B,MAAM,CAAC,kBAAkBC,IAAI,CAAC,CAACC,SAAY,CAAA;YACzCC,SAASD,OAAOE,6BAA6B;QAC/C,CAAA;AAGF,kBAAkB,GAClB,OAAO,MAAMC,6BAA6BR;IACxCS,OAAgC;IAEhC,YAAY,EAAEC,IAAI,EAAEC,GAAG,EAAqD,CAAE;QAC5E,KAAK,CAACA;QACN,IAAI,CAACF,MAAM,GAAGC;IAChB;IAEA,OAAgBE,MAAMC,IAA0B,EAAwB;QACtE,OAAO,IAAI,IAAI,CAAC;YACdH,MAAMG,KAAKJ,MAAM;YACjBE,KAAKE,KAAKC,KAAK;QACjB;IACF;IAEA,OAAgBC,UAAkB;QAChC,OAAO;IACT;IAEA,OAAgBC,WAAWC,cAA8C,EAAwB;QAC/F,MAAMJ,OAAOK,4BAA4B;YAAER,MAAMO,eAAeP,IAAI;QAAC;QACrE,OAAOG;IACT;IAEAM,qBAA2B;QACzB,OAAO;IACT;IAEAC,sBAA4B;QAC1B,OAAO;IACT;IAESC,UAAUC,MAAoB,EAAe;QACpD,MAAMC,UAAUC,SAASC,aAAa,CAAC;QACvC3B,uBAAuByB,SAAS;QAChC,OAAOA;IACT;IAESG,WAAwB;QAC/B,qBAAO,QAACxB;YAAUQ,MAAM,IAAI,CAACD,MAAM;;;;;;IACrC;IAESkB,aAA6C;QACpD,OAAO;YACLC,MAAM,IAAI,CAACb,OAAO;YAClBL,MAAM,IAAI,CAACD,MAAM;YACjBoB,SAAS;QACX;IACF;IAEA,WAAW;IAEFC,WAAoB;QAC3B,OAAO;IACT;IAESC,UAAUC,QAAc,EAAEC,GAAgB,EAAW;QAC5D,OAAO;IACT;AACF;AAEA,OAAO,SAASf,4BAA4B,EAC1CR,IAAI,EAGL;IACC,OAAOX,sBACL,IAAIS,qBAAqB;QACvBE;IACF;AAEJ;AAEA,OAAO,SAASwB,wBACdrB,IAAoC;IAEpC,OAAOA,gBAAgBL;AACzB"}

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

@@ -0,0 +1,16 @@
+@layer payload-default {
+  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/features/migrations/slateToLexical/converter/converters/blockquote/converter.js

@@ -1,23 +1,23 @@
 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']
+    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/features/migrations/slateToLexical/converter/converters/blockquote/converter.js.map

@@ -1 +1 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateBlockquoteConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '../../../../../blockquote/server/index.js'\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"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,wBAAA,GAA+C;EAC1DC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}
+{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '../../../../../blockquote/server/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateBlockquoteConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'quote',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'quote',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    } as const as SerializedQuoteNode\n  },\n  nodeTypes: ['blockquote'],\n}\n"],"names":["convertSlateNodesToLexical","SlateBlockquoteConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,2BAA+C;IAC1DC,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/features/migrations/slateToLexical/converter/converters/heading/converter.js

@@ -1,24 +1,30 @@
 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']
+    converter ({ converters, slateNode }) {
+        return {
+            type: 'heading',
+            children: convertSlateNodesToLexical({
+                canContainParagraphs: false,
+                converters,
+                parentNodeType: 'heading',
+                slateNodes: slateNode.children
+            }),
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            tag: slateNode.type,
+            // Slate puts the tag (h1 / h2 / ...) inside of node.type
+            version: 1
+        };
+    },
+    nodeTypes: [
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6'
+    ]
 };
+
 //# sourceMappingURL=converter.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateHeadingConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","tag","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '../../../../../heading/server/index.js'\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"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,qBAAA,GAA4C;EACvDC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,GAAA,EAAKT,SAAA,CAAUC,IAAI;MACnBS,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC,MAAM,MAAM,MAAM,MAAM,MAAM;AAC5C","ignoreList":[]}
+{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '../../../../../heading/server/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateHeadingConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'heading',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'heading',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      tag: slateNode.type as 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6', // Slate puts the tag (h1 / h2 / ...) inside of node.type\n      version: 1,\n    } as const as SerializedHeadingNode\n  },\n  nodeTypes: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],\n}\n"],"names":["convertSlateNodesToLexical","SlateHeadingConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","tag","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,wBAA4C;IACvDC,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;YAA6C,yDAAyD;YACzHS,SAAS;QACX;IACF;IACAC,WAAW;QAAC;QAAM;QAAM;QAAM;QAAM;QAAM;KAAK;AACjD,EAAC"}

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

@@ -1,33 +1,35 @@
 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
+    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
+            };
         };
-      }
-      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']
+        return convertChildren(slateNode);
+    },
+    nodeTypes: [
+        'indent'
+    ]
 };
+
 //# sourceMappingURL=converter.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateIndentConverter","converter","converters","slateNode","convertChildren","node","indentLevel","type","children","text","canContainParagraphs","parentNodeType","slateNodes","indent","map","child","direction","format","version","nodeTypes"],"sources":["../../../../../../../src/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"],"mappings":"AAIA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,oBAAA,GAA2C;EACtDC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,MAAMC,eAAA,GAAkBA,CAACC,IAAA,EAAWC,WAAA,GAAsB,CAAC;MACzD,IACED,IAAC,EAAME,IAAA,KAAS,CAACF,IAAA,CAAKG,QAAQ,IAAIH,IAAA,CAAKE,IAAI,KAAK,QAAO,KACtD,CAACF,IAAA,EAAME,IAAA,IAAQF,IAAA,EAAMI,IAAA,EACtB;QACA,OAAO;UACL,GAAGV,0BAAA,CAA2B;YAC5BW,oBAAA,EAAsB;YACtBR,UAAA;YACAS,cAAA,EAAgB;YAChBC,UAAA,EAAY,CAACP,IAAA;UACf,EAAE,CAAC,EAAE;UACLQ,MAAA,EAAQP;QACV;MACF;MAEA,MAAME,QAAA,GAAWH,IAAA,CAAKG,QAAQ,CAACM,GAAG,CAAEC,KAAA,IAAeX,eAAA,CAAgBW,KAAA,EAAOT,WAAA,GAAc;MACxF,OAAO;QACLC,IAAA,EAAM;QACNC,QAAA;QACAQ,SAAA,EAAW;QACXC,MAAA,EAAQ;QACRJ,MAAA,EAAQP,WAAA;QACRY,OAAA,EAAS;MACX;IACF;IAEA,OAAOd,eAAA,CAAgBD,SAAA;EACzB;EACAgB,SAAA,EAAW,CAAC;AACd","ignoreList":[]}
+{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/converter.ts"],"sourcesContent":["import type { SerializedLexicalNode, SerializedParagraphNode } from 'lexical'\n\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateIndentConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    const convertChildren = (node: any, indentLevel: number = 0): SerializedLexicalNode => {\n      if (\n        (node?.type && (!node.children || node.type !== 'indent')) ||\n        (!node?.type && node?.text)\n      ) {\n        return {\n          ...convertSlateNodesToLexical({\n            canContainParagraphs: false,\n            converters,\n            parentNodeType: 'indent',\n            slateNodes: [node],\n          })[0],\n          indent: indentLevel,\n        } as const as SerializedLexicalNode\n      }\n\n      const children = node.children.map((child: any) => convertChildren(child, indentLevel + 1))\n      return {\n        type: 'paragraph',\n        children,\n        direction: 'ltr',\n        format: '',\n        indent: indentLevel,\n        version: 1,\n      } as const as SerializedParagraphNode\n    }\n\n    return convertChildren(slateNode)\n  },\n  nodeTypes: ['indent'],\n}\n"],"names":["convertSlateNodesToLexical","SlateIndentConverter","converter","converters","slateNode","convertChildren","node","indentLevel","type","children","text","canContainParagraphs","parentNodeType","slateNodes","indent","map","child","direction","format","version","nodeTypes"],"mappings":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,uBAA2C;IACtDC,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/features/migrations/slateToLexical/converter/converters/link/converter.js

@@ -1,30 +1,31 @@
 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.linkType || 'custom') === 'custom' ? slateNode.url || 'https' : undefined
-      },
-      format: '',
-      indent: 0,
-      version: 2
-    };
-  },
-  nodeTypes: ['link']
+    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.linkType || 'custom') === 'custom' ? slateNode.url || 'https' : undefined
+            },
+            // can be undefined only if linkType is not custom, otherwise: validation error
+            format: '',
+            indent: 0,
+            version: 2
+        };
+    },
+    nodeTypes: [
+        'link'
+    ]
 };
+
 //# sourceMappingURL=converter.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateLinkConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","fields","doc","linkType","newTab","url","undefined","format","indent","version","nodeTypes"],"sources":["../../../../../../../src/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.linkType || 'custom') === 'custom' ? slateNode.url || 'https' : undefined, // can be undefined only if linkType is not custom, otherwise: validation error\n      },\n      format: '',\n      indent: 0,\n      version: 2,\n    } as const as SerializedLinkNode\n  },\n  nodeTypes: ['link'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,kBAAA,GAAyC;EACpDC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;QACN,IAAIP,SAAA,CAAUO,MAAM,IAAI,CAAC,CAAC;QAC1BC,GAAA,EAAKR,SAAA,CAAUQ,GAAG,IAAI;QACtBC,QAAA,EAAUT,SAAA,CAAUS,QAAQ,IAAI;QAChCC,MAAA,EAAQV,SAAA,CAAUU,MAAM,IAAI;QAC5BC,GAAA,EAAK,CAACX,SAAA,CAAUS,QAAQ,IAAI,QAAO,MAAO,WAAWT,SAAA,CAAUW,GAAG,IAAI,UAAUC;MAClF;MACAC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}
+{"version":3,"sources":["../../../../../../../src/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.linkType || 'custom') === 'custom' ? slateNode.url || 'https' : undefined, // can be undefined only if linkType is not custom, otherwise: validation error\n      },\n      format: '',\n      indent: 0,\n      version: 2,\n    } as const as SerializedLinkNode\n  },\n  nodeTypes: ['link'],\n}\n"],"names":["convertSlateNodesToLexical","SlateLinkConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","fields","doc","linkType","newTab","url","undefined","format","indent","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,qBAAyC;IACpDC,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,KAAK,AAACX,CAAAA,UAAUS,QAAQ,IAAI,QAAO,MAAO,WAAWT,UAAUW,GAAG,IAAI,UAAUC;YAClF;YAD6F,+EAA+E;YAE5KC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAO;AACrB,EAAC"}

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

@@ -1,26 +1,25 @@
 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']
+    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/features/migrations/slateToLexical/converter/converters/listItem/converter.js.map

@@ -1 +1 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateListItemConverter","converter","childIndex","converters","slateNode","type","checked","undefined","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","value","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '../../../../../lists/plugin/index.js'\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"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,sBAAA,GAA6C;EACxDC,UAAU;IAAEC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IAC7C,OAAO;MACLC,IAAA,EAAM;MACNC,OAAA,EAASC,SAAA;MACTC,QAAA,EAAUT,0BAAA,CAA2B;QACnCU,oBAAA,EAAsB;QACtBN,UAAA;QACAO,cAAA,EAAgB;QAChBC,UAAA,EAAYP,SAAA,CAAUI;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,KAAA,EAAOb,UAAA,GAAa;MACpBc,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}
+{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateListItemConverter: SlateNodeConverter = {\n  converter({ childIndex, converters, slateNode }) {\n    return {\n      type: 'listitem',\n      checked: undefined,\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'listitem',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      value: childIndex + 1,\n      version: 1,\n    } as const as SerializedListItemNode\n  },\n  nodeTypes: ['li'],\n}\n"],"names":["convertSlateNodesToLexical","SlateListItemConverter","converter","childIndex","converters","slateNode","type","checked","undefined","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","value","version","nodeTypes"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,yBAA6C;IACxDC,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/features/migrations/slateToLexical/converter/converters/orderedList/converter.js

@@ -1,26 +1,26 @@
 import { convertSlateNodesToLexical } from '../../index.js';
 export const SlateOrderedListConverter = {
-  converter({
-    converters,
-    slateNode
-  }) {
-    return {
-      type: 'list',
-      children: convertSlateNodesToLexical({
-        canContainParagraphs: false,
-        converters,
-        parentNodeType: 'list',
-        slateNodes: slateNode.children
-      }),
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      listType: 'number',
-      start: 1,
-      tag: 'ol',
-      version: 1
-    };
-  },
-  nodeTypes: ['ol']
+    converter ({ converters, slateNode }) {
+        return {
+            type: 'list',
+            children: convertSlateNodesToLexical({
+                canContainParagraphs: false,
+                converters,
+                parentNodeType: 'list',
+                slateNodes: slateNode.children
+            }),
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            listType: 'number',
+            start: 1,
+            tag: 'ol',
+            version: 1
+        };
+    },
+    nodeTypes: [
+        'ol'
+    ]
 };
+
 //# sourceMappingURL=converter.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateOrderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateOrderedListConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'list',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'list',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      listType: 'number',\n      start: 1,\n      tag: 'ol',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ol'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,yBAAA,GAAgD;EAC3DC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,QAAA,EAAU;MACVC,KAAA,EAAO;MACPC,GAAA,EAAK;MACLC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}
+{"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateOrderedListConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'list',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'list',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      listType: 'number',\n      start: 1,\n      tag: 'ol',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ol'],\n}\n"],"names":["convertSlateNodesToLexical","SlateOrderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"mappings":"AAGA,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,UAAU;YACVC,OAAO;YACPC,KAAK;YACLC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAK;AACnB,EAAC"}

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

@@ -1,15 +1,16 @@
 export const SlateRelationshipConverter = {
-  converter({
-    slateNode
-  }) {
-    return {
-      type: 'relationship',
-      format: '',
-      relationTo: slateNode.relationTo,
-      value: slateNode?.value?.id || '',
-      version: 2
-    };
-  },
-  nodeTypes: ['relationship']
+    converter ({ slateNode }) {
+        return {
+            type: 'relationship',
+            format: '',
+            relationTo: slateNode.relationTo,
+            value: slateNode?.value?.id || '',
+            version: 2
+        };
+    },
+    nodeTypes: [
+        'relationship'
+    ]
 };
+
 //# sourceMappingURL=converter.js.map