@payloadcms/richtext-lexical 3.0.0-beta.4 → 3.0.0-beta.41

package/dist/field/features/lists/shared/markdown.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/shared/markdown.ts"],"sourcesContent":["// Copied from https://github.com/facebook/lexical/blob/176b8cf16ecb332ee5efe2c75219e223b7b019f2/packages/lexical-markdown/src/MarkdownTransformers.ts#L97C1-L172C1\n\nimport type { ListNode, ListType } from '@lexical/list'\nimport type { ElementTransformer } from '@lexical/markdown'\nimport type { ElementNode } from 'lexical'\n\nimport { $createListItemNode, $createListNode, $isListItemNode, $isListNode } from '@lexical/list'\n\n// Amount of spaces that define indentation level\nconst LIST_INDENT_SIZE = 4\n\nexport const listReplace = (listType: ListType): ElementTransformer['replace'] => {\n  return (parentNode, children, match) => {\n    const previousNode = parentNode.getPreviousSibling()\n    const nextNode = parentNode.getNextSibling()\n    const listItem = $createListItemNode(listType === 'check' ? match[3] === 'x' : undefined)\n    if ($isListNode(nextNode) && nextNode.getListType() === listType) {\n      const firstChild = nextNode.getFirstChild()\n      if (firstChild !== null) {\n        firstChild.insertBefore(listItem)\n      } else {\n        // should never happen, but let's handle gracefully, just in case.\n        nextNode.append(listItem)\n      }\n      parentNode.remove()\n    } else if ($isListNode(previousNode) && previousNode.getListType() === listType) {\n      previousNode.append(listItem)\n      parentNode.remove()\n    } else {\n      const list = $createListNode(listType, listType === 'number' ? Number(match[2]) : undefined)\n      list.append(listItem)\n      parentNode.replace(list)\n    }\n    listItem.append(...children)\n    listItem.select(0, 0)\n    const indent = Math.floor(match[1].length / LIST_INDENT_SIZE)\n    if (indent) {\n      listItem.setIndent(indent)\n    }\n  }\n}\n\nexport const listExport = (\n  listNode: ListNode,\n  exportChildren: (node: ElementNode) => string,\n  depth: number,\n): string => {\n  const output = []\n  const children = listNode.getChildren()\n  let index = 0\n  for (const listItemNode of children) {\n    if ($isListItemNode(listItemNode)) {\n      if (listItemNode.getChildrenSize() === 1) {\n        const firstChild = listItemNode.getFirstChild()\n        if ($isListNode(firstChild)) {\n          output.push(listExport(firstChild, exportChildren, depth + 1))\n          continue\n        }\n      }\n      const indent = ' '.repeat(depth * LIST_INDENT_SIZE)\n      const listType = listNode.getListType()\n      const prefix =\n        listType === 'number'\n          ? `${listNode.getStart() + index}. `\n          : listType === 'check'\n            ? `- [${listItemNode.getChecked() ? 'x' : ' '}] `\n            : '- '\n      output.push(indent + prefix + exportChildren(listItemNode))\n      index++\n    }\n  }\n\n  return output.join('\\n')\n}\n"],"names":["$createListItemNode","$createListNode","$isListItemNode","$isListNode","LIST_INDENT_SIZE","listReplace","listType","parentNode","children","match","previousNode","getPreviousSibling","nextNode","getNextSibling","listItem","undefined","getListType","firstChild","getFirstChild","insertBefore","append","remove","list","Number","replace","select","indent","Math","floor","length","setIndent","listExport","listNode","exportChildren","depth","output","getChildren","index","listItemNode","getChildrenSize","push","repeat","prefix","getStart","getChecked","join"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,mKAAmK;AAMnK,SAASA,mBAAmB,EAAEC,eAAe,EAAEC,eAAe,EAAEC,WAAW,QAAQ,gBAAe;AAElG,iDAAiD;AACjD,MAAMC,mBAAmB;AAEzB,OAAO,MAAMC,cAAc,CAACC;IAC1B,OAAO,CAACC,YAAYC,UAAUC;QAC5B,MAAMC,eAAeH,WAAWI,kBAAkB;QAClD,MAAMC,WAAWL,WAAWM,cAAc;QAC1C,MAAMC,WAAWd,oBAAoBM,aAAa,UAAUG,KAAK,CAAC,EAAE,KAAK,MAAMM;QAC/E,IAAIZ,YAAYS,aAAaA,SAASI,WAAW,OAAOV,UAAU;YAChE,MAAMW,aAAaL,SAASM,aAAa;YACzC,IAAID,eAAe,MAAM;gBACvBA,WAAWE,YAAY,CAACL;YAC1B,OAAO;gBACL,kEAAkE;gBAClEF,SAASQ,MAAM,CAACN;YAClB;YACAP,WAAWc,MAAM;QACnB,OAAO,IAAIlB,YAAYO,iBAAiBA,aAAaM,WAAW,OAAOV,UAAU;YAC/EI,aAAaU,MAAM,CAACN;YACpBP,WAAWc,MAAM;QACnB,OAAO;YACL,MAAMC,OAAOrB,gBAAgBK,UAAUA,aAAa,WAAWiB,OAAOd,KAAK,CAAC,EAAE,IAAIM;YAClFO,KAAKF,MAAM,CAACN;YACZP,WAAWiB,OAAO,CAACF;QACrB;QACAR,SAASM,MAAM,IAAIZ;QACnBM,SAASW,MAAM,CAAC,GAAG;QACnB,MAAMC,SAASC,KAAKC,KAAK,CAACnB,KAAK,CAAC,EAAE,CAACoB,MAAM,GAAGzB;QAC5C,IAAIsB,QAAQ;YACVZ,SAASgB,SAAS,CAACJ;QACrB;IACF;AACF,EAAC;AAED,OAAO,MAAMK,aAAa,CACxBC,UACAC,gBACAC;IAEA,MAAMC,SAAS,EAAE;IACjB,MAAM3B,WAAWwB,SAASI,WAAW;IACrC,IAAIC,QAAQ;IACZ,KAAK,MAAMC,gBAAgB9B,SAAU;QACnC,IAAIN,gBAAgBoC,eAAe;YACjC,IAAIA,aAAaC,eAAe,OAAO,GAAG;gBACxC,MAAMtB,aAAaqB,aAAapB,aAAa;gBAC7C,IAAIf,YAAYc,aAAa;oBAC3BkB,OAAOK,IAAI,CAACT,WAAWd,YAAYgB,gBAAgBC,QAAQ;oBAC3D;gBACF;YACF;YACA,MAAMR,SAAS,IAAIe,MAAM,CAACP,QAAQ9B;YAClC,MAAME,WAAW0B,SAAShB,WAAW;YACrC,MAAM0B,SACJpC,aAAa,WACT,CAAC,EAAE0B,SAASW,QAAQ,KAAKN,MAAM,EAAE,CAAC,GAClC/B,aAAa,UACX,CAAC,GAAG,EAAEgC,aAAaM,UAAU,KAAK,MAAM,IAAI,EAAE,CAAC,GAC/C;YACRT,OAAOK,IAAI,CAACd,SAASgB,SAAST,eAAeK;YAC7CD;QACF;IACF;IAEA,OAAOF,OAAOU,IAAI,CAAC;AACrB,EAAC"}

