@payloadcms/richtext-lexical 3.84.0 → 4.0.0-internal.38b7f1d

package/dist/features/converters/lexicalToHtml_deprecated/converter/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["createLocalReq","hasText","convertLexicalToHTML","converters","currentDepth","data","depth","draft","overrideAccess","payload","req","showHiddenFields","undefined","config","defaultDepth","convertLexicalNodesToHTML","lexicalNodes","root","children","parent","unknownConverter","find","converter","nodeTypes","includes","htmlArray","Promise","all","map","node","i","converterForNode","type","childIndex","error","console","join"],"sources":["../../../../../src/features/converters/lexicalToHtml_deprecated/converter/index.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\nimport type { Payload, PayloadRequest } from 'payload'\n\nimport { createLocalReq } from 'payload'\n\nimport type { HTMLConverter, SerializedLexicalNodeWithParent } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\n\n/**\n * @deprecated - will be removed in 4.0\n */\nexport type ConvertLexicalToHTMLArgs = {\n  converters: HTMLConverter[]\n  currentDepth?: number\n  data: SerializedEditorState\n  depth?: number\n  draft?: boolean // default false\n  overrideAccess?: boolean // default false\n  showHiddenFields?: boolean // default false\n} & (\n  | {\n      /**\n       * This payload property will only be used if req is undefined.\n       */\n      payload?: never\n      /**\n       * When the converter is called, req CAN be passed in depending on where it's run.\n       * If this is undefined and config is passed through, lexical will create a new req object for you. If this is null or\n       * config is undefined, lexical will not create a new req object for you and local API / server-side-only\n       * functionality will be disabled.\n       */\n      req: PayloadRequest\n    }\n  | {\n      /**\n       * This payload property will only be used if req is undefined.\n       */\n      payload?: Payload\n      /**\n       * When the converter is called, req CAN be passed in depending on where it's run.\n       * If this is undefined and config is passed through, lexical will create a new req object for you. If this is null or\n       * config is undefined, lexical will not create a new req object for you and local API / server-side-only\n       * functionality will be disabled.\n       */\n      req?: null | undefined\n    }\n)\n\n/**\n * @deprecated - will be removed in 4.0. Use the function exported from `@payloadcms/richtext-lexical/html` instead.\n * @example\n * ```ts\n * // old (deprecated)\n * import { convertLexicalToHTML } from '@payloadcms/richtext-lexical'\n * // new (recommended)\n * import { convertLexicalToHTML } from '@payloadcms/richtext-lexical/html'\n * ```\n * For more details, you can refer to https://payloadcms.com/docs/rich-text/converting-html to see all the\n * ways to convert lexical to HTML.\n */\nexport async function convertLexicalToHTML({\n  converters,\n  currentDepth,\n  data,\n  depth,\n  draft,\n  overrideAccess,\n  payload,\n  req,\n  showHiddenFields,\n}: ConvertLexicalToHTMLArgs): Promise<string> {\n  if (hasText(data)) {\n    if (req === undefined && payload) {\n      req = await createLocalReq({}, payload)\n    }\n\n    if (!currentDepth) {\n      currentDepth = 0\n    }\n\n    if (!depth) {\n      depth = req?.payload?.config?.defaultDepth\n    }\n\n    return await convertLexicalNodesToHTML({\n      converters,\n      currentDepth,\n      depth: depth!,\n      draft: draft === undefined ? false : draft,\n      lexicalNodes: data?.root?.children,\n      overrideAccess: overrideAccess === undefined ? false : overrideAccess,\n      parent: data?.root,\n      req: req!,\n      showHiddenFields: showHiddenFields === undefined ? false : showHiddenFields,\n    })\n  }\n  return ''\n}\n\n/**\n * @deprecated - will be removed in 4.0\n */\nexport async function convertLexicalNodesToHTML({\n  converters,\n  currentDepth,\n  depth,\n  draft,\n  lexicalNodes,\n  overrideAccess,\n  parent,\n  req,\n  showHiddenFields,\n}: {\n  converters: HTMLConverter[]\n  currentDepth: number\n  depth: number\n  draft: boolean\n  lexicalNodes: SerializedLexicalNode[]\n  overrideAccess: boolean\n  parent: SerializedLexicalNodeWithParent\n  /**\n   * When the converter is called, req CAN be passed in depending on where it's run.\n   */\n  req: null | PayloadRequest\n  showHiddenFields: boolean\n}): Promise<string> {\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n\n  const htmlArray = await Promise.all(\n    lexicalNodes.map(async (node, i) => {\n      const converterForNode = converters.find((converter) =>\n        converter.nodeTypes.includes(node.type),\n      )\n      try {\n        if (!converterForNode) {\n          if (unknownConverter) {\n            return await unknownConverter.converter({\n              childIndex: i,\n              converters,\n              currentDepth,\n              depth,\n              draft,\n              node,\n              overrideAccess,\n              parent,\n              req,\n              showHiddenFields,\n            })\n          }\n          return '<span>unknown node</span>'\n        }\n        return await converterForNode.converter({\n          childIndex: i,\n          converters,\n          currentDepth,\n          depth,\n          draft,\n          node,\n          overrideAccess,\n          parent,\n          req,\n          showHiddenFields,\n        })\n      } catch (error) {\n        console.error('Error converting lexical node to HTML:', error, 'node:', node)\n        return ''\n      }\n    }),\n  )\n\n  return htmlArray.join('') || ''\n}\n"],"mappings":"AAGA,SAASA,cAAc,QAAQ;AAI/B,SAASC,OAAO,QAAQ;AA0CxB;;;;;;;;;;;;AAYA,OAAO,eAAeC,qBAAqB;EACzCC,UAAU;EACVC,YAAY;EACZC,IAAI;EACJC,KAAK;EACLC,KAAK;EACLC,cAAc;EACdC,OAAO;EACPC,GAAG;EACHC;AAAgB,CACS;EACzB,IAAIV,OAAA,CAAQI,IAAA,GAAO;IACjB,IAAIK,GAAA,KAAQE,SAAA,IAAaH,OAAA,EAAS;MAChCC,GAAA,GAAM,MAAMV,cAAA,CAAe,CAAC,GAAGS,OAAA;IACjC;IAEA,IAAI,CAACL,YAAA,EAAc;MACjBA,YAAA,GAAe;IACjB;IAEA,IAAI,CAACE,KAAA,EAAO;MACVA,KAAA,GAAQI,GAAA,EAAKD,OAAA,EAASI,MAAA,EAAQC,YAAA;IAChC;IAEA,OAAO,MAAMC,yBAAA,CAA0B;MACrCZ,UAAA;MACAC,YAAA;MACAE,KAAA,EAAOA,KAAA;MACPC,KAAA,EAAOA,KAAA,KAAUK,SAAA,GAAY,QAAQL,KAAA;MACrCS,YAAA,EAAcX,IAAA,EAAMY,IAAA,EAAMC,QAAA;MAC1BV,cAAA,EAAgBA,cAAA,KAAmBI,SAAA,GAAY,QAAQJ,cAAA;MACvDW,MAAA,EAAQd,IAAA,EAAMY,IAAA;MACdP,GAAA,EAAKA,GAAA;MACLC,gBAAA,EAAkBA,gBAAA,KAAqBC,SAAA,GAAY,QAAQD;IAC7D;EACF;EACA,OAAO;AACT;AAEA;;;AAGA,OAAO,eAAeI,0BAA0B;EAC9CZ,UAAU;EACVC,YAAY;EACZE,KAAK;EACLC,KAAK;EACLS,YAAY;EACZR,cAAc;EACdW,MAAM;EACNT,GAAG;EACHC;AAAgB,CAcjB;EACC,MAAMS,gBAAA,GAAmBjB,UAAA,CAAWkB,IAAI,CAAEC,SAAA,IAAcA,SAAA,CAAUC,SAAS,CAACC,QAAQ,CAAC;EAErF,MAAMC,SAAA,GAAY,MAAMC,OAAA,CAAQC,GAAG,CACjCX,YAAA,CAAaY,GAAG,CAAC,OAAOC,IAAA,EAAMC,CAAA;IAC5B,MAAMC,gBAAA,GAAmB5B,UAAA,CAAWkB,IAAI,CAAEC,SAAA,IACxCA,SAAA,CAAUC,SAAS,CAACC,QAAQ,CAACK,IAAA,CAAKG,IAAI;IAExC,IAAI;MACF,IAAI,CAACD,gBAAA,EAAkB;QACrB,IAAIX,gBAAA,EAAkB;UACpB,OAAO,MAAMA,gBAAA,CAAiBE,SAAS,CAAC;YACtCW,UAAA,EAAYH,CAAA;YACZ3B,UAAA;YACAC,YAAA;YACAE,KAAA;YACAC,KAAA;YACAsB,IAAA;YACArB,cAAA;YACAW,MAAA;YACAT,GAAA;YACAC;UACF;QACF;QACA,OAAO;MACT;MACA,OAAO,MAAMoB,gBAAA,CAAiBT,SAAS,CAAC;QACtCW,UAAA,EAAYH,CAAA;QACZ3B,UAAA;QACAC,YAAA;QACAE,KAAA;QACAC,KAAA;QACAsB,IAAA;QACArB,cAAA;QACAW,MAAA;QACAT,GAAA;QACAC;MACF;IACF,EAAE,OAAOuB,KAAA,EAAO;MACdC,OAAA,CAAQD,KAAK,CAAC,0CAA0CA,KAAA,EAAO,SAASL,IAAA;MACxE,OAAO;IACT;EACF;EAGF,OAAOJ,SAAA,CAAUW,IAAI,CAAC,OAAO;AAC/B","ignoreList":[]}

