@ruya.sa/richtext-lexical 3.71.7

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateUnknownConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/converter.ts"],"sourcesContent":["import type { SerializedUnknownConvertedNode } from '../../../nodes/unknownConvertedNode/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateUnknownConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'unknownConverted',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'unknownConverted',\n        slateNodes: slateNode.children!,\n      }),\n      data: {\n        nodeData: slateNode,\n        nodeType: slateNode.type,\n      },\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    } as const as SerializedUnknownConvertedNode\n  },\n  nodeTypes: ['unknown'],\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,IAAA,EAAM;QACJC,QAAA,EAAUP,SAAA;QACVQ,QAAA,EAAUR,SAAA,CAAUC;MACtB;MACAQ,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

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

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

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

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

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

@@ -0,0 +1,26 @@
+import { convertSlateNodesToLexical } from '../../index.js';
+export const SlateUnorderedListConverter = {
+  converter({
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'list',
+      children: 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=converter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateUnorderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unorderedList/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 SlateUnorderedListConverter: 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: 'bullet',\n      start: 1,\n      tag: 'ul',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ul'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,2BAAA,GAAkD;EAC7DC,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":[]}

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"converter.js","names":["SlateUploadConverter","converter","slateNode","type","fields","format","relationTo","value","id","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["import type { SerializedUploadNode } from '../../../../../upload/server/nodes/UploadNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const SlateUploadConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'upload',\n      fields: {\n        ...slateNode.fields,\n      },\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode.value?.id || '',\n      version: 2,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"mappings":"AAGA,OAAO,MAAMA,oBAAA,GAA2C;EACtDC,UAAU;IAAEC;EAAS,CAAE;IACrB,OAAO;MACLC,IAAA,EAAM;MACNC,MAAA,EAAQ;QACN,GAAGF,SAAA,CAAUE;MACf;MACAC,MAAA,EAAQ;MACRC,UAAA,EAAYJ,SAAA,CAAUI,UAAU;MAChCC,KAAA,EAAOL,SAAA,CAAUK,KAAK,EAAEC,EAAA,IAAM;MAC9BC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/slateToLexical/converter/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAapD,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,EAWtD,CAAA"}

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

@@ -0,0 +1,12 @@
+import { SlateBlockquoteConverter } from './converters/blockquote/converter.js';
+import { SlateHeadingConverter } from './converters/heading/converter.js';
+import { SlateIndentConverter } from './converters/indent/converter.js';
+import { SlateLinkConverter } from './converters/link/converter.js';
+import { SlateListItemConverter } from './converters/listItem/converter.js';
+import { SlateOrderedListConverter } from './converters/orderedList/converter.js';
+import { SlateRelationshipConverter } from './converters/relationship/converter.js';
+import { SlateUnknownConverter } from './converters/unknown/converter.js';
+import { SlateUnorderedListConverter } from './converters/unorderedList/converter.js';
+import { SlateUploadConverter } from './converters/upload/converter.js';
+export const defaultSlateConverters = [SlateBlockquoteConverter, SlateHeadingConverter, SlateIndentConverter, SlateLinkConverter, SlateListItemConverter, SlateOrderedListConverter, SlateRelationshipConverter, SlateUnorderedListConverter, SlateUploadConverter, SlateUnknownConverter];
+//# sourceMappingURL=defaultConverters.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConverters.js","names":["SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters"],"sources":["../../../../../src/features/migrations/slateToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { SlateNodeConverter } from './types.js'\n\nimport { SlateBlockquoteConverter } from './converters/blockquote/converter.js'\nimport { SlateHeadingConverter } from './converters/heading/converter.js'\nimport { SlateIndentConverter } from './converters/indent/converter.js'\nimport { SlateLinkConverter } from './converters/link/converter.js'\nimport { SlateListItemConverter } from './converters/listItem/converter.js'\nimport { SlateOrderedListConverter } from './converters/orderedList/converter.js'\nimport { SlateRelationshipConverter } from './converters/relationship/converter.js'\nimport { SlateUnknownConverter } from './converters/unknown/converter.js'\nimport { SlateUnorderedListConverter } from './converters/unorderedList/converter.js'\nimport { SlateUploadConverter } from './converters/upload/converter.js'\n\nexport const defaultSlateConverters: SlateNodeConverter[] = [\n  SlateBlockquoteConverter,\n  SlateHeadingConverter,\n  SlateIndentConverter,\n  SlateLinkConverter,\n  SlateListItemConverter,\n  SlateOrderedListConverter,\n  SlateRelationshipConverter,\n  SlateUnorderedListConverter,\n  SlateUploadConverter,\n  SlateUnknownConverter,\n]\n"],"mappings":"AAEA,SAASA,wBAAwB,QAAQ;AACzC,SAASC,qBAAqB,QAAQ;AACtC,SAASC,oBAAoB,QAAQ;AACrC,SAASC,kBAAkB,QAAQ;AACnC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,yBAAyB,QAAQ;AAC1C,SAASC,0BAA0B,QAAQ;AAC3C,SAASC,qBAAqB,QAAQ;AACtC,SAASC,2BAA2B,QAAQ;AAC5C,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,sBAAA,GAA+C,CAC1DV,wBAAA,EACAC,qBAAA,EACAC,oBAAA,EACAC,kBAAA,EACAC,sBAAA,EACAC,yBAAA,EACAC,0BAAA,EACAE,2BAAA,EACAC,oBAAA,EACAF,qBAAA,CACD","ignoreList":[]}

package/dist/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.js';
+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/features/migrations/slateToLexical/converter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/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,YAAY,CAAA;AAI/D,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,CAiD1B;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,kBAAkB,EAAE,EAChC,IAAI,EAAE,SAAS,GACd,uBAAuB,CAgBzB;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,kBAAkB,CAUnE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAwB3D"}

package/dist/features/migrations/slateToLexical/converter/index.js

@@ -0,0 +1,130 @@
+import { NodeFormat } from '../../../../lexical/utils/nodeFormat.js';
+export function convertSlateToLexical({
+  converters,
+  slateData
+}) {
+  return {
+    root: {
+      type: 'root',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: true,
+        converters,
+        parentNodeType: 'root',
+        slateNodes: slateData
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
+    }
+  };
+}
+export function convertSlateNodesToLexical({
+  canContainParagraphs,
+  converters,
+  parentNodeType,
+  slateNodes
+}) {
+  if (!converters?.length || !slateNodes?.length) {
+    return [];
+  }
+  const unknownConverter = converters.find(converter => converter.nodeTypes.includes('unknown'));
+  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix
+  return (
+    // Flatten in case we unwrap an array of child nodes
+    slateNodes.flatMap((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 {
+          // Unwrap generic Slate nodes recursively since depth wasn't guaranteed by Slate, especially when copy + pasting rich text
+          // - If there are children and it can't be a paragraph in Lexical, assume that the generic node should be unwrapped until the text nodes, and only assume that its a text node when there are no more children
+          if (slateNode.children) {
+            return convertSlateNodesToLexical({
+              canContainParagraphs,
+              converters,
+              parentNodeType,
+              slateNodes: slateNode.children || []
+            });
+          }
+          // This is a simple text node. canContainParagraphs may be false if this is nested inside 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
+      });
+    }) || []
+  );
+}
+export function convertParagraphNode(converters, node) {
+  return {
+    type: 'paragraph',
+    children: convertSlateNodesToLexical({
+      canContainParagraphs: false,
+      converters,
+      parentNodeType: 'paragraph',
+      slateNodes: node.children || []
+    }),
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    textFormat: 0,
+    textStyle: '',
+    version: 1
+  };
+}
+export function convertTextNode(node) {
+  return {
+    type: 'text',
+    detail: 0,
+    format: convertNodeToFormat(node),
+    mode: 'normal',
+    style: '',
+    text: node.text ?? '',
+    version: 1
+  };
+}
+export function convertNodeToFormat(node) {
+  let format = 0;
+  if (node.bold) {
+    format = format | NodeFormat.IS_BOLD;
+  }
+  if (node.italic) {
+    format = format | NodeFormat.IS_ITALIC;
+  }
+  if (node.strikethrough) {
+    format = format | NodeFormat.IS_STRIKETHROUGH;
+  }
+  if (node.underline) {
+    format = format | NodeFormat.IS_UNDERLINE;
+  }
+  if (node.subscript) {
+    format = format | NodeFormat.IS_SUBSCRIPT;
+  }
+  if (node.superscript) {
+    format = format | NodeFormat.IS_SUPERSCRIPT;
+  }
+  if (node.code) {
+    format = format | NodeFormat.IS_CODE;
+  }
+  return format;
+}
+//# sourceMappingURL=index.js.map

package/dist/features/migrations/slateToLexical/converter/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["NodeFormat","convertSlateToLexical","converters","slateData","root","type","children","convertSlateNodesToLexical","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","flatMap","slateNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node","textFormat","textStyle","detail","convertNodeToFormat","mode","style","text","bold","IS_BOLD","italic","IS_ITALIC","strikethrough","IS_STRIKETHROUGH","underline","IS_UNDERLINE","subscript","IS_SUBSCRIPT","superscript","IS_SUPERSCRIPT","code","IS_CODE"],"sources":["../../../../../src/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.js'\n\nimport { NodeFormat } from '../../../../lexical/utils/nodeFormat.js'\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 || !slateNodes?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix\n  return (\n    // Flatten in case we unwrap an array of child nodes\n    slateNodes.flatMap((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          // Unwrap generic Slate nodes recursively since depth wasn't guaranteed by Slate, especially when copy + pasting rich text\n          // - If there are children and it can't be a paragraph in Lexical, assume that the generic node should be unwrapped until the text nodes, and only assume that its a text node when there are no more children\n          if (slateNode.children) {\n            return convertSlateNodesToLexical({\n              canContainParagraphs,\n              converters,\n              parentNodeType,\n              slateNodes: slateNode.children || [],\n            })\n          }\n          // This is a simple text node. canContainParagraphs may be false if this is nested inside 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) =>\n        converter.nodeTypes.includes(slateNode.type!),\n      )\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    textFormat: 0,\n    textStyle: '',\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"],"mappings":"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","ignoreList":[]}

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

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

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

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

package/dist/features/migrations/slateToLexical/converter/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/features/migrations/slateToLexical/converter/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nexport type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    parentNodeType,\n    slateNode,\n  }: {\n    childIndex: number\n    converters: SlateNodeConverter[]\n    parentNodeType: string\n    slateNode: SlateNode\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type SlateNode = {\n  [key: string]: any\n  children?: SlateNode[]\n  type?: string // doesn't always have type, e.g. for paragraphs\n}\n"],"mappings":"AAiBA","ignoreList":[]}

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

@@ -0,0 +1,2 @@
+export declare const SlateToLexicalFeatureClient: import("../../typesClient.js").FeatureProviderProviderClient<undefined, undefined>;
+//# sourceMappingURL=feature.client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"names":[],"mappings":"AAKA,eAAO,MAAM,2BAA2B,oFAItC,CAAA"}

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

@@ -0,0 +1,10 @@
+'use client';
+
+import { createClientFeature } from '../../../utilities/createClientFeature.js';
+import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
+export const SlateToLexicalFeatureClient = createClientFeature(() => {
+  return {
+    nodes: [UnknownConvertedNode]
+  };
+});
+//# sourceMappingURL=feature.client.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.js","names":["createClientFeature","UnknownConvertedNode","SlateToLexicalFeatureClient","nodes"],"sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const SlateToLexicalFeatureClient = createClientFeature(() => {\n  return {\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"mappings":"AAAA;;AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,2BAAA,GAA8BF,mBAAA,CAAoB;EAC7D,OAAO;IACLG,KAAA,EAAO,CAACF,oBAAA;EACV;AACF","ignoreList":[]}

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

@@ -0,0 +1,40 @@
+import type { SlateNodeConverter } from './converter/types.js';
+export type SlateToLexicalFeatureProps = {
+    /**
+     * Custom converters to transform Slate nodes to Lexical nodes.
+     * Can be an array of converters or a function that receives default converters and returns an array.
+     * @default defaultSlateConverters
+     */
+    converters?: (({ defaultConverters }: {
+        defaultConverters: SlateNodeConverter[];
+    }) => SlateNodeConverter[]) | SlateNodeConverter[];
+    /**
+     * When true, disables the afterRead hook that converts Slate data on-the-fly.
+     * Set this to true when running the migration script. That way, this feature is only used
+     * to "pass through" the converters to the migration script.
+     * @default false
+     */
+    disableHooks?: boolean;
+};
+/**
+ * Enables on-the-fly conversion of Slate data to Lexical format through an afterRead hook.
+ * Used for testing migrations before running the permanent migration script.
+ * Only converts data that is in Slate format (arrays); Lexical data passes through unchanged.
+ *
+ * @example
+ * ```ts
+ * lexicalEditor({
+ *   features: ({ defaultFeatures }) => [
+ *     ...defaultFeatures,
+ *     SlateToLexicalFeature({
+ *       converters: [...defaultSlateConverters, MyCustomConverter],
+ *       disableHooks: false, // Set to true during migration script
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export declare const SlateToLexicalFeature: import("../../typesServer.js").FeatureProviderProviderServer<SlateToLexicalFeatureProps, {
+    converters?: SlateNodeConverter[];
+}, undefined>;
+//# sourceMappingURL=feature.server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/slateToLexical/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAO9D,MAAM,MAAM,0BAA0B,GAAG;IACvC;;;;OAIG;IACH,UAAU,CAAC,EACP,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE;QAAE,iBAAiB,EAAE,kBAAkB,EAAE,CAAA;KAAE,KAAK,kBAAkB,EAAE,CAAC,GAC9F,kBAAkB,EAAE,CAAA;IACxB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB;iBAGjB,kBAAkB,EAAE;aAkDnC,CAAA"}

package/dist/features/migrations/slateToLexical/feature.server.js

@@ -0,0 +1,68 @@
+import { createServerFeature } from '../../../utilities/createServerFeature.js';
+import { defaultSlateConverters } from './converter/defaultConverters.js';
+import { convertSlateToLexical } from './converter/index.js';
+import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
+/**
+ * Enables on-the-fly conversion of Slate data to Lexical format through an afterRead hook.
+ * Used for testing migrations before running the permanent migration script.
+ * Only converts data that is in Slate format (arrays); Lexical data passes through unchanged.
+ *
+ * @example
+ * ```ts
+ * lexicalEditor({
+ *   features: ({ defaultFeatures }) => [
+ *     ...defaultFeatures,
+ *     SlateToLexicalFeature({
+ *       converters: [...defaultSlateConverters, MyCustomConverter],
+ *       disableHooks: false, // Set to true during migration script
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export const SlateToLexicalFeature = createServerFeature({
+  feature: ({
+    props
+  }) => {
+    if (!props) {
+      props = {};
+    }
+    let converters = [];
+    if (props?.converters && typeof props?.converters === 'function') {
+      converters = props.converters({
+        defaultConverters: defaultSlateConverters
+      });
+    } else if (props.converters && typeof props?.converters !== 'function') {
+      converters = props.converters;
+    } else {
+      converters = defaultSlateConverters;
+    }
+    props.converters = converters;
+    return {
+      ClientFeature: '@ruya.sa/richtext-lexical/client#SlateToLexicalFeatureClient',
+      hooks: props.disableHooks ? undefined : {
+        afterRead: [({
+          value
+        }) => {
+          if (!value || !Array.isArray(value) || 'root' in value) {
+            // incomingEditorState null or not from Slate
+            return value;
+          }
+          // Slate => convert to lexical
+          return convertSlateToLexical({
+            converters: props.converters,
+            slateData: value
+          });
+        }]
+      },
+      nodes: [{
+        node: UnknownConvertedNode
+      }],
+      sanitizedServerFeatureProps: {
+        converters
+      }
+    };
+  },
+  key: 'slateToLexical'
+});
+//# sourceMappingURL=feature.server.js.map

package/dist/features/migrations/slateToLexical/feature.server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.js","names":["createServerFeature","defaultSlateConverters","convertSlateToLexical","UnknownConvertedNode","SlateToLexicalFeature","feature","props","converters","defaultConverters","ClientFeature","hooks","disableHooks","undefined","afterRead","value","Array","isArray","slateData","nodes","node","sanitizedServerFeatureProps","key"],"sources":["../../../../src/features/migrations/slateToLexical/feature.server.ts"],"sourcesContent":["import type { SlateNodeConverter } from './converter/types.js'\n\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\nimport { defaultSlateConverters } from './converter/defaultConverters.js'\nimport { convertSlateToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type SlateToLexicalFeatureProps = {\n  /**\n   * Custom converters to transform Slate nodes to Lexical nodes.\n   * Can be an array of converters or a function that receives default converters and returns an array.\n   * @default defaultSlateConverters\n   */\n  converters?:\n    | (({ defaultConverters }: { defaultConverters: SlateNodeConverter[] }) => SlateNodeConverter[])\n    | SlateNodeConverter[]\n  /**\n   * When true, disables the afterRead hook that converts Slate data on-the-fly.\n   * Set this to true when running the migration script. That way, this feature is only used\n   * to \"pass through\" the converters to the migration script.\n   * @default false\n   */\n  disableHooks?: boolean\n}\n\n/**\n * Enables on-the-fly conversion of Slate data to Lexical format through an afterRead hook.\n * Used for testing migrations before running the permanent migration script.\n * Only converts data that is in Slate format (arrays); Lexical data passes through unchanged.\n *\n * @example\n * ```ts\n * lexicalEditor({\n *   features: ({ defaultFeatures }) => [\n *     ...defaultFeatures,\n *     SlateToLexicalFeature({\n *       converters: [...defaultSlateConverters, MyCustomConverter],\n *       disableHooks: false, // Set to true during migration script\n *     }),\n *   ],\n * })\n * ```\n */\nexport const SlateToLexicalFeature = createServerFeature<\n  SlateToLexicalFeatureProps,\n  {\n    converters?: SlateNodeConverter[]\n  }\n>({\n  feature: ({ props }) => {\n    if (!props) {\n      props = {}\n    }\n\n    let converters: SlateNodeConverter[] = []\n    if (props?.converters && typeof props?.converters === 'function') {\n      converters = props.converters({ defaultConverters: defaultSlateConverters })\n    } else if (props.converters && typeof props?.converters !== 'function') {\n      converters = props.converters\n    } else {\n      converters = defaultSlateConverters\n    }\n\n    props.converters = converters\n\n    return {\n      ClientFeature: '@ruya.sa/richtext-lexical/client#SlateToLexicalFeatureClient',\n      hooks: props.disableHooks\n        ? undefined\n        : {\n            afterRead: [\n              ({ value }) => {\n                if (!value || !Array.isArray(value) || 'root' in value) {\n                  // incomingEditorState null or not from Slate\n                  return value\n                }\n\n                // Slate => convert to lexical\n                return convertSlateToLexical({\n                  converters: props.converters as SlateNodeConverter[],\n                  slateData: value,\n                })\n              },\n            ],\n          },\n      nodes: [\n        {\n          node: UnknownConvertedNode,\n        },\n      ],\n      sanitizedServerFeatureProps: {\n        converters,\n      },\n    }\n  },\n  key: 'slateToLexical',\n})\n"],"mappings":"AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,qBAAqB,QAAQ;AACtC,SAASC,oBAAoB,QAAQ;AAoBrC;;;;;;;;;;;;;;;;;;AAkBA,OAAO,MAAMC,qBAAA,GAAwBJ,mBAAA,CAKnC;EACAK,OAAA,EAASA,CAAC;IAAEC;EAAK,CAAE;IACjB,IAAI,CAACA,KAAA,EAAO;MACVA,KAAA,GAAQ,CAAC;IACX;IAEA,IAAIC,UAAA,GAAmC,EAAE;IACzC,IAAID,KAAA,EAAOC,UAAA,IAAc,OAAOD,KAAA,EAAOC,UAAA,KAAe,YAAY;MAChEA,UAAA,GAAaD,KAAA,CAAMC,UAAU,CAAC;QAAEC,iBAAA,EAAmBP;MAAuB;IAC5E,OAAO,IAAIK,KAAA,CAAMC,UAAU,IAAI,OAAOD,KAAA,EAAOC,UAAA,KAAe,YAAY;MACtEA,UAAA,GAAaD,KAAA,CAAMC,UAAU;IAC/B,OAAO;MACLA,UAAA,GAAaN,sBAAA;IACf;IAEAK,KAAA,CAAMC,UAAU,GAAGA,UAAA;IAEnB,OAAO;MACLE,aAAA,EAAe;MACfC,KAAA,EAAOJ,KAAA,CAAMK,YAAY,GACrBC,SAAA,GACA;QACEC,SAAA,EAAW,CACT,CAAC;UAAEC;QAAK,CAAE;UACR,IAAI,CAACA,KAAA,IAAS,CAACC,KAAA,CAAMC,OAAO,CAACF,KAAA,KAAU,UAAUA,KAAA,EAAO;YACtD;YACA,OAAOA,KAAA;UACT;UAEA;UACA,OAAOZ,qBAAA,CAAsB;YAC3BK,UAAA,EAAYD,KAAA,CAAMC,UAAU;YAC5BU,SAAA,EAAWH;UACb;QACF;MAEJ;MACJI,KAAA,EAAO,CACL;QACEC,IAAA,EAAMhB;MACR,EACD;MACDiB,2BAAA,EAA6B;QAC3Bb;MACF;IACF;EACF;EACAc,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { UnknownConvertedNodeData } from './index.js';
+import './index.scss';
+type Props = {
+    data: UnknownConvertedNodeData;
+};
+export declare const UnknownConvertedNodeComponent: React.FC<Props>;
+export {};
+//# sourceMappingURL=Component.d.ts.map

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.d.ts.map

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

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.js

@@ -0,0 +1,15 @@
+'use client';
+
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+export const UnknownConvertedNodeComponent = props => {
+  const {
+    data
+  } = props;
+  return /*#__PURE__*/_jsxs("div", {
+    children: ["Unknown converted Slate node: ", /*#__PURE__*/_jsx("strong", {
+      children: data?.nodeType
+    })]
+  });
+};
+//# sourceMappingURL=Component.js.map

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Component.js","names":["React","UnknownConvertedNodeComponent","props","data","_jsxs","_jsx","nodeType"],"sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["'use client'\nimport React from 'react'\n\nimport type { UnknownConvertedNodeData } from './index.js'\n\nimport './index.scss'\n\ntype Props = {\n  data: UnknownConvertedNodeData\n}\n\nexport const UnknownConvertedNodeComponent: React.FC<Props> = (props) => {\n  const { data } = props\n\n  return (\n    <div>\n      Unknown converted Slate node: <strong>{data?.nodeType}</strong>\n    </div>\n  )\n}\n"],"mappings":"AAAA;;;AACA,OAAOA,KAAA,MAAW;AAUlB,OAAO,MAAMC,6BAAA,GAAkDC,KAAA;EAC7D,MAAM;IAAEC;EAAI,CAAE,GAAGD,KAAA;EAEjB,oBACEE,KAAA,CAAC;eAAI,kC,aAC2BC,IAAA,CAAC;gBAAQF,IAAA,EAAMG;;;AAGnD","ignoreList":[]}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAGhC,OAAO,EAAyB,aAAa,EAAE,MAAM,SAAS,CAAA;AAG9D,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;WAK5D,KAAK,CAAC,IAAI,EAAE,oBAAoB,GAAG,oBAAoB;WAOvD,OAAO,IAAI,MAAM;WAIjB,UAAU,CAAC,cAAc,EAAE,8BAA8B,GAAG,oBAAoB;IAKhG,kBAAkB,IAAI,IAAI;IAI1B,mBAAmB,IAAI,IAAI;IAIlB,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,QAAQ,IAAI,GAAG,CAAC,OAAO;IAIvB,UAAU,IAAI,8BAA8B;IAU5C,QAAQ,IAAI,OAAO;IAInB,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO;CAG9D;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,GACL,EAAE;IACD,IAAI,EAAE,wBAAwB,CAAA;CAC/B,GAAG,oBAAoB,CAMvB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,oBAAoB,CAE9B"}