package/dist/field/features/lists/shared/slashMenuListGroup.d.ts

@@ -0,0 +1,3 @@
+import type { SlashMenuGroup, SlashMenuItem } from '../../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js';
+export declare function slashMenuListGroupWithItems(items: SlashMenuItem[]): SlashMenuGroup;
+//# sourceMappingURL=slashMenuListGroup.d.ts.map

package/dist/field/features/lists/shared/slashMenuListGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slashMenuListGroup.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/shared/slashMenuListGroup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACd,MAAM,wEAAwE,CAAA;AAE/E,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,cAAc,CAQlF"}

package/dist/field/features/lists/shared/slashMenuListGroup.js

@@ -0,0 +1,11 @@
+export function slashMenuListGroupWithItems(items) {
+    return {
+        items,
+        key: 'lists',
+        label: ({ i18n })=>{
+            return i18n.t('lexical:general:slashMenuListGroupLabel');
+        }
+    };
+}
+
+//# sourceMappingURL=slashMenuListGroup.js.map

package/dist/field/features/lists/shared/slashMenuListGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/shared/slashMenuListGroup.ts"],"sourcesContent":["import type {\n  SlashMenuGroup,\n  SlashMenuItem,\n} from '../../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\n\nexport function slashMenuListGroupWithItems(items: SlashMenuItem[]): SlashMenuGroup {\n  return {\n    items,\n    key: 'lists',\n    label: ({ i18n }) => {\n      return i18n.t('lexical:general:slashMenuListGroupLabel')\n    },\n  }\n}\n"],"names":["slashMenuListGroupWithItems","items","key","label","i18n","t"],"rangeMappings":";;;;;;;;","mappings":"AAKA,OAAO,SAASA,4BAA4BC,KAAsB;IAChE,OAAO;QACLA;QACAC,KAAK;QACLC,OAAO,CAAC,EAAEC,IAAI,EAAE;YACd,OAAOA,KAAKC,CAAC,CAAC;QAChB;IACF;AACF"}

package/dist/field/features/lists/{unorderedlist → unorderedList}/feature.client.d.ts

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

package/dist/field/features/lists/unorderedList/feature.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/unorderedList/feature.client.tsx"],"names":[],"mappings":";AAkGA,eAAO,MAAM,mCAAmC;;;EAAoD,CAAA"}

package/dist/field/features/lists/unorderedList/feature.client.js

@@ -0,0 +1,97 @@
+'use client';
+import { $isListNode, INSERT_UNORDERED_LIST_COMMAND, ListItemNode, ListNode } from '@lexical/list';
+import { $isRangeSelection } from 'lexical';
+import { UnorderedListIcon } from '../../../lexical/ui/icons/UnorderedList/index.js';
+import { createClientComponent } from '../../createClientComponent.js';
+import { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js';
+import { LexicalListPlugin } from '../plugin/index.js';
+import { slashMenuListGroupWithItems } from '../shared/slashMenuListGroup.js';
+import { UNORDERED_LIST } from './markdownTransformer.js';
+const toolbarGroups = [
+    toolbarTextDropdownGroupWithItems([
+        {
+            ChildComponent: UnorderedListIcon,
+            isActive: ({ selection })=>{
+                if (!$isRangeSelection(selection)) {
+                    return false;
+                }
+                for (const node of selection.getNodes()){
+                    if ($isListNode(node) && node.getListType() === 'bullet') {
+                        continue;
+                    }
+                    const parent = node.getParent();
+                    if ($isListNode(parent) && parent.getListType() === 'bullet') {
+                        continue;
+                    }
+                    const parentParent = parent?.getParent();
+                    // Example scenario: Node = textNode, parent = listItemNode, parentParent = listNode
+                    if ($isListNode(parentParent) && parentParent.getListType() === 'bullet') {
+                        continue;
+                    }
+                    return false;
+                }
+                return true;
+            },
+            key: 'unorderedList',
+            label: ({ i18n })=>{
+                return i18n.t('lexical:unorderedList:label');
+            },
+            onSelect: ({ editor })=>{
+                editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined);
+            },
+            order: 11
+        }
+    ])
+];
+const UnorderedListFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ()=>{
+            return {
+                clientFeatureProps: props,
+                markdownTransformers: [
+                    UNORDERED_LIST
+                ],
+                nodes: [
+                    ListNode,
+                    ListItemNode
+                ],
+                plugins: [
+                    {
+                        Component: LexicalListPlugin,
+                        position: 'normal'
+                    }
+                ],
+                slashMenu: {
+                    groups: [
+                        slashMenuListGroupWithItems([
+                            {
+                                Icon: UnorderedListIcon,
+                                key: 'unorderedList',
+                                keywords: [
+                                    'unordered list',
+                                    'ul'
+                                ],
+                                label: ({ i18n })=>{
+                                    return i18n.t('lexical:unorderedList:label');
+                                },
+                                onSelect: ({ editor })=>{
+                                    editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined);
+                                }
+                            }
+                        ])
+                    ]
+                },
+                toolbarFixed: {
+                    groups: toolbarGroups
+                },
+                toolbarInline: {
+                    groups: toolbarGroups
+                }
+            };
+        }
+    };
+};
+export const UnorderedListFeatureClientComponent = createClientComponent(UnorderedListFeatureClient);
+
+//# sourceMappingURL=feature.client.js.map