package/dist/features/converters/lexicalToHtml_deprecated/converter/types.d.ts

@@ -1,27 +0,0 @@
-import type { SerializedLexicalNode } from 'lexical';
-import type { PayloadRequest } from 'payload';
-/**
- * @deprecated - will be removed in 4.0
- */
-export type HTMLConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
-    converter: (args: {
-        childIndex: number;
-        converters: HTMLConverter<any>[];
-        currentDepth: number;
-        depth: number;
-        draft: boolean;
-        node: T;
-        overrideAccess: boolean;
-        parent: SerializedLexicalNodeWithParent;
-        /**
-         * When the converter is called, req CAN be passed in depending on where it's run.
-         */
-        req: null | PayloadRequest;
-        showHiddenFields: boolean;
-    }) => Promise<string> | string;
-    nodeTypes: string[];
-};
-export type SerializedLexicalNodeWithParent = {
-    parent?: SerializedLexicalNode;
-} & SerializedLexicalNode;
-//# sourceMappingURL=types.d.ts.map

package/dist/features/converters/lexicalToHtml_deprecated/converter/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToHtml_deprecated/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IACnF,SAAS,EAAE,CAAC,IAAI,EAAE;QAChB,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,CAAA;QAChC,YAAY,EAAE,MAAM,CAAA;QACpB,KAAK,EAAE,MAAM,CAAA;QACb,KAAK,EAAE,OAAO,CAAA;QACd,IAAI,EAAE,CAAC,CAAA;QACP,cAAc,EAAE,OAAO,CAAA;QACvB,MAAM,EAAE,+BAA+B,CAAA;QACvC;;WAEG;QACH,GAAG,EAAE,IAAI,GAAG,cAAc,CAAA;QAC1B,gBAAgB,EAAE,OAAO,CAAA;KAC1B,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAA;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG;IAC5C,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAC/B,GAAG,qBAAqB,CAAA"}

package/dist/features/converters/lexicalToHtml_deprecated/converter/types.js

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

package/dist/features/converters/lexicalToHtml_deprecated/converter/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToHtml_deprecated/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type { PayloadRequest } from 'payload'\n\n/**\n * @deprecated - will be removed in 4.0\n */\nexport type HTMLConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: (args: {\n    childIndex: number\n    converters: HTMLConverter<any>[]\n    currentDepth: number\n    depth: number\n    draft: boolean\n    node: T\n    overrideAccess: boolean\n    parent: SerializedLexicalNodeWithParent\n    /**\n     * When the converter is called, req CAN be passed in depending on where it's run.\n     */\n    req: null | PayloadRequest\n    showHiddenFields: boolean\n  }) => Promise<string> | string\n  nodeTypes: string[]\n}\n\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"mappings":"AAyBA","ignoreList":[]}

package/dist/features/converters/lexicalToHtml_deprecated/field/index.d.ts

@@ -1,39 +0,0 @@
-import type { Field } from 'payload';
-import type { SanitizedServerEditorConfig } from '../../../../lexical/config/types.js';
-import type { HTMLConverter } from '../converter/types.js';
-type Args = {
-    /**
-     * Whether the lexicalHTML field should be hidden in the admin panel
-     *
-     * @default true
-     */
-    hidden?: boolean;
-    name: string;
-    /**
-     * Whether the HTML should be stored in the database
-     *
-     * @default false
-     */
-    storeInDB?: boolean;
-};
-/**
- * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.
- *
- * @deprecated - will be removed in 4.0
- * @param editorConfig
- */
-export declare const consolidateHTMLConverters: ({ editorConfig, }: {
-    editorConfig: SanitizedServerEditorConfig;
-}) => HTMLConverter[];
-/**
- * @deprecated - will be removed in 4.0
- */
-export declare const lexicalHTML: (
-/**
- * A string which matches the lexical field name you want to convert to HTML.
- *
- * This has to be a sibling field of this lexicalHTML field - otherwise, it won't be able to find the lexical field.
- **/
-lexicalFieldName: string, args: Args) => Field;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/features/converters/lexicalToHtml_deprecated/field/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToHtml_deprecated/field/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAA;AAEtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAM1D,KAAK,IAAI,GAAG;IACV;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,sBAEnC;IACD,YAAY,EAAE,2BAA2B,CAAA;CAC1C,KAAG,aAAa,EA+ChB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE;AACxB;;;;IAII;AACJ,gBAAgB,EAAE,MAAM,EACxB,IAAI,EAAE,IAAI,KACP,KAuFJ,CAAA"}

package/dist/features/converters/lexicalToHtml_deprecated/field/index.js

@@ -1,122 +0,0 @@
-import { defaultHTMLConverters } from '../converter/defaultConverters.js';
-import { convertLexicalToHTML } from '../converter/index.js';
-/**
- * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.
- *
- * @deprecated - will be removed in 4.0
- * @param editorConfig
- */
-export const consolidateHTMLConverters = ({
-  editorConfig
-}) => {
-  const htmlConverterFeature = editorConfig.resolvedFeatureMap.get('htmlConverter');
-  const htmlConverterFeatureProps = htmlConverterFeature?.sanitizedServerFeatureProps;
-  const defaultConvertersWithConvertersFromFeatures = [...defaultHTMLConverters];
-  for (const converter of editorConfig.features.converters.html) {
-    defaultConvertersWithConvertersFromFeatures.push(converter);
-  }
-  const finalConverters = htmlConverterFeatureProps?.converters && typeof htmlConverterFeatureProps?.converters === 'function' ? htmlConverterFeatureProps.converters({
-    defaultConverters: defaultConvertersWithConvertersFromFeatures
-  }) : htmlConverterFeatureProps?.converters || defaultConvertersWithConvertersFromFeatures;
-  // filter converters by nodeTypes. The last converter in the list wins. If there are multiple converters for the same nodeType, the last one will be used and the node types will be removed from
-  // previous converters. If previous converters do not have any nodeTypes left, they will be removed from the list.
-  // This guarantees that user-added converters which are added after the default ones will always have precedence
-  const foundNodeTypes = [];
-  const filteredConverters = [];
-  for (const converter of finalConverters.reverse()) {
-    if (!converter.nodeTypes?.length) {
-      continue;
-    }
-    const newConverter = {
-      converter: converter.converter,
-      nodeTypes: [...converter.nodeTypes]
-    };
-    newConverter.nodeTypes = newConverter.nodeTypes.filter(nodeType => {
-      if (foundNodeTypes.includes(nodeType)) {
-        return false;
-      }
-      foundNodeTypes.push(nodeType);
-      return true;
-    });
-    if (newConverter.nodeTypes.length) {
-      filteredConverters.push(newConverter);
-    }
-  }
-  return filteredConverters;
-};
-/**
- * @deprecated - will be removed in 4.0
- */
-export const lexicalHTML = (lexicalFieldName, args) => {
-  const {
-    name = 'lexicalHTML',
-    hidden = true,
-    storeInDB = false
-  } = args;
-  return {
-    name,
-    type: 'code',
-    admin: {
-      editorOptions: {
-        language: 'html'
-      },
-      hidden
-    },
-    hooks: {
-      afterRead: [async ({
-        currentDepth,
-        depth,
-        draft,
-        field,
-        overrideAccess,
-        req,
-        showHiddenFields,
-        siblingData,
-        siblingFields
-      }) => {
-        if (!siblingFields) {
-          throw new Error(`Could not find sibling fields of current lexicalHTML field with name ${field?.name}`);
-        }
-        const lexicalField = siblingFields.find(field => 'name' in field && field.name === lexicalFieldName);
-        const lexicalFieldData = siblingData[lexicalFieldName];
-        if (!lexicalFieldData) {
-          return '';
-        }
-        if (!lexicalField) {
-          throw new Error('You cannot use the lexicalHTML field because the referenced lexical field was not found');
-        }
-        const config = lexicalField?.editor?.editorConfig;
-        if (!config) {
-          throw new Error('The linked lexical field does not have an editorConfig. This is needed for the lexicalHTML field.');
-        }
-        if (!config?.resolvedFeatureMap?.has('htmlConverter')) {
-          throw new Error('You cannot use the lexicalHTML field because the linked lexical field does not have a HTMLConverterFeature');
-        }
-        const finalConverters = consolidateHTMLConverters({
-          editorConfig: config
-        });
-        return await convertLexicalToHTML({
-          converters: finalConverters,
-          currentDepth,
-          data: lexicalFieldData,
-          depth,
-          draft,
-          overrideAccess,
-          req,
-          showHiddenFields
-        });
-      }],
-      beforeChange: [({
-        siblingData,
-        value
-      }) => {
-        if (storeInDB) {
-          return value;
-        }
-        delete siblingData[name];
-        return null;
-      }]
-    }
-  };
-};
-//# sourceMappingURL=index.js.map