package/dist/field/features/lists/unorderedList/feature.client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/unorderedList/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { $isListNode, INSERT_UNORDERED_LIST_COMMAND, ListItemNode, ListNode } from '@lexical/list'\nimport { $isRangeSelection } from 'lexical'\n\nimport type { ToolbarGroup } from '../../toolbars/types.js'\nimport type { FeatureProviderProviderClient } from '../../types.js'\n\nimport { UnorderedListIcon } from '../../../lexical/ui/icons/UnorderedList/index.js'\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js'\nimport { LexicalListPlugin } from '../plugin/index.js'\nimport { slashMenuListGroupWithItems } from '../shared/slashMenuListGroup.js'\nimport { UNORDERED_LIST } from './markdownTransformer.js'\n\nconst toolbarGroups: ToolbarGroup[] = [\n  toolbarTextDropdownGroupWithItems([\n    {\n      ChildComponent: UnorderedListIcon,\n      isActive: ({ selection }) => {\n        if (!$isRangeSelection(selection)) {\n          return false\n        }\n        for (const node of selection.getNodes()) {\n          if ($isListNode(node) && node.getListType() === 'bullet') {\n            continue\n          }\n\n          const parent = node.getParent()\n\n          if ($isListNode(parent) && parent.getListType() === 'bullet') {\n            continue\n          }\n\n          const parentParent = parent?.getParent()\n          // Example scenario: Node = textNode, parent = listItemNode, parentParent = listNode\n          if ($isListNode(parentParent) && parentParent.getListType() === 'bullet') {\n            continue\n          }\n\n          return false\n        }\n        return true\n      },\n      key: 'unorderedList',\n      label: ({ i18n }) => {\n        return i18n.t('lexical:unorderedList:label')\n      },\n      onSelect: ({ editor }) => {\n        editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined)\n      },\n      order: 11,\n    },\n  ]),\n]\n\nconst UnorderedListFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n  return {\n    clientFeatureProps: props,\n    feature: () => {\n      return {\n        clientFeatureProps: props,\n        markdownTransformers: [UNORDERED_LIST],\n        nodes: [ListNode, ListItemNode],\n        plugins: [\n          {\n            Component: LexicalListPlugin,\n            position: 'normal',\n          },\n        ],\n        slashMenu: {\n          groups: [\n            slashMenuListGroupWithItems([\n              {\n                Icon: UnorderedListIcon,\n                key: 'unorderedList',\n                keywords: ['unordered list', 'ul'],\n                label: ({ i18n }) => {\n                  return i18n.t('lexical:unorderedList:label')\n                },\n                onSelect: ({ editor }) => {\n                  editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined)\n                },\n              },\n            ]),\n          ],\n        },\n        toolbarFixed: {\n          groups: toolbarGroups,\n        },\n        toolbarInline: {\n          groups: toolbarGroups,\n        },\n      }\n    },\n  }\n}\n\nexport const UnorderedListFeatureClientComponent = createClientComponent(UnorderedListFeatureClient)\n"],"names":["$isListNode","INSERT_UNORDERED_LIST_COMMAND","ListItemNode","ListNode","$isRangeSelection","UnorderedListIcon","createClientComponent","toolbarTextDropdownGroupWithItems","LexicalListPlugin","slashMenuListGroupWithItems","UNORDERED_LIST","toolbarGroups","ChildComponent","isActive","selection","node","getNodes","getListType","parent","getParent","parentParent","key","label","i18n","t","onSelect","editor","dispatchCommand","undefined","order","UnorderedListFeatureClient","props","clientFeatureProps","feature","markdownTransformers","nodes","plugins","Component","position","slashMenu","groups","Icon","keywords","toolbarFixed","toolbarInline","UnorderedListFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAEA,SAASA,WAAW,EAAEC,6BAA6B,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAClG,SAASC,iBAAiB,QAAQ,UAAS;AAK3C,SAASC,iBAAiB,QAAQ,mDAAkD;AACpF,SAASC,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,iCAAiC,QAAQ,4CAA2C;AAC7F,SAASC,iBAAiB,QAAQ,qBAAoB;AACtD,SAASC,2BAA2B,QAAQ,kCAAiC;AAC7E,SAASC,cAAc,QAAQ,2BAA0B;AAEzD,MAAMC,gBAAgC;IACpCJ,kCAAkC;QAChC;YACEK,gBAAgBP;YAChBQ,UAAU,CAAC,EAAEC,SAAS,EAAE;gBACtB,IAAI,CAACV,kBAAkBU,YAAY;oBACjC,OAAO;gBACT;gBACA,KAAK,MAAMC,QAAQD,UAAUE,QAAQ,GAAI;oBACvC,IAAIhB,YAAYe,SAASA,KAAKE,WAAW,OAAO,UAAU;wBACxD;oBACF;oBAEA,MAAMC,SAASH,KAAKI,SAAS;oBAE7B,IAAInB,YAAYkB,WAAWA,OAAOD,WAAW,OAAO,UAAU;wBAC5D;oBACF;oBAEA,MAAMG,eAAeF,QAAQC;oBAC7B,oFAAoF;oBACpF,IAAInB,YAAYoB,iBAAiBA,aAAaH,WAAW,OAAO,UAAU;wBACxE;oBACF;oBAEA,OAAO;gBACT;gBACA,OAAO;YACT;YACAI,KAAK;YACLC,OAAO,CAAC,EAAEC,IAAI,EAAE;gBACd,OAAOA,KAAKC,CAAC,CAAC;YAChB;YACAC,UAAU,CAAC,EAAEC,MAAM,EAAE;gBACnBA,OAAOC,eAAe,CAAC1B,+BAA+B2B;YACxD;YACAC,OAAO;QACT;KACD;CACF;AAED,MAAMC,6BAAuE,CAACC;IAC5E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS;YACP,OAAO;gBACLD,oBAAoBD;gBACpBG,sBAAsB;oBAACxB;iBAAe;gBACtCyB,OAAO;oBAAChC;oBAAUD;iBAAa;gBAC/BkC,SAAS;oBACP;wBACEC,WAAW7B;wBACX8B,UAAU;oBACZ;iBACD;gBACDC,WAAW;oBACTC,QAAQ;wBACN/B,4BAA4B;4BAC1B;gCACEgC,MAAMpC;gCACNgB,KAAK;gCACLqB,UAAU;oCAAC;oCAAkB;iCAAK;gCAClCpB,OAAO,CAAC,EAAEC,IAAI,EAAE;oCACd,OAAOA,KAAKC,CAAC,CAAC;gCAChB;gCACAC,UAAU,CAAC,EAAEC,MAAM,EAAE;oCACnBA,OAAOC,eAAe,CAAC1B,+BAA+B2B;gCACxD;4BACF;yBACD;qBACF;gBACH;gBACAe,cAAc;oBACZH,QAAQ7B;gBACV;gBACAiC,eAAe;oBACbJ,QAAQ7B;gBACV;YACF;QACF;IACF;AACF;AAEA,OAAO,MAAMkC,sCAAsCvC,sBAAsBwB,4BAA2B"}