package/dist/features/converters/lexicalToHtml_deprecated/field/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["defaultHTMLConverters","convertLexicalToHTML","consolidateHTMLConverters","editorConfig","htmlConverterFeature","resolvedFeatureMap","get","htmlConverterFeatureProps","sanitizedServerFeatureProps","defaultConvertersWithConvertersFromFeatures","converter","features","converters","html","push","finalConverters","defaultConverters","foundNodeTypes","filteredConverters","reverse","nodeTypes","length","newConverter","filter","nodeType","includes","lexicalHTML","lexicalFieldName","args","name","hidden","storeInDB","type","admin","editorOptions","language","hooks","afterRead","currentDepth","depth","draft","field","overrideAccess","req","showHiddenFields","siblingData","siblingFields","Error","lexicalField","find","lexicalFieldData","config","editor","has","data","beforeChange","value"],"sources":["../../../../../src/features/converters/lexicalToHtml_deprecated/field/index.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { Field } from 'payload'\n\nimport type { SanitizedServerEditorConfig } from '../../../../lexical/config/types.js'\nimport type { LexicalRichTextAdapter, LexicalRichTextField } from '../../../../types.js'\nimport type { HTMLConverter } from '../converter/types.js'\nimport type { HTMLConverterFeatureProps } from '../index.js'\n\nimport { defaultHTMLConverters } from '../converter/defaultConverters.js'\nimport { convertLexicalToHTML } from '../converter/index.js'\n\ntype Args = {\n  /**\n   * Whether the lexicalHTML field should be hidden in the admin panel\n   *\n   * @default true\n   */\n  hidden?: boolean\n  name: string\n  /**\n   * Whether the HTML should be stored in the database\n   *\n   * @default false\n   */\n  storeInDB?: boolean\n}\n\n/**\n * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.\n *\n * @deprecated - will be removed in 4.0\n * @param editorConfig\n */\nexport const consolidateHTMLConverters = ({\n  editorConfig,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n}): HTMLConverter[] => {\n  const htmlConverterFeature = editorConfig.resolvedFeatureMap.get('htmlConverter')\n  const htmlConverterFeatureProps: HTMLConverterFeatureProps =\n    htmlConverterFeature?.sanitizedServerFeatureProps\n\n  const defaultConvertersWithConvertersFromFeatures = [...defaultHTMLConverters]\n\n  for (const converter of editorConfig.features.converters.html) {\n    defaultConvertersWithConvertersFromFeatures.push(converter)\n  }\n\n  const finalConverters =\n    htmlConverterFeatureProps?.converters &&\n    typeof htmlConverterFeatureProps?.converters === 'function'\n      ? htmlConverterFeatureProps.converters({\n          defaultConverters: defaultConvertersWithConvertersFromFeatures,\n        })\n      : (htmlConverterFeatureProps?.converters as HTMLConverter[]) ||\n        defaultConvertersWithConvertersFromFeatures\n\n  // filter converters by nodeTypes. The last converter in the list wins. If there are multiple converters for the same nodeType, the last one will be used and the node types will be removed from\n  // previous converters. If previous converters do not have any nodeTypes left, they will be removed from the list.\n  // This guarantees that user-added converters which are added after the default ones will always have precedence\n  const foundNodeTypes: string[] = []\n  const filteredConverters: HTMLConverter[] = []\n  for (const converter of finalConverters.reverse()) {\n    if (!converter.nodeTypes?.length) {\n      continue\n    }\n    const newConverter: HTMLConverter = {\n      converter: converter.converter,\n      nodeTypes: [...converter.nodeTypes],\n    }\n    newConverter.nodeTypes = newConverter.nodeTypes.filter((nodeType) => {\n      if (foundNodeTypes.includes(nodeType)) {\n        return false\n      }\n      foundNodeTypes.push(nodeType)\n      return true\n    })\n\n    if (newConverter.nodeTypes.length) {\n      filteredConverters.push(newConverter)\n    }\n  }\n\n  return filteredConverters\n}\n\n/**\n * @deprecated - will be removed in 4.0\n */\nexport const lexicalHTML: (\n  /**\n   * A string which matches the lexical field name you want to convert to HTML.\n   *\n   * This has to be a sibling field of this lexicalHTML field - otherwise, it won't be able to find the lexical field.\n   **/\n  lexicalFieldName: string,\n  args: Args,\n) => Field = (lexicalFieldName, args) => {\n  const { name = 'lexicalHTML', hidden = true, storeInDB = false } = args\n  return {\n    name,\n    type: 'code',\n    admin: {\n      editorOptions: {\n        language: 'html',\n      },\n      hidden,\n    },\n    hooks: {\n      afterRead: [\n        async ({\n          currentDepth,\n          depth,\n          draft,\n          field,\n          overrideAccess,\n          req,\n          showHiddenFields,\n          siblingData,\n          siblingFields,\n        }) => {\n          if (!siblingFields) {\n            throw new Error(\n              `Could not find sibling fields of current lexicalHTML field with name ${field?.name}`,\n            )\n          }\n\n          const lexicalField: LexicalRichTextField = siblingFields.find(\n            (field) => 'name' in field && field.name === lexicalFieldName,\n          ) as LexicalRichTextField\n\n          const lexicalFieldData: SerializedEditorState = siblingData[lexicalFieldName]\n\n          if (!lexicalFieldData) {\n            return ''\n          }\n\n          if (!lexicalField) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the referenced lexical field was not found',\n            )\n          }\n\n          const config = (lexicalField?.editor as LexicalRichTextAdapter)?.editorConfig\n\n          if (!config) {\n            throw new Error(\n              'The linked lexical field does not have an editorConfig. This is needed for the lexicalHTML field.',\n            )\n          }\n\n          if (!config?.resolvedFeatureMap?.has('htmlConverter')) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the linked lexical field does not have a HTMLConverterFeature',\n            )\n          }\n\n          const finalConverters = consolidateHTMLConverters({\n            editorConfig: config,\n          })\n\n          return await convertLexicalToHTML({\n            converters: finalConverters,\n            currentDepth,\n            data: lexicalFieldData,\n            depth,\n            draft,\n            overrideAccess,\n            req,\n            showHiddenFields,\n          })\n        },\n      ],\n      beforeChange: [\n        ({ siblingData, value }) => {\n          if (storeInDB) {\n            return value\n          }\n          delete siblingData[name]\n          return null\n        },\n      ],\n    },\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/converters/lexicalToHtml_deprecated/index.d.ts

@@ -1,12 +0,0 @@
-import type { HTMLConverter } from './converter/types.js';
-export type HTMLConverterFeatureProps = {
-    converters?: (({ defaultConverters }: {
-        defaultConverters: HTMLConverter<any>[];
-    }) => HTMLConverter<any>[]) | HTMLConverter<any>[];
-};
-/**
- * @deprecated - will be removed in 4.0. Please refer to https://payloadcms.com/docs/rich-text/converting-html
- * to see all the ways to convert lexical to HTML.
- */
-export declare const HTMLConverterFeature: import("../../typesServer.js").FeatureProviderProviderServer<HTMLConverterFeatureProps, HTMLConverterFeatureProps, undefined>;
-//# sourceMappingURL=index.d.ts.map

package/dist/features/converters/lexicalToHtml_deprecated/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/lexicalToHtml_deprecated/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAIzD,MAAM,MAAM,yBAAyB,GAAG;IACtC,UAAU,CAAC,EACP,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE;QAAE,iBAAiB,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,CAAA;KAAE,KAAK,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC,GAC9F,aAAa,CAAC,GAAG,CAAC,EAAE,CAAA;CACzB,CAAA;AAGD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,+HAG/B,CAAA"}

package/dist/features/converters/lexicalToHtml_deprecated/index.js

@@ -1,11 +0,0 @@
-import { createServerFeature } from '../../../utilities/createServerFeature.js';
-// This is just used to save the props on the richText field
-/**
- * @deprecated - will be removed in 4.0. Please refer to https://payloadcms.com/docs/rich-text/converting-html
- * to see all the ways to convert lexical to HTML.
- */
-export const HTMLConverterFeature = createServerFeature({
-  feature: {},
-  key: 'htmlConverter'
-});
-//# sourceMappingURL=index.js.map

package/dist/features/converters/lexicalToHtml_deprecated/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["createServerFeature","HTMLConverterFeature","feature","key"],"sources":["../../../../src/features/converters/lexicalToHtml_deprecated/index.ts"],"sourcesContent":["import type { HTMLConverter } from './converter/types.js'\n\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\n\nexport type HTMLConverterFeatureProps = {\n  converters?:\n    | (({ defaultConverters }: { defaultConverters: HTMLConverter<any>[] }) => HTMLConverter<any>[])\n    | HTMLConverter<any>[]\n}\n\n// This is just used to save the props on the richText field\n/**\n * @deprecated - will be removed in 4.0. Please refer to https://payloadcms.com/docs/rich-text/converting-html\n * to see all the ways to convert lexical to HTML.\n */\nexport const HTMLConverterFeature = createServerFeature<HTMLConverterFeatureProps>({\n  feature: {},\n  key: 'htmlConverter',\n})\n"],"mappings":"AAEA,SAASA,mBAAmB,QAAQ;AAQpC;AACA;;;;AAIA,OAAO,MAAMC,oBAAA,GAAuBD,mBAAA,CAA+C;EACjFE,OAAA,EAAS,CAAC;EACVC,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/lists/htmlConverter.d.ts

@@ -1,5 +0,0 @@
-import type { HTMLConverter } from '../converters/lexicalToHtml_deprecated/converter/types.js';
-import type { SerializedListItemNode, SerializedListNode } from './plugin/index.js';
-export declare const ListHTMLConverter: HTMLConverter<SerializedListNode>;
-export declare const ListItemHTMLConverter: HTMLConverter<SerializedListItemNode>;
-//# sourceMappingURL=htmlConverter.d.ts.map

package/dist/features/lists/htmlConverter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"htmlConverter.d.ts","sourceRoot":"","sources":["../../../src/features/lists/htmlConverter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2DAA2D,CAAA;AAC9F,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAInF,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,kBAAkB,CA8B/D,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,sBAAsB,CAyDvE,CAAA"}

package/dist/features/lists/htmlConverter.js

@@ -1,81 +0,0 @@
-import { ListItemNode, ListNode } from '@lexical/list';
-import { v4 as uuidv4 } from 'uuid';
-import { convertLexicalNodesToHTML } from '../converters/lexicalToHtml_deprecated/converter/index.js';
-export const ListHTMLConverter = {
-  converter: async ({
-    converters,
-    currentDepth,
-    depth,
-    draft,
-    node,
-    overrideAccess,
-    parent,
-    req,
-    showHiddenFields
-  }) => {
-    const childrenText = await convertLexicalNodesToHTML({
-      converters,
-      currentDepth,
-      depth,
-      draft,
-      lexicalNodes: node.children,
-      overrideAccess,
-      parent: {
-        ...node,
-        parent
-      },
-      req,
-      showHiddenFields
-    });
-    return `<${node?.tag} class="list-${node?.listType}">${childrenText}</${node?.tag}>`;
-  },
-  nodeTypes: [ListNode.getType()]
-};
-export const ListItemHTMLConverter = {
-  converter: async ({
-    converters,
-    currentDepth,
-    depth,
-    draft,
-    node,
-    overrideAccess,
-    parent,
-    req,
-    showHiddenFields
-  }) => {
-    const hasSubLists = node.children.some(child => child.type === 'list');
-    const childrenText = await convertLexicalNodesToHTML({
-      converters,
-      currentDepth,
-      depth,
-      draft,
-      lexicalNodes: node.children,
-      overrideAccess,
-      parent: {
-        ...node,
-        parent
-      },
-      req,
-      showHiddenFields
-    });
-    if ('listType' in parent && parent?.listType === 'check') {
-      const uuid = uuidv4();
-      return `<li aria-checked=${node.checked ? 'true' : 'false'} class="${'list-item-checkbox' + (node.checked ? ' list-item-checkbox-checked' : ' list-item-checkbox-unchecked') + (hasSubLists ? ' nestedListItem' : '')}"
-          role="checkbox"
-          tabIndex=${-1}
-          value=${node?.value}
-      >
-      ${hasSubLists ? childrenText : `
-        <input type="checkbox" id="${uuid}"${node.checked ? ' checked' : ''}>
-        <label for="${uuid}">${childrenText}</label><br>
-      `}
-
-
-          </li>`;
-    } else {
-      return `<li ${hasSubLists ? `class="nestedListItem" ` : ''}value=${node?.value}>${childrenText}</li>`;
-    }
-  },
-  nodeTypes: [ListItemNode.getType()]
-};
-//# sourceMappingURL=htmlConverter.js.map

package/dist/features/lists/htmlConverter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"htmlConverter.js","names":["ListItemNode","ListNode","v4","uuidv4","convertLexicalNodesToHTML","ListHTMLConverter","converter","converters","currentDepth","depth","draft","node","overrideAccess","parent","req","showHiddenFields","childrenText","lexicalNodes","children","tag","listType","nodeTypes","getType","ListItemHTMLConverter","hasSubLists","some","child","type","uuid","checked","value"],"sources":["../../../src/features/lists/htmlConverter.ts"],"sourcesContent":["import { ListItemNode, ListNode } from '@lexical/list'\nimport { v4 as uuidv4 } from 'uuid'\n\nimport type { HTMLConverter } from '../converters/lexicalToHtml_deprecated/converter/types.js'\nimport type { SerializedListItemNode, SerializedListNode } from './plugin/index.js'\n\nimport { convertLexicalNodesToHTML } from '../converters/lexicalToHtml_deprecated/converter/index.js'\n\nexport const ListHTMLConverter: HTMLConverter<SerializedListNode> = {\n  converter: async ({\n    converters,\n    currentDepth,\n    depth,\n    draft,\n    node,\n    overrideAccess,\n    parent,\n    req,\n    showHiddenFields,\n  }) => {\n    const childrenText = await convertLexicalNodesToHTML({\n      converters,\n      currentDepth,\n      depth,\n      draft,\n      lexicalNodes: node.children,\n      overrideAccess,\n      parent: {\n        ...node,\n        parent,\n      },\n      req,\n      showHiddenFields,\n    })\n\n    return `<${node?.tag} class=\"list-${node?.listType}\">${childrenText}</${node?.tag}>`\n  },\n  nodeTypes: [ListNode.getType()],\n}\n\nexport const ListItemHTMLConverter: HTMLConverter<SerializedListItemNode> = {\n  converter: async ({\n    converters,\n    currentDepth,\n    depth,\n    draft,\n    node,\n    overrideAccess,\n    parent,\n    req,\n    showHiddenFields,\n  }) => {\n    const hasSubLists = node.children.some((child) => child.type === 'list')\n\n    const childrenText = await convertLexicalNodesToHTML({\n      converters,\n      currentDepth,\n      depth,\n      draft,\n      lexicalNodes: node.children,\n      overrideAccess,\n      parent: {\n        ...node,\n        parent,\n      },\n      req,\n      showHiddenFields,\n    })\n\n    if ('listType' in parent && parent?.listType === 'check') {\n      const uuid = uuidv4()\n\n      return `<li aria-checked=${node.checked ? 'true' : 'false'} class=\"${\n        'list-item-checkbox' +\n        (node.checked ? ' list-item-checkbox-checked' : ' list-item-checkbox-unchecked') +\n        (hasSubLists ? ' nestedListItem' : '')\n      }\"\n          role=\"checkbox\"\n          tabIndex=${-1}\n          value=${node?.value}\n      >\n      ${\n        hasSubLists\n          ? childrenText\n          : `\n        <input type=\"checkbox\" id=\"${uuid}\"${node.checked ? ' checked' : ''}>\n        <label for=\"${uuid}\">${childrenText}</label><br>\n      `\n      }\n\n\n          </li>`\n    } else {\n      return `<li ${hasSubLists ? `class=\"nestedListItem\" ` : ''}value=${node?.value}>${childrenText}</li>`\n    }\n  },\n  nodeTypes: [ListItemNode.getType()],\n}\n"],"mappings":"AAAA,SAASA,YAAY,EAAEC,QAAQ,QAAQ;AACvC,SAASC,EAAA,IAAMC,MAAM,QAAQ;AAK7B,SAASC,yBAAyB,QAAQ;AAE1C,OAAO,MAAMC,iBAAA,GAAuD;EAClEC,SAAA,EAAW,MAAAA,CAAO;IAChBC,UAAU;IACVC,YAAY;IACZC,KAAK;IACLC,KAAK;IACLC,IAAI;IACJC,cAAc;IACdC,MAAM;IACNC,GAAG;IACHC;EAAgB,CACjB;IACC,MAAMC,YAAA,GAAe,MAAMZ,yBAAA,CAA0B;MACnDG,UAAA;MACAC,YAAA;MACAC,KAAA;MACAC,KAAA;MACAO,YAAA,EAAcN,IAAA,CAAKO,QAAQ;MAC3BN,cAAA;MACAC,MAAA,EAAQ;QACN,GAAGF,IAAI;QACPE;MACF;MACAC,GAAA;MACAC;IACF;IAEA,OAAO,IAAIJ,IAAA,EAAMQ,GAAA,gBAAmBR,IAAA,EAAMS,QAAA,KAAaJ,YAAA,KAAiBL,IAAA,EAAMQ,GAAA,GAAM;EACtF;EACAE,SAAA,EAAW,CAACpB,QAAA,CAASqB,OAAO;AAC9B;AAEA,OAAO,MAAMC,qBAAA,GAA+D;EAC1EjB,SAAA,EAAW,MAAAA,CAAO;IAChBC,UAAU;IACVC,YAAY;IACZC,KAAK;IACLC,KAAK;IACLC,IAAI;IACJC,cAAc;IACdC,MAAM;IACNC,GAAG;IACHC;EAAgB,CACjB;IACC,MAAMS,WAAA,GAAcb,IAAA,CAAKO,QAAQ,CAACO,IAAI,CAAEC,KAAA,IAAUA,KAAA,CAAMC,IAAI,KAAK;IAEjE,MAAMX,YAAA,GAAe,MAAMZ,yBAAA,CAA0B;MACnDG,UAAA;MACAC,YAAA;MACAC,KAAA;MACAC,KAAA;MACAO,YAAA,EAAcN,IAAA,CAAKO,QAAQ;MAC3BN,cAAA;MACAC,MAAA,EAAQ;QACN,GAAGF,IAAI;QACPE;MACF;MACAC,GAAA;MACAC;IACF;IAEA,IAAI,cAAcF,MAAA,IAAUA,MAAA,EAAQO,QAAA,KAAa,SAAS;MACxD,MAAMQ,IAAA,GAAOzB,MAAA;MAEb,OAAO,oBAAoBQ,IAAA,CAAKkB,OAAO,GAAG,SAAS,kBACjD,wBACClB,IAAA,CAAKkB,OAAO,GAAG,gCAAgC,+BAA8B,KAC7EL,WAAA,GAAc,oBAAoB,EAAC;;qBAGvB,CAAC;kBACJb,IAAA,EAAMmB,KAAA;;QAGhBN,WAAA,GACIR,YAAA,GACA;qCACyBY,IAAA,IAAQjB,IAAA,CAAKkB,OAAO,GAAG,aAAa;sBACnDD,IAAA,KAASZ,YAAA;OACxB;;;gBAIS;IACZ,OAAO;MACL,OAAO,OAAOQ,WAAA,GAAc,yBAAyB,GAAG,WAAWb,IAAA,EAAMmB,KAAA,IAASd,YAAA,OAAmB;IACvG;EACF;EACAK,SAAA,EAAW,CAACrB,YAAA,CAAasB,OAAO;AAClC","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/heading/converter.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/heading/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,gBAAgB,EAAE,0BAe9B,CAAA"}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/heading/converter.js