package/dist/field/features/lists/unorderedList/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/unorderedList/feature.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAA;AAQnE,eAAO,MAAM,oBAAoB,EAAE,6BAA6B,CAAC,SAAS,EAAE,SAAS,CA6BpF,CAAA"}

package/dist/field/features/lists/{unorderedlist → unorderedList}/feature.server.js

@@ -1,34 +1,36 @@
-import lexicalListImport from '@lexical/list';
-const { ListItemNode, ListNode } = lexicalListImport;
+import { ListItemNode, ListNode } from '@lexical/list';
+import { createNode } from '../../typeUtilities.js';
 import { ListHTMLConverter, ListItemHTMLConverter } from '../htmlConverter.js';
 import { UnorderedListFeatureClientComponent } from './feature.client.js';
+import { i18n } from './i18n.js';
 import { UNORDERED_LIST } from './markdownTransformer.js';
 export const UnorderedListFeature = (props)=>{
     return {
         feature: ()=>{
             return {
                 ClientComponent: UnorderedListFeatureClientComponent,
+                i18n,
                 markdownTransformers: [
                     UNORDERED_LIST
                 ],
                 nodes: [
-                    {
+                    createNode({
                         converters: {
                             html: ListHTMLConverter
                         },
                         node: ListNode
-                    },
-                    {
+                    }),
+                    createNode({
                         converters: {
                             html: ListItemHTMLConverter
                         },
                         node: ListItemNode
-                    }
+                    })
                 ],
                 serverFeatureProps: props
             };
         },
-        key: 'unorderedlist',
+        key: 'unorderedList',
         serverFeatureProps: props
     };
 };

package/dist/field/features/lists/unorderedList/feature.server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/unorderedList/feature.server.ts"],"sourcesContent":["import { ListItemNode, ListNode } from '@lexical/list'\n\nimport type { FeatureProviderProviderServer } from '../../types.js'\n\nimport { createNode } from '../../typeUtilities.js'\nimport { ListHTMLConverter, ListItemHTMLConverter } from '../htmlConverter.js'\nimport { UnorderedListFeatureClientComponent } from './feature.client.js'\nimport { i18n } from './i18n.js'\nimport { UNORDERED_LIST } from './markdownTransformer.js'\n\nexport const UnorderedListFeature: FeatureProviderProviderServer<undefined, undefined> = (\n  props,\n) => {\n  return {\n    feature: () => {\n      return {\n        ClientComponent: UnorderedListFeatureClientComponent,\n        i18n,\n        markdownTransformers: [UNORDERED_LIST],\n        nodes: [\n          createNode({\n            converters: {\n              html: ListHTMLConverter,\n            },\n            node: ListNode,\n          }),\n          createNode({\n            converters: {\n              html: ListItemHTMLConverter,\n            },\n            node: ListItemNode,\n          }),\n        ],\n        serverFeatureProps: props,\n      }\n    },\n    key: 'unorderedList',\n    serverFeatureProps: props,\n  }\n}\n"],"names":["ListItemNode","ListNode","createNode","ListHTMLConverter","ListItemHTMLConverter","UnorderedListFeatureClientComponent","i18n","UNORDERED_LIST","UnorderedListFeature","props","feature","ClientComponent","markdownTransformers","nodes","converters","html","node","serverFeatureProps","key"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAItD,SAASC,UAAU,QAAQ,yBAAwB;AACnD,SAASC,iBAAiB,EAAEC,qBAAqB,QAAQ,sBAAqB;AAC9E,SAASC,mCAAmC,QAAQ,sBAAqB;AACzE,SAASC,IAAI,QAAQ,YAAW;AAChC,SAASC,cAAc,QAAQ,2BAA0B;AAEzD,OAAO,MAAMC,uBAA4E,CACvFC;IAEA,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,iBAAiBN;gBACjBC;gBACAM,sBAAsB;oBAACL;iBAAe;gBACtCM,OAAO;oBACLX,WAAW;wBACTY,YAAY;4BACVC,MAAMZ;wBACR;wBACAa,MAAMf;oBACR;oBACAC,WAAW;wBACTY,YAAY;4BACVC,MAAMX;wBACR;wBACAY,MAAMhB;oBACR;iBACD;gBACDiB,oBAAoBR;YACtB;QACF;QACAS,KAAK;QACLD,oBAAoBR;IACtB;AACF,EAAC"}