@@ -1,22 +0,0 @@
-import { convertLexicalPluginNodesToLexical } from '../../index.js';
-export const HeadingConverter = {
-  converter({
-    converters,
-    lexicalPluginNode,
-    quiet
-  }) {
-    return {
-      ...lexicalPluginNode,
-      type: 'heading',
-      children: convertLexicalPluginNodesToLexical({
-        converters,
-        lexicalPluginNodes: lexicalPluginNode.children,
-        parentNodeType: 'heading',
-        quiet
-      }),
-      version: 1
-    };
-  },
-  nodeTypes: ['heading']
-};
-//# sourceMappingURL=converter.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["convertLexicalPluginNodesToLexical","HeadingConverter","converter","converters","lexicalPluginNode","quiet","type","children","lexicalPluginNodes","parentNodeType","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/heading/converter.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '../../../../../heading/server/index.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const HeadingConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode, quiet }) {\n    return {\n      ...lexicalPluginNode,\n      type: 'heading',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'heading',\n        quiet,\n      }),\n      version: 1,\n    } as const as SerializedHeadingNode\n  },\n  nodeTypes: ['heading'],\n}\n"],"mappings":"AAGA,SAASA,kCAAkC,QAAQ;AAEnD,OAAO,MAAMC,gBAAA,GAA+C;EAC1DC,UAAU;IAAEC,UAAU;IAAEC,iBAAiB;IAAEC;EAAK,CAAE;IAChD,OAAO;MACL,GAAGD,iBAAiB;MACpBE,IAAA,EAAM;MACNC,QAAA,EAAUP,kCAAA,CAAmC;QAC3CG,UAAA;QACAK,kBAAA,EAAoBJ,iBAAA,CAAkBG,QAAQ;QAC9CE,cAAA,EAAgB;QAChBJ;MACF;MACAK,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/link/converter.d.ts

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

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

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

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/link/converter.js

@@ -1,33 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */import { convertLexicalPluginNodesToLexical } from '../../index.js';
-export const LinkConverter = {
-  converter({
-    converters,
-    lexicalPluginNode,
-    quiet
-  }) {
-    return {
-      type: 'link',
-      children: convertLexicalPluginNodesToLexical({
-        converters,
-        lexicalPluginNodes: lexicalPluginNode.children,
-        parentNodeType: 'link',
-        quiet
-      }),
-      direction: lexicalPluginNode.direction || 'ltr',
-      fields: {
-        doc: lexicalPluginNode.attributes?.doc ? {
-          relationTo: lexicalPluginNode.attributes?.doc?.relationTo,
-          value: lexicalPluginNode.attributes?.doc?.value
-        } : undefined,
-        linkType: lexicalPluginNode.attributes?.linkType || 'custom',
-        newTab: lexicalPluginNode.attributes?.newTab || false,
-        url: lexicalPluginNode.attributes?.url || undefined
-      },
-      format: lexicalPluginNode.format || '',
-      indent: lexicalPluginNode.indent || 0,
-      version: 2
-    };
-  },
-  nodeTypes: ['link']
-};
-//# sourceMappingURL=converter.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["convertLexicalPluginNodesToLexical","LinkConverter","converter","converters","lexicalPluginNode","quiet","type","children","lexicalPluginNodes","parentNodeType","direction","fields","doc","attributes","relationTo","value","undefined","linkType","newTab","url","format","indent","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/link/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedLinkNode } from '../../../../../link/nodes/types.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const LinkConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode, quiet }) {\n    return {\n      type: 'link',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'link',\n        quiet,\n      }),\n      direction: (lexicalPluginNode as any).direction || 'ltr',\n      fields: {\n        doc: (lexicalPluginNode as any).attributes?.doc\n          ? {\n              relationTo: (lexicalPluginNode as any).attributes?.doc?.relationTo,\n              value: (lexicalPluginNode as any).attributes?.doc?.value,\n            }\n          : undefined,\n        linkType: (lexicalPluginNode as any).attributes?.linkType || 'custom',\n        newTab: (lexicalPluginNode as any).attributes?.newTab || false,\n        url: (lexicalPluginNode as any).attributes?.url || undefined,\n      },\n      format: (lexicalPluginNode as any).format || '',\n      indent: (lexicalPluginNode as any).indent || 0,\n      version: 2,\n    } as const as SerializedLinkNode\n  },\n  nodeTypes: ['link'],\n}\n"],"mappings":"AAAA,uDAKA,SAASA,kCAAkC,QAAQ;AAEnD,OAAO,MAAMC,aAAA,GAA4C;EACvDC,UAAU;IAAEC,UAAU;IAAEC,iBAAiB;IAAEC;EAAK,CAAE;IAChD,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUP,kCAAA,CAAmC;QAC3CG,UAAA;QACAK,kBAAA,EAAoBJ,iBAAA,CAAkBG,QAAQ;QAC9CE,cAAA,EAAgB;QAChBJ;MACF;MACAK,SAAA,EAAWN,iBAAC,CAA0BM,SAAS,IAAI;MACnDC,MAAA,EAAQ;QACNC,GAAA,EAAKR,iBAAC,CAA0BS,UAAU,EAAED,GAAA,GACxC;UACEE,UAAA,EAAYV,iBAAC,CAA0BS,UAAU,EAAED,GAAA,EAAKE,UAAA;UACxDC,KAAA,EAAOX,iBAAC,CAA0BS,UAAU,EAAED,GAAA,EAAKG;QACrD,IACAC,SAAA;QACJC,QAAA,EAAUb,iBAAC,CAA0BS,UAAU,EAAEI,QAAA,IAAY;QAC7DC,MAAA,EAAQd,iBAAC,CAA0BS,UAAU,EAAEK,MAAA,IAAU;QACzDC,GAAA,EAAKf,iBAAC,CAA0BS,UAAU,EAAEM,GAAA,IAAOH;MACrD;MACAI,MAAA,EAAQhB,iBAAC,CAA0BgB,MAAM,IAAI;MAC7CC,MAAA,EAAQjB,iBAAC,CAA0BiB,MAAM,IAAI;MAC7CC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/list/converter.d.ts

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

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

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

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/list/converter.js