package/dist/field/features/lists/unorderedList/i18n.d.ts

@@ -0,0 +1,3 @@
+import type { GenericLanguages } from '@payloadcms/translations';
+export declare const i18n: Partial<GenericLanguages>;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/field/features/lists/unorderedList/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/unorderedList/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEhE,eAAO,MAAM,IAAI,EAAE,OAAO,CAAC,gBAAgB,CAiG1C,CAAA"}

package/dist/field/features/lists/unorderedList/i18n.js

@@ -0,0 +1,100 @@
+export const i18n = {
+    ar: {
+        label: 'قائمة غير مرتبة'
+    },
+    az: {
+        label: 'Sırasız Siyahı'
+    },
+    bg: {
+        label: 'Неподреден списък'
+    },
+    cs: {
+        label: 'Neuspořádaný seznam'
+    },
+    de: {
+        label: 'Ungeordnete Liste'
+    },
+    en: {
+        label: 'Unordered List'
+    },
+    es: {
+        label: 'Lista desordenada'
+    },
+    fa: {
+        label: 'لیست بدون ترتیب'
+    },
+    fr: {
+        label: 'Liste non ordonnée'
+    },
+    he: {
+        label: 'רשימה לא מסודרת'
+    },
+    hr: {
+        label: 'Neuređeni popis'
+    },
+    hu: {
+        label: 'Rendezetlen lista'
+    },
+    it: {
+        label: 'Elenco non ordinato'
+    },
+    ja: {
+        label: '順不同リスト'
+    },
+    ko: {
+        label: '비정렬 목록'
+    },
+    my: {
+        label: 'Senarai Tidak Tertib'
+    },
+    nb: {
+        label: 'Usortert liste'
+    },
+    nl: {
+        label: 'Ongeordende lijst'
+    },
+    pl: {
+        label: 'Nieuporządkowana lista'
+    },
+    pt: {
+        label: 'Lista Não Ordenada'
+    },
+    ro: {
+        label: 'Listă neordonată'
+    },
+    rs: {
+        label: 'Neporedani spisak'
+    },
+    'rs-latin': {
+        label: 'Neuređena Lista'
+    },
+    ru: {
+        label: 'Несортированный список'
+    },
+    sk: {
+        label: 'Neusporiadaný zoznam'
+    },
+    sv: {
+        label: 'Oordnad lista'
+    },
+    th: {
+        label: 'รายการที่ไม่ได้เรียงลำดับ'
+    },
+    tr: {
+        label: 'Sırasız Liste'
+    },
+    uk: {
+        label: 'Невпорядкований список'
+    },
+    vi: {
+        label: 'Danh sách không theo thứ tự'
+    },
+    zh: {
+        label: '无序列表'
+    },
+    'zh-TW': {
+        label: '無順序列表'
+    }
+};
+
+//# sourceMappingURL=i18n.js.map