@@ -1,24 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */import { convertLexicalPluginNodesToLexical } from '../../index.js';
-export const ListConverter = {
-  converter({
-    converters,
-    lexicalPluginNode,
-    quiet
-  }) {
-    return {
-      ...lexicalPluginNode,
-      type: 'list',
-      children: convertLexicalPluginNodesToLexical({
-        converters,
-        lexicalPluginNodes: lexicalPluginNode.children,
-        parentNodeType: 'list',
-        quiet
-      }),
-      listType: lexicalPluginNode?.listType || 'number',
-      tag: lexicalPluginNode?.tag || 'ol',
-      version: 1
-    };
-  },
-  nodeTypes: ['list']
-};
-//# sourceMappingURL=converter.js.map

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/list/converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["convertLexicalPluginNodesToLexical","ListConverter","converter","converters","lexicalPluginNode","quiet","type","children","lexicalPluginNodes","parentNodeType","listType","tag","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/list/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const ListConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode, quiet }) {\n    return {\n      ...lexicalPluginNode,\n      type: 'list',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'list',\n        quiet,\n      }),\n      listType: (lexicalPluginNode as any)?.listType || 'number',\n      tag: (lexicalPluginNode as any)?.tag || 'ol',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['list'],\n}\n"],"mappings":"AAAA,uDAKA,SAASA,kCAAkC,QAAQ;AAEnD,OAAO,MAAMC,aAAA,GAA4C;EACvDC,UAAU;IAAEC,UAAU;IAAEC,iBAAiB;IAAEC;EAAK,CAAE;IAChD,OAAO;MACL,GAAGD,iBAAiB;MACpBE,IAAA,EAAM;MACNC,QAAA,EAAUP,kCAAA,CAAmC;QAC3CG,UAAA;QACAK,kBAAA,EAAoBJ,iBAAA,CAAkBG,QAAQ;QAC9CE,cAAA,EAAgB;QAChBJ;MACF;MACAK,QAAA,EAAUN,iBAAC,EAA2BM,QAAA,IAAY;MAClDC,GAAA,EAAKP,iBAAC,EAA2BO,GAAA,IAAO;MACxCC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/listItem/converter.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/listItem/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,iBAAiB,EAAE,0BAiB/B,CAAA"}

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