package/dist/field/features/lists/unorderedList/i18n.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/unorderedList/i18n.ts"],"sourcesContent":["import type { GenericLanguages } from '@payloadcms/translations'\n\nexport const i18n: Partial<GenericLanguages> = {\n  ar: {\n    label: 'قائمة غير مرتبة',\n  },\n  az: {\n    label: 'Sırasız Siyahı',\n  },\n  bg: {\n    label: 'Неподреден списък',\n  },\n  cs: {\n    label: 'Neuspořádaný seznam',\n  },\n  de: {\n    label: 'Ungeordnete Liste',\n  },\n  en: {\n    label: 'Unordered List',\n  },\n  es: {\n    label: 'Lista desordenada',\n  },\n  fa: {\n    label: 'لیست بدون ترتیب',\n  },\n  fr: {\n    label: 'Liste non ordonnée',\n  },\n  he: {\n    label: 'רשימה לא מסודרת',\n  },\n  hr: {\n    label: 'Neuređeni popis',\n  },\n  hu: {\n    label: 'Rendezetlen lista',\n  },\n  it: {\n    label: 'Elenco non ordinato',\n  },\n  ja: {\n    label: '順不同リスト',\n  },\n  ko: {\n    label: '비정렬 목록',\n  },\n  my: {\n    label: 'Senarai Tidak Tertib',\n  },\n  nb: {\n    label: 'Usortert liste',\n  },\n  nl: {\n    label: 'Ongeordende lijst',\n  },\n  pl: {\n    label: 'Nieuporządkowana lista',\n  },\n  pt: {\n    label: 'Lista Não Ordenada',\n  },\n  ro: {\n    label: 'Listă neordonată',\n  },\n  rs: {\n    label: 'Neporedani spisak',\n  },\n  'rs-latin': {\n    label: 'Neuređena Lista',\n  },\n  ru: {\n    label: 'Несортированный список',\n  },\n  sk: {\n    label: 'Neusporiadaný zoznam',\n  },\n  sv: {\n    label: 'Oordnad lista',\n  },\n  th: {\n    label: 'รายการที่ไม่ได้เรียงลำดับ',\n  },\n  tr: {\n    label: 'Sırasız Liste',\n  },\n  uk: {\n    label: 'Невпорядкований список',\n  },\n  vi: {\n    label: 'Danh sách không theo thứ tự',\n  },\n  zh: {\n    label: '无序列表',\n  },\n  'zh-TW': {\n    label: '無順序列表',\n  },\n}\n"],"names":["i18n","ar","label","az","bg","cs","de","en","es","fa","fr","he","hr","hu","it","ja","ko","my","nb","nl","pl","pt","ro","rs","ru","sk","sv","th","tr","uk","vi","zh"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA,OAAkC;IAC7CC,IAAI;QACFC,OAAO;IACT;IACAC,IAAI;QACFD,OAAO;IACT;IACAE,IAAI;QACFF,OAAO;IACT;IACAG,IAAI;QACFH,OAAO;IACT;IACAI,IAAI;QACFJ,OAAO;IACT;IACAK,IAAI;QACFL,OAAO;IACT;IACAM,IAAI;QACFN,OAAO;IACT;IACAO,IAAI;QACFP,OAAO;IACT;IACAQ,IAAI;QACFR,OAAO;IACT;IACAS,IAAI;QACFT,OAAO;IACT;IACAU,IAAI;QACFV,OAAO;IACT;IACAW,IAAI;QACFX,OAAO;IACT;IACAY,IAAI;QACFZ,OAAO;IACT;IACAa,IAAI;QACFb,OAAO;IACT;IACAc,IAAI;QACFd,OAAO;IACT;IACAe,IAAI;QACFf,OAAO;IACT;IACAgB,IAAI;QACFhB,OAAO;IACT;IACAiB,IAAI;QACFjB,OAAO;IACT;IACAkB,IAAI;QACFlB,OAAO;IACT;IACAmB,IAAI;QACFnB,OAAO;IACT;IACAoB,IAAI;QACFpB,OAAO;IACT;IACAqB,IAAI;QACFrB,OAAO;IACT;IACA,YAAY;QACVA,OAAO;IACT;IACAsB,IAAI;QACFtB,OAAO;IACT;IACAuB,IAAI;QACFvB,OAAO;IACT;IACAwB,IAAI;QACFxB,OAAO;IACT;IACAyB,IAAI;QACFzB,OAAO;IACT;IACA0B,IAAI;QACF1B,OAAO;IACT;IACA2B,IAAI;QACF3B,OAAO;IACT;IACA4B,IAAI;QACF5B,OAAO;IACT;IACA6B,IAAI;QACF7B,OAAO;IACT;IACA,SAAS;QACPA,OAAO;IACT;AACF,EAAC"}

package/dist/field/features/lists/unorderedList/markdownTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/lists/unorderedList/markdownTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAM3D,eAAO,MAAM,cAAc,EAAE,kBAQ5B,CAAA"}

package/dist/field/features/lists/{unorderedlist → unorderedList}/markdownTransformer.js