@@ -1,25 +0,0 @@
-import { convertLexicalPluginNodesToLexical } from '../../index.js';
-export const ListItemConverter = {
-  converter({
-    childIndex,
-    converters,
-    lexicalPluginNode,
-    quiet
-  }) {
-    return {
-      ...lexicalPluginNode,
-      type: 'listitem',
-      checked: undefined,
-      children: convertLexicalPluginNodesToLexical({
-        converters,
-        lexicalPluginNodes: lexicalPluginNode.children,
-        parentNodeType: 'listitem',
-        quiet
-      }),
-      value: childIndex + 1,
-      version: 1
-    };
-  },
-  nodeTypes: ['listitem']
-};
-//# sourceMappingURL=converter.js.map

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/listItem/converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["convertLexicalPluginNodesToLexical","ListItemConverter","converter","childIndex","converters","lexicalPluginNode","quiet","type","checked","undefined","children","lexicalPluginNodes","parentNodeType","value","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '../../../../../lists/plugin/index.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const ListItemConverter: LexicalPluginNodeConverter = {\n  converter({ childIndex, converters, lexicalPluginNode, quiet }) {\n    return {\n      ...lexicalPluginNode,\n      type: 'listitem',\n      checked: undefined,\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'listitem',\n        quiet,\n      }),\n      value: childIndex + 1,\n      version: 1,\n    } as const as SerializedListItemNode\n  },\n  nodeTypes: ['listitem'],\n}\n"],"mappings":"AAGA,SAASA,kCAAkC,QAAQ;AAEnD,OAAO,MAAMC,iBAAA,GAAgD;EAC3DC,UAAU;IAAEC,UAAU;IAAEC,UAAU;IAAEC,iBAAiB;IAAEC;EAAK,CAAE;IAC5D,OAAO;MACL,GAAGD,iBAAiB;MACpBE,IAAA,EAAM;MACNC,OAAA,EAASC,SAAA;MACTC,QAAA,EAAUV,kCAAA,CAAmC;QAC3CI,UAAA;QACAO,kBAAA,EAAoBN,iBAAA,CAAkBK,QAAQ;QAC9CE,cAAA,EAAgB;QAChBN;MACF;MACAO,KAAA,EAAOV,UAAA,GAAa;MACpBW,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,cAAc,EAAE,0BAe5B,CAAA"}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.js

@@ -1,22 +0,0 @@
-import { convertLexicalPluginNodesToLexical } from '../../index.js';
-export const QuoteConverter = {
-  converter({
-    converters,
-    lexicalPluginNode,
-    quiet
-  }) {
-    return {
-      ...lexicalPluginNode,
-      type: 'quote',
-      children: convertLexicalPluginNodesToLexical({
-        converters,
-        lexicalPluginNodes: lexicalPluginNode.children,
-        parentNodeType: 'quote',
-        quiet
-      }),
-      version: 1
-    };
-  },
-  nodeTypes: ['quote']
-};
-//# sourceMappingURL=converter.js.map

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["convertLexicalPluginNodesToLexical","QuoteConverter","converter","converters","lexicalPluginNode","quiet","type","children","lexicalPluginNodes","parentNodeType","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/quote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '../../../../../blockquote/server/index.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const QuoteConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode, quiet }) {\n    return {\n      ...lexicalPluginNode,\n      type: 'quote',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'quote',\n        quiet,\n      }),\n      version: 1,\n    } as const as SerializedQuoteNode\n  },\n  nodeTypes: ['quote'],\n}\n"],"mappings":"AAGA,SAASA,kCAAkC,QAAQ;AAEnD,OAAO,MAAMC,cAAA,GAA6C;EACxDC,UAAU;IAAEC,UAAU;IAAEC,iBAAiB;IAAEC;EAAK,CAAE;IAChD,OAAO;MACL,GAAGD,iBAAiB;MACpBE,IAAA,EAAM;MACNC,QAAA,EAAUP,kCAAA,CAAmC;QAC3CG,UAAA;QACAK,kBAAA,EAAoBJ,iBAAA,CAAkBG,QAAQ;QAC9CE,cAAA,EAAgB;QAChBJ;MACF;MACAK,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAIhE,eAAO,MAAM,gBAAgB,EAAE,0BAqB9B,CAAA"}