@@ -1,6 +1,5 @@
-import lexicalListImport from '@lexical/list';
-const { $isListNode, ListItemNode, ListNode } = lexicalListImport;
-import { listExport, listReplace } from '../common/markdown.js';
+import { $isListNode, ListItemNode, ListNode } from '@lexical/list';
+import { listExport, listReplace } from '../shared/markdown.js';
 export const UNORDERED_LIST = {
     type: 'element',
     dependencies: [

package/dist/field/features/lists/unorderedList/markdownTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/field/features/lists/unorderedList/markdownTransformer.ts"],"sourcesContent":["import type { ElementTransformer } from '@lexical/markdown'\n\nimport { $isListNode, ListItemNode, ListNode } from '@lexical/list'\n\nimport { listExport, listReplace } from '../shared/markdown.js'\n\nexport const UNORDERED_LIST: ElementTransformer = {\n  type: 'element',\n  dependencies: [ListNode, ListItemNode],\n  export: (node, exportChildren) => {\n    return $isListNode(node) ? listExport(node, exportChildren, 0) : null\n  },\n  regExp: /^(\\s*)[-*+]\\s/,\n  replace: listReplace('bullet'),\n}\n"],"names":["$isListNode","ListItemNode","ListNode","listExport","listReplace","UNORDERED_LIST","type","dependencies","export","node","exportChildren","regExp","replace"],"rangeMappings":";;;;;;;;;;;;;","mappings":"AAEA,SAASA,WAAW,EAAEC,YAAY,EAAEC,QAAQ,QAAQ,gBAAe;AAEnE,SAASC,UAAU,EAAEC,WAAW,QAAQ,wBAAuB;AAE/D,OAAO,MAAMC,iBAAqC;IAChDC,MAAM;IACNC,cAAc;QAACL;QAAUD;KAAa;IACtCO,QAAQ,CAACC,MAAMC;QACb,OAAOV,YAAYS,QAAQN,WAAWM,MAAMC,gBAAgB,KAAK;IACnE;IACAC,QAAQ;IACRC,SAASR,YAAY;AACvB,EAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAEhE,eAAO,MAAM,gBAAgB,EAAE,0BAoB9B,CAAA"}
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAEhE,eAAO,MAAM,gBAAgB,EAAE,0BAkB9B,CAAA"}

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

@@ -11,10 +11,8 @@
             fields,
             format: lexicalPluginNode?.format || '',
             relationTo: lexicalPluginNode?.rawImagePayload?.relationTo,
-            value: {
-                id: lexicalPluginNode?.rawImagePayload?.value?.id || ''
-            },
-            version: 1
+            value: lexicalPluginNode?.rawImagePayload?.value?.id || '',
+            version: 2
         };
     },
     nodeTypes: [

package/dist/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedUploadNode } from '../../../../../upload/nodes/UploadNode.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nexport const _UploadConverter: LexicalPluginNodeConverter = {\n  converter({ lexicalPluginNode }) {\n    let fields = {}\n    if ((lexicalPluginNode as any)?.caption?.editorState) {\n      fields = {\n        caption: (lexicalPluginNode as any)?.caption,\n      }\n    }\n    return {\n      type: 'upload',\n      fields,\n      format: (lexicalPluginNode as any)?.format || '',\n      relationTo: (lexicalPluginNode as any)?.rawImagePayload?.relationTo,\n      value: {\n        id: (lexicalPluginNode as any)?.rawImagePayload?.value?.id || '',\n      },\n      version: 1,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"names":["_UploadConverter","converter","lexicalPluginNode","fields","caption","editorState","type","format","relationTo","rawImagePayload","value","id","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,qDAAqD,GAKrD,OAAO,MAAMA,mBAA+C;IAC1DC,WAAU,EAAEC,iBAAiB,EAAE;QAC7B,IAAIC,SAAS,CAAC;QACd,IAAKD,mBAA2BE,SAASC,aAAa;YACpDF,SAAS;gBACPC,SAAUF,mBAA2BE;YACvC;QACF;QACA,OAAO;YACLE,MAAM;YACNH;YACAI,QAAQ,AAACL,mBAA2BK,UAAU;YAC9CC,YAAaN,mBAA2BO,iBAAiBD;YACzDE,OAAO;gBACLC,IAAI,AAACT,mBAA2BO,iBAAiBC,OAAOC,MAAM;YAChE;YACAC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedUploadNode } from '../../../../../upload/nodes/UploadNode.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nexport const _UploadConverter: LexicalPluginNodeConverter = {\n  converter({ lexicalPluginNode }) {\n    let fields = {}\n    if ((lexicalPluginNode as any)?.caption?.editorState) {\n      fields = {\n        caption: (lexicalPluginNode as any)?.caption,\n      }\n    }\n    return {\n      type: 'upload',\n      fields,\n      format: (lexicalPluginNode as any)?.format || '',\n      relationTo: (lexicalPluginNode as any)?.rawImagePayload?.relationTo,\n      value: (lexicalPluginNode as any)?.rawImagePayload?.value?.id || '',\n      version: 2,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"names":["_UploadConverter","converter","lexicalPluginNode","fields","caption","editorState","type","format","relationTo","rawImagePayload","value","id","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,qDAAqD,GAKrD,OAAO,MAAMA,mBAA+C;IAC1DC,WAAU,EAAEC,iBAAiB,EAAE;QAC7B,IAAIC,SAAS,CAAC;QACd,IAAKD,mBAA2BE,SAASC,aAAa;YACpDF,SAAS;gBACPC,SAAUF,mBAA2BE;YACvC;QACF;QACA,OAAO;YACLE,MAAM;YACNH;YACAI,QAAQ,AAACL,mBAA2BK,UAAU;YAC9CC,YAAaN,mBAA2BO,iBAAiBD;YACzDE,OAAO,AAACR,mBAA2BO,iBAAiBC,OAAOC,MAAM;YACjEC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}

package/dist/field/features/migrations/lexicalPluginToLexical/feature.client.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"names":[],"mappings":";AAqCA,eAAO,MAAM,4CAA4C,0BAExD,CAAA"}
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"names":[],"mappings":";AAqCA,eAAO,MAAM,4CAA4C;;;EAExD,CAAA"}

package/dist/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.js

@@ -1,8 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import './index.scss';
 export const UnknownConvertedNodeComponent = (props)=>{
     const { data } = props;
-    return /*#__PURE__*/ React.createElement("div", null, "Unknown converted payload-plugin-lexical node: ", /*#__PURE__*/ React.createElement("strong", null, data?.nodeType));
+    return /*#__PURE__*/ _jsxs("div", {
+        children: [
+            "Unknown converted payload-plugin-lexical node: ",
+            /*#__PURE__*/ _jsx("strong", {
+                children: data?.nodeType
+            })
+        ]
+    });
 };
 
 //# sourceMappingURL=Component.js.map

package/dist/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["import 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 payload-plugin-lexical node: <strong>{data?.nodeType}</strong>\n    </div>\n  )\n}\n"],"names":["React","UnknownConvertedNodeComponent","props","data","div","strong","nodeType"],"rangeMappings":";;;;;","mappings":"AAAA,OAAOA,WAAW,QAAO;AAIzB,OAAO,eAAc;AAMrB,OAAO,MAAMC,gCAAiD,CAACC;IAC7D,MAAM,EAAEC,IAAI,EAAE,GAAGD;IAEjB,qBACE,oBAACE,aAAI,iEAC4C,oBAACC,gBAAQF,MAAMG;AAGpE,EAAC"}
+{"version":3,"sources":["../../../../../../../src/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["import 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 payload-plugin-lexical node: <strong>{data?.nodeType}</strong>\n    </div>\n  )\n}\n"],"names":["React","UnknownConvertedNodeComponent","props","data","div","strong","nodeType"],"rangeMappings":";;;;;;;;;;;;;","mappings":";AAAA,OAAOA,WAAW,QAAO;AAIzB,OAAO,eAAc;AAMrB,OAAO,MAAMC,gCAAiD,CAACC;IAC7D,MAAM,EAAEC,IAAI,EAAE,GAAGD;IAEjB,qBACE,MAACE;;YAAI;0BAC4C,KAACC;0BAAQF,MAAMG;;;;AAGpE,EAAC"}

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

@@ -1,8 +1,7 @@
-/// <reference types="react" resolution-mode="require"/>
 import type { SerializedLexicalNode, Spread } from 'lexical';
-import lexicalImport from 'lexical';
-declare const DecoratorNode: typeof lexicalImport.DecoratorNode;
 import type { EditorConfig, LexicalNode, NodeKey } from 'lexical';
+import type { JSX } from 'react';
+import { DecoratorNode } from 'lexical';
 export type UnknownConvertedNodeData = {
     nodeData: unknown;
     nodeType: string;
@@ -32,5 +31,4 @@ export declare function $createUnknownConvertedNode({ data, }: {
     data: UnknownConvertedNodeData;
 }): UnknownConvertedNode;
 export declare function $isUnknownConvertedNode(node: LexicalNode | null | undefined): node is UnknownConvertedNode;
-export {};
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACjE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAGhC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAGvC,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,7 +1,6 @@
-import lexicalUtilsImport from '@lexical/utils';
-const { addClassNamesToElement } = lexicalUtilsImport;
-import lexicalImport from 'lexical';
-const { DecoratorNode } = lexicalImport;
+import { jsx as _jsx } from "react/jsx-runtime";
+import { addClassNamesToElement } from '@lexical/utils';
+import { DecoratorNode } from 'lexical';
 import * as React from 'react';
 const Component = /*#__PURE__*/ React.lazy(()=>import('./Component.js').then((module)=>({
             default: module.UnknownConvertedNodeComponent
@@ -39,7 +38,7 @@ const Component = /*#__PURE__*/ React.lazy(()=>import('./Component.js').then((mo
         return element;
     }
     decorate() {
-        return /*#__PURE__*/ React.createElement(Component, {
+        return /*#__PURE__*/ _jsx(Component, {
             data: this.__data
         });
     }

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"sources":["../../../../../../../src/field/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { SerializedLexicalNode, Spread } from 'lexical'\nimport type { EditorConfig, LexicalNode, NodeKey } from 'lexical'\nimport type { JSX } from 'react'\n\nimport { addClassNamesToElement } from '@lexical/utils'\nimport { 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 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":["addClassNamesToElement","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":";AAIA,SAASA,sBAAsB,QAAQ,iBAAgB;AACvD,SAASC,aAAa,QAAQ,UAAS;AACvC,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;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;QACvC3B,uBAAuByB,SAAS;QAChC,OAAOA;IACT;IAEAG,WAA+B;QAC7B,qBAAO,KAACzB;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/slateToLexical/converter/converters/blockquote/client.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" resolution-mode="require"/>
-export declare const BlockQuoteConverterClient: import("react").FC<{
+export declare const BlockquoteConverterClient: import("react").FC<{
     componentKey: string;
     featureKey: string;
 }>;

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

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

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

@@ -1 +1 @@
-{"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"}
+{"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/index.js

@@ -1,7 +1,7 @@
-import { BlockQuoteConverterClient } from './client.js';
+import { BlockquoteConverterClient } from './client.js';
 import { _SlateBlockquoteConverter } from './converter.js';
 export const SlateBlockquoteConverter = {
-    ClientComponent: BlockQuoteConverterClient,
+    ClientComponent: BlockquoteConverterClient,
     converter: _SlateBlockquoteConverter
 };
 

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

@@ -1 +1 @@
-{"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"}
+{"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/relationship/converter.d.ts.map

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

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

@@ -4,10 +4,8 @@ export const _SlateRelationshipConverter = {
             type: 'relationship',
             format: '',
             relationTo: slateNode.relationTo,
-            value: {
-                id: slateNode?.value?.id || ''
-            },
-            version: 1
+            value: slateNode?.value?.id || '',
+            version: 2
         };
     },
     nodeTypes: [

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"sourcesContent":["import type { SerializedRelationshipNode } from '../../../../../relationship/nodes/RelationshipNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const _SlateRelationshipConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'relationship',\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: {\n        id: slateNode?.value?.id || '',\n      },\n      version: 1,\n    } as const as SerializedRelationshipNode\n  },\n  nodeTypes: ['relationship'],\n}\n"],"names":["_SlateRelationshipConverter","converter","slateNode","type","format","relationTo","value","id","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":"AAGA,OAAO,MAAMA,8BAAkD;IAC7DC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;YACRC,YAAYH,UAAUG,UAAU;YAChCC,OAAO;gBACLC,IAAIL,WAAWI,OAAOC,MAAM;YAC9B;YACAC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAe;AAC7B,EAAC"}
+{"version":3,"sources":["../../../../../../../../src/field/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"sourcesContent":["import type { SerializedRelationshipNode } from '../../../../../relationship/nodes/RelationshipNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const _SlateRelationshipConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'relationship',\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode?.value?.id || '',\n      version: 2,\n    } as const as SerializedRelationshipNode\n  },\n  nodeTypes: ['relationship'],\n}\n"],"names":["_SlateRelationshipConverter","converter","slateNode","type","format","relationTo","value","id","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;","mappings":"AAGA,OAAO,MAAMA,8BAAkD;IAC7DC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;YACRC,YAAYH,UAAUG,UAAU;YAChCC,OAAOJ,WAAWI,OAAOC,MAAM;YAC/BC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAe;AAC7B,EAAC"}

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

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

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

@@ -7,10 +7,8 @@ export const _SlateUploadConverter = {
             },
             format: '',
             relationTo: slateNode.relationTo,
-            value: {
-                id: slateNode.value?.id || ''
-            },
-            version: 1
+            value: slateNode.value?.id || '',
+            version: 2
         };
     },
     nodeTypes: [