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

package/dist/features/converters/lexicalToHtml/async/index.js

@@ -1,97 +1,107 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable no-console */ import { hasText } from '../../../../validate/hasText.js';
+/* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable no-console */import { hasText } from '../../../../validate/hasText.js';
 import { findConverterForNode } from '../shared/findConverterForNode.js';
 import { defaultHTMLConvertersAsync } from './defaultConverters.js';
-/**
-   * Override class names for the container.
-   */ /**
-   * If true, removes the container div wrapper.
-   */ /**
-   * If true, disables indentation globally. If an array, disables for specific node `type` values.
-   */ /**
-   * If true, disables text alignment globally. If an array, disables for specific node `type` values.
-   */ export async function convertLexicalToHTMLAsync({ className, converters, data, disableContainer, disableIndent, disableTextAlign, populate }) {
-    if (hasText(data)) {
-        let finalConverters = {};
-        if (converters) {
-            if (typeof converters === 'function') {
-                finalConverters = converters({
-                    defaultConverters: defaultHTMLConvertersAsync
-                });
-            } else {
-                finalConverters = converters;
-            }
-        } else {
-            finalConverters = defaultHTMLConvertersAsync;
-        }
-        const html = (await convertLexicalNodesToHTMLAsync({
-            converters: finalConverters,
-            disableIndent,
-            disableTextAlign,
-            nodes: data?.root?.children,
-            parent: data?.root,
-            populate
-        })).join('');
-        if (disableContainer) {
-            return html;
-        } else {
-            return `<div class="${className ?? 'payload-richtext'}">${html}</div>`;
-        }
+export async function convertLexicalToHTMLAsync({
+  className,
+  converters,
+  data,
+  disableContainer,
+  disableIndent,
+  disableTextAlign,
+  populate
+}) {
+  if (hasText(data)) {
+    let finalConverters = {};
+    if (converters) {
+      if (typeof converters === 'function') {
+        finalConverters = converters({
+          defaultConverters: defaultHTMLConvertersAsync
+        });
+      } else {
+        finalConverters = converters;
+      }
+    } else {
+      finalConverters = defaultHTMLConvertersAsync;
     }
+    const html = (await convertLexicalNodesToHTMLAsync({
+      converters: finalConverters,
+      disableIndent,
+      disableTextAlign,
+      nodes: data?.root?.children,
+      parent: data?.root,
+      populate
+    })).join('');
     if (disableContainer) {
-        return '';
+      return html;
     } else {
-        return `<div class="${className ?? 'payload-richtext'}"></div>`;
+      return `<div class="${className ?? 'payload-richtext'}">${html}</div>`;
     }
+  }
+  if (disableContainer) {
+    return '';
+  } else {
+    return `<div class="${className ?? 'payload-richtext'}"></div>`;
+  }
 }
-export async function convertLexicalNodesToHTMLAsync({ converters, disableIndent, disableTextAlign, nodes, parent, populate }) {
-    const unknownConverter = converters.unknown;
-    const htmlArray = [];
-    let i = -1;
-    for (const node of nodes){
-        i++;
-        const { converterForNode, providedCSSString, providedStyleTag } = findConverterForNode({
-            converters,
-            disableIndent,
-            disableTextAlign,
-            node,
-            unknownConverter
-        });
-        try {
-            let nodeHTML;
-            if (converterForNode) {
-                const converted = typeof converterForNode === 'function' ? await converterForNode({
-                    childIndex: i,
-                    converters,
-                    node,
-                    populate,
-                    nodesToHTML: async (args)=>{
-                        return await convertLexicalNodesToHTMLAsync({
-                            converters: args.converters ?? converters,
-                            disableIndent: args.disableIndent ?? disableIndent,
-                            disableTextAlign: args.disableTextAlign ?? disableTextAlign,
-                            nodes: args.nodes,
-                            parent: args.parent ?? {
-                                ...node,
-                                parent
-                            },
-                            populate
-                        });
-                    },
-                    parent,
-                    providedCSSString,
-                    providedStyleTag
-                }) : converterForNode;
-                nodeHTML = converted;
-            } else {
-                nodeHTML = '<span>unknown node</span>';
-            }
-            htmlArray.push(nodeHTML);
-        } catch (error) {
-            console.error('Error converting lexical node to HTML:', error, 'node:', node);
-            htmlArray.push('');
-        }
+export async function convertLexicalNodesToHTMLAsync({
+  converters,
+  disableIndent,
+  disableTextAlign,
+  nodes,
+  parent,
+  populate
+}) {
+  const unknownConverter = converters.unknown;
+  const htmlArray = [];
+  let i = -1;
+  for (const node of nodes) {
+    i++;
+    const {
+      converterForNode,
+      providedCSSString,
+      providedStyleTag
+    } = findConverterForNode({
+      converters,
+      disableIndent,
+      disableTextAlign,
+      node,
+      unknownConverter
+    });
+    try {
+      let nodeHTML;
+      if (converterForNode) {
+        const converted = typeof converterForNode === 'function' ? await converterForNode({
+          childIndex: i,
+          converters,
+          node,
+          populate,
+          nodesToHTML: async args => {
+            return await convertLexicalNodesToHTMLAsync({
+              converters: args.converters ?? converters,
+              disableIndent: args.disableIndent ?? disableIndent,
+              disableTextAlign: args.disableTextAlign ?? disableTextAlign,
+              nodes: args.nodes,
+              parent: args.parent ?? {
+                ...node,
+                parent
+              },
+              populate
+            });
+          },
+          parent,
+          providedCSSString,
+          providedStyleTag
+        }) : converterForNode;
+        nodeHTML = converted;
+      } else {
+        nodeHTML = '<span>unknown node</span>';
+      }
+      htmlArray.push(nodeHTML);
+    } catch (error) {
+      console.error('Error converting lexical node to HTML:', error, 'node:', node);
+      htmlArray.push('');
     }
-    return htmlArray.filter(Boolean);
+  }
+  return htmlArray.filter(Boolean);
 }
-
 //# sourceMappingURL=index.js.map

package/dist/features/converters/lexicalToHtml/async/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToHtml/async/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-console */\nimport type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\nimport type {\n  HTMLConverterAsync,\n  HTMLConvertersAsync,\n  HTMLConvertersFunctionAsync,\n  HTMLPopulateFn,\n} from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\nimport { findConverterForNode } from '../shared/findConverterForNode.js'\nimport { defaultHTMLConvertersAsync } from './defaultConverters.js'\n\nexport type ConvertLexicalToHTMLAsyncArgs = {\n  /**\n   * Override class names for the container.\n   */\n  className?: string\n  converters?: HTMLConvertersAsync | HTMLConvertersFunctionAsync\n  data: SerializedEditorState\n  /**\n   * If true, removes the container div wrapper.\n   */\n  disableContainer?: boolean\n  /**\n   * If true, disables indentation globally. If an array, disables for specific node `type` values.\n   */\n  disableIndent?: boolean | string[]\n  /**\n   * If true, disables text alignment globally. If an array, disables for specific node `type` values.\n   */\n  disableTextAlign?: boolean | string[]\n  populate?: HTMLPopulateFn\n}\n\nexport async function convertLexicalToHTMLAsync({\n  className,\n  converters,\n  data,\n  disableContainer,\n  disableIndent,\n  disableTextAlign,\n  populate,\n}: ConvertLexicalToHTMLAsyncArgs): Promise<string> {\n  if (hasText(data)) {\n    let finalConverters: HTMLConvertersAsync = {}\n    if (converters) {\n      if (typeof converters === 'function') {\n        finalConverters = converters({ defaultConverters: defaultHTMLConvertersAsync })\n      } else {\n        finalConverters = converters\n      }\n    } else {\n      finalConverters = defaultHTMLConvertersAsync\n    }\n\n    const html = (\n      await convertLexicalNodesToHTMLAsync({\n        converters: finalConverters,\n        disableIndent,\n        disableTextAlign,\n        nodes: data?.root?.children,\n        parent: data?.root,\n        populate,\n      })\n    ).join('')\n\n    if (disableContainer) {\n      return html\n    } else {\n      return `<div class=\"${className ?? 'payload-richtext'}\">${html}</div>`\n    }\n  }\n  if (disableContainer) {\n    return ''\n  } else {\n    return `<div class=\"${className ?? 'payload-richtext'}\"></div>`\n  }\n}\n\nexport async function convertLexicalNodesToHTMLAsync({\n  converters,\n  disableIndent,\n  disableTextAlign,\n  nodes,\n  parent,\n  populate,\n}: {\n  converters: HTMLConvertersAsync\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n  populate?: HTMLPopulateFn\n}): Promise<string[]> {\n  const unknownConverter: HTMLConverterAsync<any> = converters.unknown as HTMLConverterAsync<any>\n\n  const htmlArray: string[] = []\n\n  let i = -1\n  for (const node of nodes) {\n    i++\n    const { converterForNode, providedCSSString, providedStyleTag } = findConverterForNode({\n      converters,\n      disableIndent,\n      disableTextAlign,\n      node,\n      unknownConverter,\n    })\n\n    try {\n      let nodeHTML: string\n\n      if (converterForNode) {\n        const converted =\n          typeof converterForNode === 'function'\n            ? await converterForNode({\n                childIndex: i,\n                converters,\n                node,\n                populate,\n\n                nodesToHTML: async (args) => {\n                  return await convertLexicalNodesToHTMLAsync({\n                    converters: args.converters ?? converters,\n                    disableIndent: args.disableIndent ?? disableIndent,\n                    disableTextAlign: args.disableTextAlign ?? disableTextAlign,\n                    nodes: args.nodes,\n                    parent: args.parent ?? {\n                      ...node,\n                      parent,\n                    },\n                    populate,\n                  })\n                },\n                parent,\n                providedCSSString,\n                providedStyleTag,\n              })\n            : converterForNode\n        nodeHTML = converted\n      } else {\n        nodeHTML = '<span>unknown node</span>'\n      }\n\n      htmlArray.push(nodeHTML)\n    } catch (error) {\n      console.error('Error converting lexical node to HTML:', error, 'node:', node)\n      htmlArray.push('')\n    }\n  }\n\n  return htmlArray.filter(Boolean)\n}\n"],"names":["hasText","findConverterForNode","defaultHTMLConvertersAsync","convertLexicalToHTMLAsync","className","converters","data","disableContainer","disableIndent","disableTextAlign","populate","finalConverters","defaultConverters","html","convertLexicalNodesToHTMLAsync","nodes","root","children","parent","join","unknownConverter","unknown","htmlArray","i","node","converterForNode","providedCSSString","providedStyleTag","nodeHTML","converted","childIndex","nodesToHTML","args","push","error","console","filter","Boolean"],"mappings":"AAAA,qDAAqD,GACrD,6BAA6B,GAW7B,SAASA,OAAO,QAAQ,kCAAiC;AACzD,SAASC,oBAAoB,QAAQ,oCAAmC;AACxE,SAASC,0BAA0B,QAAQ,yBAAwB;AAGjE;;GAEC,GAID;;GAEC,GAED;;GAEC,GAED;;GAEC,GAKH,OAAO,eAAeC,0BAA0B,EAC9CC,SAAS,EACTC,UAAU,EACVC,IAAI,EACJC,gBAAgB,EAChBC,aAAa,EACbC,gBAAgB,EAChBC,QAAQ,EACsB;IAC9B,IAAIV,QAAQM,OAAO;QACjB,IAAIK,kBAAuC,CAAC;QAC5C,IAAIN,YAAY;YACd,IAAI,OAAOA,eAAe,YAAY;gBACpCM,kBAAkBN,WAAW;oBAAEO,mBAAmBV;gBAA2B;YAC/E,OAAO;gBACLS,kBAAkBN;YACpB;QACF,OAAO;YACLM,kBAAkBT;QACpB;QAEA,MAAMW,OAAO,AACX,CAAA,MAAMC,+BAA+B;YACnCT,YAAYM;YACZH;YACAC;YACAM,OAAOT,MAAMU,MAAMC;YACnBC,QAAQZ,MAAMU;YACdN;QACF,EAAC,EACDS,IAAI,CAAC;QAEP,IAAIZ,kBAAkB;YACpB,OAAOM;QACT,OAAO;YACL,OAAO,CAAC,YAAY,EAAET,aAAa,mBAAmB,EAAE,EAAES,KAAK,MAAM,CAAC;QACxE;IACF;IACA,IAAIN,kBAAkB;QACpB,OAAO;IACT,OAAO;QACL,OAAO,CAAC,YAAY,EAAEH,aAAa,mBAAmB,QAAQ,CAAC;IACjE;AACF;AAEA,OAAO,eAAeU,+BAA+B,EACnDT,UAAU,EACVG,aAAa,EACbC,gBAAgB,EAChBM,KAAK,EACLG,MAAM,EACNR,QAAQ,EAQT;IACC,MAAMU,mBAA4Cf,WAAWgB,OAAO;IAEpE,MAAMC,YAAsB,EAAE;IAE9B,IAAIC,IAAI,CAAC;IACT,KAAK,MAAMC,QAAQT,MAAO;QACxBQ;QACA,MAAM,EAAEE,gBAAgB,EAAEC,iBAAiB,EAAEC,gBAAgB,EAAE,GAAG1B,qBAAqB;YACrFI;YACAG;YACAC;YACAe;YACAJ;QACF;QAEA,IAAI;YACF,IAAIQ;YAEJ,IAAIH,kBAAkB;gBACpB,MAAMI,YACJ,OAAOJ,qBAAqB,aACxB,MAAMA,iBAAiB;oBACrBK,YAAYP;oBACZlB;oBACAmB;oBACAd;oBAEAqB,aAAa,OAAOC;wBAClB,OAAO,MAAMlB,+BAA+B;4BAC1CT,YAAY2B,KAAK3B,UAAU,IAAIA;4BAC/BG,eAAewB,KAAKxB,aAAa,IAAIA;4BACrCC,kBAAkBuB,KAAKvB,gBAAgB,IAAIA;4BAC3CM,OAAOiB,KAAKjB,KAAK;4BACjBG,QAAQc,KAAKd,MAAM,IAAI;gCACrB,GAAGM,IAAI;gCACPN;4BACF;4BACAR;wBACF;oBACF;oBACAQ;oBACAQ;oBACAC;gBACF,KACAF;gBACNG,WAAWC;YACb,OAAO;gBACLD,WAAW;YACb;YAEAN,UAAUW,IAAI,CAACL;QACjB,EAAE,OAAOM,OAAO;YACdC,QAAQD,KAAK,CAAC,0CAA0CA,OAAO,SAASV;YACxEF,UAAUW,IAAI,CAAC;QACjB;IACF;IAEA,OAAOX,UAAUc,MAAM,CAACC;AAC1B"}
+{"version":3,"file":"index.js","names":["hasText","findConverterForNode","defaultHTMLConvertersAsync","convertLexicalToHTMLAsync","className","converters","data","disableContainer","disableIndent","disableTextAlign","populate","finalConverters","defaultConverters","html","convertLexicalNodesToHTMLAsync","nodes","root","children","parent","join","unknownConverter","unknown","htmlArray","i","node","converterForNode","providedCSSString","providedStyleTag","nodeHTML","converted","childIndex","nodesToHTML","args","push","error","console","filter","Boolean"],"sources":["../../../../../src/features/converters/lexicalToHtml/async/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-console */\nimport type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\nimport type {\n  HTMLConverterAsync,\n  HTMLConvertersAsync,\n  HTMLConvertersFunctionAsync,\n  HTMLPopulateFn,\n} from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\nimport { findConverterForNode } from '../shared/findConverterForNode.js'\nimport { defaultHTMLConvertersAsync } from './defaultConverters.js'\n\nexport type ConvertLexicalToHTMLAsyncArgs = {\n  /**\n   * Override class names for the container.\n   */\n  className?: string\n  converters?: HTMLConvertersAsync | HTMLConvertersFunctionAsync\n  data: SerializedEditorState\n  /**\n   * If true, removes the container div wrapper.\n   */\n  disableContainer?: boolean\n  /**\n   * If true, disables indentation globally. If an array, disables for specific node `type` values.\n   */\n  disableIndent?: boolean | string[]\n  /**\n   * If true, disables text alignment globally. If an array, disables for specific node `type` values.\n   */\n  disableTextAlign?: boolean | string[]\n  populate?: HTMLPopulateFn\n}\n\nexport async function convertLexicalToHTMLAsync({\n  className,\n  converters,\n  data,\n  disableContainer,\n  disableIndent,\n  disableTextAlign,\n  populate,\n}: ConvertLexicalToHTMLAsyncArgs): Promise<string> {\n  if (hasText(data)) {\n    let finalConverters: HTMLConvertersAsync = {}\n    if (converters) {\n      if (typeof converters === 'function') {\n        finalConverters = converters({ defaultConverters: defaultHTMLConvertersAsync })\n      } else {\n        finalConverters = converters\n      }\n    } else {\n      finalConverters = defaultHTMLConvertersAsync\n    }\n\n    const html = (\n      await convertLexicalNodesToHTMLAsync({\n        converters: finalConverters,\n        disableIndent,\n        disableTextAlign,\n        nodes: data?.root?.children,\n        parent: data?.root,\n        populate,\n      })\n    ).join('')\n\n    if (disableContainer) {\n      return html\n    } else {\n      return `<div class=\"${className ?? 'payload-richtext'}\">${html}</div>`\n    }\n  }\n  if (disableContainer) {\n    return ''\n  } else {\n    return `<div class=\"${className ?? 'payload-richtext'}\"></div>`\n  }\n}\n\nexport async function convertLexicalNodesToHTMLAsync({\n  converters,\n  disableIndent,\n  disableTextAlign,\n  nodes,\n  parent,\n  populate,\n}: {\n  converters: HTMLConvertersAsync\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n  populate?: HTMLPopulateFn\n}): Promise<string[]> {\n  const unknownConverter: HTMLConverterAsync<any> = converters.unknown as HTMLConverterAsync<any>\n\n  const htmlArray: string[] = []\n\n  let i = -1\n  for (const node of nodes) {\n    i++\n    const { converterForNode, providedCSSString, providedStyleTag } = findConverterForNode({\n      converters,\n      disableIndent,\n      disableTextAlign,\n      node,\n      unknownConverter,\n    })\n\n    try {\n      let nodeHTML: string\n\n      if (converterForNode) {\n        const converted =\n          typeof converterForNode === 'function'\n            ? await converterForNode({\n                childIndex: i,\n                converters,\n                node,\n                populate,\n\n                nodesToHTML: async (args) => {\n                  return await convertLexicalNodesToHTMLAsync({\n                    converters: args.converters ?? converters,\n                    disableIndent: args.disableIndent ?? disableIndent,\n                    disableTextAlign: args.disableTextAlign ?? disableTextAlign,\n                    nodes: args.nodes,\n                    parent: args.parent ?? {\n                      ...node,\n                      parent,\n                    },\n                    populate,\n                  })\n                },\n                parent,\n                providedCSSString,\n                providedStyleTag,\n              })\n            : converterForNode\n        nodeHTML = converted\n      } else {\n        nodeHTML = '<span>unknown node</span>'\n      }\n\n      htmlArray.push(nodeHTML)\n    } catch (error) {\n      console.error('Error converting lexical node to HTML:', error, 'node:', node)\n      htmlArray.push('')\n    }\n  }\n\n  return htmlArray.filter(Boolean)\n}\n"],"mappings":"AAAA,wDACA,+BAWA,SAASA,OAAO,QAAQ;AACxB,SAASC,oBAAoB,QAAQ;AACrC,SAASC,0BAA0B,QAAQ;AAwB3C,OAAO,eAAeC,0BAA0B;EAC9CC,SAAS;EACTC,UAAU;EACVC,IAAI;EACJC,gBAAgB;EAChBC,aAAa;EACbC,gBAAgB;EAChBC;AAAQ,CACsB;EAC9B,IAAIV,OAAA,CAAQM,IAAA,GAAO;IACjB,IAAIK,eAAA,GAAuC,CAAC;IAC5C,IAAIN,UAAA,EAAY;MACd,IAAI,OAAOA,UAAA,KAAe,YAAY;QACpCM,eAAA,GAAkBN,UAAA,CAAW;UAAEO,iBAAA,EAAmBV;QAA2B;MAC/E,OAAO;QACLS,eAAA,GAAkBN,UAAA;MACpB;IACF,OAAO;MACLM,eAAA,GAAkBT,0BAAA;IACpB;IAEA,MAAMW,IAAA,GAAO,CACX,MAAMC,8BAAA,CAA+B;MACnCT,UAAA,EAAYM,eAAA;MACZH,aAAA;MACAC,gBAAA;MACAM,KAAA,EAAOT,IAAA,EAAMU,IAAA,EAAMC,QAAA;MACnBC,MAAA,EAAQZ,IAAA,EAAMU,IAAA;MACdN;IACF,EAAC,EACDS,IAAI,CAAC;IAEP,IAAIZ,gBAAA,EAAkB;MACpB,OAAOM,IAAA;IACT,OAAO;MACL,OAAO,eAAeT,SAAA,IAAa,uBAAuBS,IAAA,QAAY;IACxE;EACF;EACA,IAAIN,gBAAA,EAAkB;IACpB,OAAO;EACT,OAAO;IACL,OAAO,eAAeH,SAAA,IAAa,4BAA4B;EACjE;AACF;AAEA,OAAO,eAAeU,+BAA+B;EACnDT,UAAU;EACVG,aAAa;EACbC,gBAAgB;EAChBM,KAAK;EACLG,MAAM;EACNR;AAAQ,CAQT;EACC,MAAMU,gBAAA,GAA4Cf,UAAA,CAAWgB,OAAO;EAEpE,MAAMC,SAAA,GAAsB,EAAE;EAE9B,IAAIC,CAAA,GAAI,CAAC;EACT,KAAK,MAAMC,IAAA,IAAQT,KAAA,EAAO;IACxBQ,CAAA;IACA,MAAM;MAAEE,gBAAgB;MAAEC,iBAAiB;MAAEC;IAAgB,CAAE,GAAG1B,oBAAA,CAAqB;MACrFI,UAAA;MACAG,aAAA;MACAC,gBAAA;MACAe,IAAA;MACAJ;IACF;IAEA,IAAI;MACF,IAAIQ,QAAA;MAEJ,IAAIH,gBAAA,EAAkB;QACpB,MAAMI,SAAA,GACJ,OAAOJ,gBAAA,KAAqB,aACxB,MAAMA,gBAAA,CAAiB;UACrBK,UAAA,EAAYP,CAAA;UACZlB,UAAA;UACAmB,IAAA;UACAd,QAAA;UAEAqB,WAAA,EAAa,MAAOC,IAAA;YAClB,OAAO,MAAMlB,8BAAA,CAA+B;cAC1CT,UAAA,EAAY2B,IAAA,CAAK3B,UAAU,IAAIA,UAAA;cAC/BG,aAAA,EAAewB,IAAA,CAAKxB,aAAa,IAAIA,aAAA;cACrCC,gBAAA,EAAkBuB,IAAA,CAAKvB,gBAAgB,IAAIA,gBAAA;cAC3CM,KAAA,EAAOiB,IAAA,CAAKjB,KAAK;cACjBG,MAAA,EAAQc,IAAA,CAAKd,MAAM,IAAI;gBACrB,GAAGM,IAAI;gBACPN;cACF;cACAR;YACF;UACF;UACAQ,MAAA;UACAQ,iBAAA;UACAC;QACF,KACAF,gBAAA;QACNG,QAAA,GAAWC,SAAA;MACb,OAAO;QACLD,QAAA,GAAW;MACb;MAEAN,SAAA,CAAUW,IAAI,CAACL,QAAA;IACjB,EAAE,OAAOM,KAAA,EAAO;MACdC,OAAA,CAAQD,KAAK,CAAC,0CAA0CA,KAAA,EAAO,SAASV,IAAA;MACxEF,SAAA,CAAUW,IAAI,CAAC;IACjB;EACF;EAEA,OAAOX,SAAA,CAAUc,MAAM,CAACC,OAAA;AAC1B","ignoreList":[]}

package/dist/features/converters/lexicalToHtml/async/types.js

@@ -1,5 +1,2 @@
-// need these to ensure types for blocks and inlineBlocks work if no generics are provided
-// need these to ensure types for blocks and inlineBlocks work if no generics are provided
-export { };
-
+export {};
 //# sourceMappingURL=types.js.map

package/dist/features/converters/lexicalToHtml/async/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToHtml/async/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type { SelectType, TypeWithID } from 'payload'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\nexport type HTMLPopulateArguments = {\n  collectionSlug: string\n  id: number | string\n  select?: SelectType\n}\n\nexport type HTMLPopulateFn = <TData extends object = TypeWithID>(\n  args: HTMLPopulateArguments,\n) => Promise<TData | undefined>\n\nexport type HTMLConverterAsync<\n  T extends { [key: string]: any; type?: string } = SerializedLexicalNode,\n> =\n  | ((args: {\n      childIndex: number\n      converters: HTMLConvertersAsync\n      node: T\n      nodesToHTML: (args: {\n        converters?: HTMLConvertersAsync\n        disableIndent?: boolean | string[]\n        disableTextAlign?: boolean | string[]\n        nodes: SerializedLexicalNode[]\n        parent?: SerializedLexicalNodeWithParent\n      }) => Promise<string[]>\n      parent: SerializedLexicalNodeWithParent\n      populate?: HTMLPopulateFn\n      providedCSSString: string\n      providedStyleTag: string\n    }) => Promise<string> | string)\n  | string\n\nexport type HTMLConvertersAsync<\n  T extends { [key: string]: any; type?: string } =\n    | DefaultNodeTypes\n    | SerializedBlockNode<{ blockName?: null | string; blockType: string }> // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n    | SerializedInlineBlockNode<{ blockName?: null | string; blockType: string }>, // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n> = {\n  [key: string]:\n    | {\n        [blockSlug: string]: HTMLConverterAsync<any>\n      }\n    | HTMLConverterAsync<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: HTMLConverterAsync<\n    Extract<T, { type: nodeType }>\n  >\n} & {\n  blocks?: {\n    [K in Extract<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: HTMLConverterAsync<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? SerializedBlockNode<Extract<B, { blockType: K }>>\n        : SerializedBlockNode\n    >\n  }\n  inlineBlocks?: {\n    [K in Extract<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: HTMLConverterAsync<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n  unknown?: HTMLConverterAsync<SerializedLexicalNode>\n}\n\nexport type HTMLConvertersFunctionAsync<\n  T extends { [key: string]: any; type?: string } =\n    | DefaultNodeTypes\n    | SerializedBlockNode<{ blockName?: null | string }>\n    | SerializedInlineBlockNode<{ blockName?: null | string; blockType: string }>,\n> = (args: { defaultConverters: HTMLConvertersAsync<DefaultNodeTypes> }) => HTMLConvertersAsync<T>\n"],"names":[],"mappings":"AA2C4E,0FAA0F;AACnF,0FAA0F;AA4C7K,WAKkG"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToHtml/async/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type { SelectType, TypeWithID } from 'payload'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\nexport type HTMLPopulateArguments = {\n  collectionSlug: string\n  id: number | string\n  select?: SelectType\n}\n\nexport type HTMLPopulateFn = <TData extends object = TypeWithID>(\n  args: HTMLPopulateArguments,\n) => Promise<TData | undefined>\n\nexport type HTMLConverterAsync<\n  T extends { [key: string]: any; type?: string } = SerializedLexicalNode,\n> =\n  | ((args: {\n      childIndex: number\n      converters: HTMLConvertersAsync\n      node: T\n      nodesToHTML: (args: {\n        converters?: HTMLConvertersAsync\n        disableIndent?: boolean | string[]\n        disableTextAlign?: boolean | string[]\n        nodes: SerializedLexicalNode[]\n        parent?: SerializedLexicalNodeWithParent\n      }) => Promise<string[]>\n      parent: SerializedLexicalNodeWithParent\n      populate?: HTMLPopulateFn\n      providedCSSString: string\n      providedStyleTag: string\n    }) => Promise<string> | string)\n  | string\n\nexport type HTMLConvertersAsync<\n  T extends { [key: string]: any; type?: string } =\n    | DefaultNodeTypes\n    | SerializedBlockNode<{ blockName?: null | string; blockType: string }> // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n    | SerializedInlineBlockNode<{ blockName?: null | string; blockType: string }>, // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n> = {\n  [key: string]:\n    | {\n        [blockSlug: string]: HTMLConverterAsync<any>\n      }\n    | HTMLConverterAsync<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: HTMLConverterAsync<\n    Extract<T, { type: nodeType }>\n  >\n} & {\n  blocks?: {\n    [K in Extract<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: HTMLConverterAsync<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? SerializedBlockNode<Extract<B, { blockType: K }>>\n        : SerializedBlockNode\n    >\n  }\n  inlineBlocks?: {\n    [K in Extract<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: HTMLConverterAsync<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n  unknown?: HTMLConverterAsync<SerializedLexicalNode>\n}\n\nexport type HTMLConvertersFunctionAsync<\n  T extends { [key: string]: any; type?: string } =\n    | DefaultNodeTypes\n    | SerializedBlockNode<{ blockName?: null | string }>\n    | SerializedInlineBlockNode<{ blockName?: null | string; blockType: string }>,\n> = (args: { defaultConverters: HTMLConvertersAsync<DefaultNodeTypes> }) => HTMLConvertersAsync<T>\n"],"mappings":"AAwFA","ignoreList":[]}

package/dist/features/converters/lexicalToHtml/shared/findConverterForNode.js

@@ -1,63 +1,68 @@
-/* eslint-disable no-console */ export function findConverterForNode({ converters, disableIndent, disableTextAlign, node, unknownConverter }) {
-    let converterForNode;
-    if (node.type === 'block') {
-        converterForNode = converters?.blocks?.[node?.fields?.blockType];
-        if (!converterForNode && !unknownConverter) {
-            console.error(`Lexical => HTML converter: Blocks converter: found ${node?.fields?.blockType} block, but no converter is provided`);
-        }
-    } else if (node.type === 'inlineBlock') {
-        converterForNode = converters?.inlineBlocks?.[node?.fields?.blockType];
-        if (!converterForNode && !unknownConverter) {
-            console.error(`Lexical => HTML converter: Inline Blocks converter: found ${node?.fields?.blockType} inline block, but no converter is provided`);
-        }
-    } else {
-        converterForNode = converters[node.type];
+/* eslint-disable no-console */export function findConverterForNode({
+  converters,
+  disableIndent,
+  disableTextAlign,
+  node,
+  unknownConverter
+}) {
+  let converterForNode;
+  if (node.type === 'block') {
+    converterForNode = converters?.blocks?.[node?.fields?.blockType];
+    if (!converterForNode && !unknownConverter) {
+      console.error(`Lexical => HTML converter: Blocks converter: found ${node?.fields?.blockType} block, but no converter is provided`);
     }
-    const style = {};
-    // Check if disableTextAlign is not true and does not include node type
-    if (!disableTextAlign && (!Array.isArray(disableTextAlign) || !disableTextAlign?.includes(node.type))) {
-        if ('format' in node && node.format) {
-            switch(node.format){
-                case 'center':
-                    style['text-align'] = 'center';
-                    break;
-                case 'end':
-                    style['text-align'] = 'right';
-                    break;
-                case 'justify':
-                    style['text-align'] = 'justify';
-                    break;
-                case 'left':
-                    break;
-                case 'right':
-                    style['text-align'] = 'right';
-                    break;
-                case 'start':
-                    style['text-align'] = 'left';
-                    break;
-            }
-        }
+  } else if (node.type === 'inlineBlock') {
+    converterForNode = converters?.inlineBlocks?.[node?.fields?.blockType];
+    if (!converterForNode && !unknownConverter) {
+      console.error(`Lexical => HTML converter: Inline Blocks converter: found ${node?.fields?.blockType} inline block, but no converter is provided`);
     }
-    if (!disableIndent && (!Array.isArray(disableIndent) || !disableIndent?.includes(node.type))) {
-        if ('indent' in node && node.indent && node.type !== 'listitem') {
-            // the unit should be px. Do not change it to rem, em, or something else.
-            // The quantity should be 40px. Do not change it either.
-            // See rationale in
-            // https://github.com/payloadcms/payload/issues/13130#issuecomment-3058348085
-            style['padding-inline-start'] = `${Number(node.indent) * 40}px`;
-        }
+  } else {
+    converterForNode = converters[node.type];
+  }
+  const style = {};
+  // Check if disableTextAlign is not true and does not include node type
+  if (!disableTextAlign && (!Array.isArray(disableTextAlign) || !disableTextAlign?.includes(node.type))) {
+    if ('format' in node && node.format) {
+      switch (node.format) {
+        case 'center':
+          style['text-align'] = 'center';
+          break;
+        case 'end':
+          style['text-align'] = 'right';
+          break;
+        case 'justify':
+          style['text-align'] = 'justify';
+          break;
+        case 'left':
+          break;
+        case 'right':
+          style['text-align'] = 'right';
+          break;
+        case 'start':
+          style['text-align'] = 'left';
+          break;
+      }
     }
-    let providedCSSString = '';
-    for (const key of Object.keys(style)){
-        // @ts-expect-error we're iterating over the keys of the object
-        providedCSSString += `${key}: ${style[key]};`;
+  }
+  if (!disableIndent && (!Array.isArray(disableIndent) || !disableIndent?.includes(node.type))) {
+    if ('indent' in node && node.indent && node.type !== 'listitem') {
+      // the unit should be px. Do not change it to rem, em, or something else.
+      // The quantity should be 40px. Do not change it either.
+      // See rationale in
+      // https://github.com/payloadcms/payload/issues/13130#issuecomment-3058348085
+      style['padding-inline-start'] = `${Number(node.indent) * 40}px`;
     }
-    const providedStyleTag = providedCSSString?.length ? ` style="${providedCSSString}"` : '';
-    return {
-        converterForNode: converterForNode ?? unknownConverter,
-        providedCSSString,
-        providedStyleTag
-    };
+  }
+  let providedCSSString = '';
+  for (const key of Object.keys(style)) {
+    // @ts-expect-error we're iterating over the keys of the object
+    providedCSSString += `${key}: ${style[key]};`;
+  }
+  const providedStyleTag = providedCSSString?.length ? ` style="${providedCSSString}"` : '';
+  return {
+    converterForNode: converterForNode ?? unknownConverter,
+    providedCSSString,
+    providedStyleTag
+  };
 }
-
 //# sourceMappingURL=findConverterForNode.js.map

package/dist/features/converters/lexicalToHtml/shared/findConverterForNode.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToHtml/shared/findConverterForNode.ts"],"sourcesContent":["/* eslint-disable no-console */\nimport type { SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js'\nimport type { HTMLConverterAsync, HTMLConvertersAsync } from '../async/types.js'\nimport type { HTMLConverter, HTMLConverters } from '../sync/types.js'\nimport type { ProvidedCSS } from './types.js'\n\nexport function findConverterForNode<\n  TConverters extends HTMLConverters | HTMLConvertersAsync,\n  TConverter extends HTMLConverter | HTMLConverterAsync,\n>({\n  converters,\n  disableIndent,\n  disableTextAlign,\n  node,\n  unknownConverter,\n}: {\n  converters: TConverters\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n  node: SerializedLexicalNode\n  unknownConverter: TConverter\n}): {\n  converterForNode: TConverter | undefined\n  providedCSSString: string\n  providedStyleTag: string\n} {\n  let converterForNode: TConverter | undefined\n  if (node.type === 'block') {\n    converterForNode = converters?.blocks?.[\n      (node as SerializedBlockNode)?.fields?.blockType\n    ] as TConverter\n    if (!converterForNode && !unknownConverter) {\n      console.error(\n        `Lexical => HTML converter: Blocks converter: found ${(node as SerializedBlockNode)?.fields?.blockType} block, but no converter is provided`,\n      )\n    }\n  } else if (node.type === 'inlineBlock') {\n    converterForNode = converters?.inlineBlocks?.[\n      (node as SerializedInlineBlockNode)?.fields?.blockType\n    ] as TConverter\n    if (!converterForNode && !unknownConverter) {\n      console.error(\n        `Lexical => HTML converter: Inline Blocks converter: found ${(node as SerializedInlineBlockNode)?.fields?.blockType} inline block, but no converter is provided`,\n      )\n    }\n  } else {\n    converterForNode = converters[node.type] as TConverter\n  }\n\n  const style: ProvidedCSS = {}\n\n  // Check if disableTextAlign is not true and does not include node type\n  if (\n    !disableTextAlign &&\n    (!Array.isArray(disableTextAlign) || !disableTextAlign?.includes(node.type))\n  ) {\n    if ('format' in node && node.format) {\n      switch (node.format) {\n        case 'center':\n          style['text-align'] = 'center'\n          break\n        case 'end':\n          style['text-align'] = 'right'\n          break\n        case 'justify':\n          style['text-align'] = 'justify'\n          break\n        case 'left':\n          //style['text-align'] = 'left'\n          // Do nothing, as left is the default\n          break\n        case 'right':\n          style['text-align'] = 'right'\n          break\n        case 'start':\n          style['text-align'] = 'left'\n          break\n      }\n    }\n  }\n\n  if (!disableIndent && (!Array.isArray(disableIndent) || !disableIndent?.includes(node.type))) {\n    if ('indent' in node && node.indent && node.type !== 'listitem') {\n      // the unit should be px. Do not change it to rem, em, or something else.\n      // The quantity should be 40px. Do not change it either.\n      // See rationale in\n      // https://github.com/payloadcms/payload/issues/13130#issuecomment-3058348085\n      style['padding-inline-start'] = `${Number(node.indent) * 40}px`\n    }\n  }\n\n  let providedCSSString: string = ''\n  for (const key of Object.keys(style)) {\n    // @ts-expect-error we're iterating over the keys of the object\n    providedCSSString += `${key}: ${style[key]};`\n  }\n  const providedStyleTag = providedCSSString?.length ? ` style=\"${providedCSSString}\"` : ''\n\n  return {\n    converterForNode: converterForNode ?? unknownConverter,\n    providedCSSString,\n    providedStyleTag,\n  }\n}\n"],"names":["findConverterForNode","converters","disableIndent","disableTextAlign","node","unknownConverter","converterForNode","type","blocks","fields","blockType","console","error","inlineBlocks","style","Array","isArray","includes","format","indent","Number","providedCSSString","key","Object","keys","providedStyleTag","length"],"mappings":"AAAA,6BAA6B,GAQ7B,OAAO,SAASA,qBAGd,EACAC,UAAU,EACVC,aAAa,EACbC,gBAAgB,EAChBC,IAAI,EACJC,gBAAgB,EAOjB;IAKC,IAAIC;IACJ,IAAIF,KAAKG,IAAI,KAAK,SAAS;QACzBD,mBAAmBL,YAAYO,QAAQ,CACpCJ,MAA8BK,QAAQC,UACxC;QACD,IAAI,CAACJ,oBAAoB,CAACD,kBAAkB;YAC1CM,QAAQC,KAAK,CACX,CAAC,mDAAmD,EAAGR,MAA8BK,QAAQC,UAAU,oCAAoC,CAAC;QAEhJ;IACF,OAAO,IAAIN,KAAKG,IAAI,KAAK,eAAe;QACtCD,mBAAmBL,YAAYY,cAAc,CAC1CT,MAAoCK,QAAQC,UAC9C;QACD,IAAI,CAACJ,oBAAoB,CAACD,kBAAkB;YAC1CM,QAAQC,KAAK,CACX,CAAC,0DAA0D,EAAGR,MAAoCK,QAAQC,UAAU,2CAA2C,CAAC;QAEpK;IACF,OAAO;QACLJ,mBAAmBL,UAAU,CAACG,KAAKG,IAAI,CAAC;IAC1C;IAEA,MAAMO,QAAqB,CAAC;IAE5B,uEAAuE;IACvE,IACE,CAACX,oBACA,CAAA,CAACY,MAAMC,OAAO,CAACb,qBAAqB,CAACA,kBAAkBc,SAASb,KAAKG,IAAI,CAAA,GAC1E;QACA,IAAI,YAAYH,QAAQA,KAAKc,MAAM,EAAE;YACnC,OAAQd,KAAKc,MAAM;gBACjB,KAAK;oBACHJ,KAAK,CAAC,aAAa,GAAG;oBACtB;gBACF,KAAK;oBACHA,KAAK,CAAC,aAAa,GAAG;oBACtB;gBACF,KAAK;oBACHA,KAAK,CAAC,aAAa,GAAG;oBACtB;gBACF,KAAK;oBAGH;gBACF,KAAK;oBACHA,KAAK,CAAC,aAAa,GAAG;oBACtB;gBACF,KAAK;oBACHA,KAAK,CAAC,aAAa,GAAG;oBACtB;YACJ;QACF;IACF;IAEA,IAAI,CAACZ,iBAAkB,CAAA,CAACa,MAAMC,OAAO,CAACd,kBAAkB,CAACA,eAAee,SAASb,KAAKG,IAAI,CAAA,GAAI;QAC5F,IAAI,YAAYH,QAAQA,KAAKe,MAAM,IAAIf,KAAKG,IAAI,KAAK,YAAY;YAC/D,yEAAyE;YACzE,wDAAwD;YACxD,mBAAmB;YACnB,6EAA6E;YAC7EO,KAAK,CAAC,uBAAuB,GAAG,GAAGM,OAAOhB,KAAKe,MAAM,IAAI,GAAG,EAAE,CAAC;QACjE;IACF;IAEA,IAAIE,oBAA4B;IAChC,KAAK,MAAMC,OAAOC,OAAOC,IAAI,CAACV,OAAQ;QACpC,+DAA+D;QAC/DO,qBAAqB,GAAGC,IAAI,EAAE,EAAER,KAAK,CAACQ,IAAI,CAAC,CAAC,CAAC;IAC/C;IACA,MAAMG,mBAAmBJ,mBAAmBK,SAAS,CAAC,QAAQ,EAAEL,kBAAkB,CAAC,CAAC,GAAG;IAEvF,OAAO;QACLf,kBAAkBA,oBAAoBD;QACtCgB;QACAI;IACF;AACF"}
+{"version":3,"file":"findConverterForNode.js","names":["findConverterForNode","converters","disableIndent","disableTextAlign","node","unknownConverter","converterForNode","type","blocks","fields","blockType","console","error","inlineBlocks","style","Array","isArray","includes","format","indent","Number","providedCSSString","key","Object","keys","providedStyleTag","length"],"sources":["../../../../../src/features/converters/lexicalToHtml/shared/findConverterForNode.ts"],"sourcesContent":["/* eslint-disable no-console */\nimport type { SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js'\nimport type { HTMLConverterAsync, HTMLConvertersAsync } from '../async/types.js'\nimport type { HTMLConverter, HTMLConverters } from '../sync/types.js'\nimport type { ProvidedCSS } from './types.js'\n\nexport function findConverterForNode<\n  TConverters extends HTMLConverters | HTMLConvertersAsync,\n  TConverter extends HTMLConverter | HTMLConverterAsync,\n>({\n  converters,\n  disableIndent,\n  disableTextAlign,\n  node,\n  unknownConverter,\n}: {\n  converters: TConverters\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n  node: SerializedLexicalNode\n  unknownConverter: TConverter\n}): {\n  converterForNode: TConverter | undefined\n  providedCSSString: string\n  providedStyleTag: string\n} {\n  let converterForNode: TConverter | undefined\n  if (node.type === 'block') {\n    converterForNode = converters?.blocks?.[\n      (node as SerializedBlockNode)?.fields?.blockType\n    ] as TConverter\n    if (!converterForNode && !unknownConverter) {\n      console.error(\n        `Lexical => HTML converter: Blocks converter: found ${(node as SerializedBlockNode)?.fields?.blockType} block, but no converter is provided`,\n      )\n    }\n  } else if (node.type === 'inlineBlock') {\n    converterForNode = converters?.inlineBlocks?.[\n      (node as SerializedInlineBlockNode)?.fields?.blockType\n    ] as TConverter\n    if (!converterForNode && !unknownConverter) {\n      console.error(\n        `Lexical => HTML converter: Inline Blocks converter: found ${(node as SerializedInlineBlockNode)?.fields?.blockType} inline block, but no converter is provided`,\n      )\n    }\n  } else {\n    converterForNode = converters[node.type] as TConverter\n  }\n\n  const style: ProvidedCSS = {}\n\n  // Check if disableTextAlign is not true and does not include node type\n  if (\n    !disableTextAlign &&\n    (!Array.isArray(disableTextAlign) || !disableTextAlign?.includes(node.type))\n  ) {\n    if ('format' in node && node.format) {\n      switch (node.format) {\n        case 'center':\n          style['text-align'] = 'center'\n          break\n        case 'end':\n          style['text-align'] = 'right'\n          break\n        case 'justify':\n          style['text-align'] = 'justify'\n          break\n        case 'left':\n          //style['text-align'] = 'left'\n          // Do nothing, as left is the default\n          break\n        case 'right':\n          style['text-align'] = 'right'\n          break\n        case 'start':\n          style['text-align'] = 'left'\n          break\n      }\n    }\n  }\n\n  if (!disableIndent && (!Array.isArray(disableIndent) || !disableIndent?.includes(node.type))) {\n    if ('indent' in node && node.indent && node.type !== 'listitem') {\n      // the unit should be px. Do not change it to rem, em, or something else.\n      // The quantity should be 40px. Do not change it either.\n      // See rationale in\n      // https://github.com/payloadcms/payload/issues/13130#issuecomment-3058348085\n      style['padding-inline-start'] = `${Number(node.indent) * 40}px`\n    }\n  }\n\n  let providedCSSString: string = ''\n  for (const key of Object.keys(style)) {\n    // @ts-expect-error we're iterating over the keys of the object\n    providedCSSString += `${key}: ${style[key]};`\n  }\n  const providedStyleTag = providedCSSString?.length ? ` style=\"${providedCSSString}\"` : ''\n\n  return {\n    converterForNode: converterForNode ?? unknownConverter,\n    providedCSSString,\n    providedStyleTag,\n  }\n}\n"],"mappings":"AAAA,+BAQA,OAAO,SAASA,qBAGd;EACAC,UAAU;EACVC,aAAa;EACbC,gBAAgB;EAChBC,IAAI;EACJC;AAAgB,CAOjB;EAKC,IAAIC,gBAAA;EACJ,IAAIF,IAAA,CAAKG,IAAI,KAAK,SAAS;IACzBD,gBAAA,GAAmBL,UAAA,EAAYO,MAAA,GAC5BJ,IAAA,EAA8BK,MAAA,EAAQC,SAAA,CACxC;IACD,IAAI,CAACJ,gBAAA,IAAoB,CAACD,gBAAA,EAAkB;MAC1CM,OAAA,CAAQC,KAAK,CACX,sDAAuDR,IAAA,EAA8BK,MAAA,EAAQC,SAAA,sCAA+C;IAEhJ;EACF,OAAO,IAAIN,IAAA,CAAKG,IAAI,KAAK,eAAe;IACtCD,gBAAA,GAAmBL,UAAA,EAAYY,YAAA,GAC5BT,IAAA,EAAoCK,MAAA,EAAQC,SAAA,CAC9C;IACD,IAAI,CAACJ,gBAAA,IAAoB,CAACD,gBAAA,EAAkB;MAC1CM,OAAA,CAAQC,KAAK,CACX,6DAA8DR,IAAA,EAAoCK,MAAA,EAAQC,SAAA,6CAAsD;IAEpK;EACF,OAAO;IACLJ,gBAAA,GAAmBL,UAAU,CAACG,IAAA,CAAKG,IAAI,CAAC;EAC1C;EAEA,MAAMO,KAAA,GAAqB,CAAC;EAE5B;EACA,IACE,CAACX,gBAAA,KACA,CAACY,KAAA,CAAMC,OAAO,CAACb,gBAAA,KAAqB,CAACA,gBAAA,EAAkBc,QAAA,CAASb,IAAA,CAAKG,IAAI,IAC1E;IACA,IAAI,YAAYH,IAAA,IAAQA,IAAA,CAAKc,MAAM,EAAE;MACnC,QAAQd,IAAA,CAAKc,MAAM;QACjB,KAAK;UACHJ,KAAK,CAAC,aAAa,GAAG;UACtB;QACF,KAAK;UACHA,KAAK,CAAC,aAAa,GAAG;UACtB;QACF,KAAK;UACHA,KAAK,CAAC,aAAa,GAAG;UACtB;QACF,KAAK;UAGH;QACF,KAAK;UACHA,KAAK,CAAC,aAAa,GAAG;UACtB;QACF,KAAK;UACHA,KAAK,CAAC,aAAa,GAAG;UACtB;MACJ;IACF;EACF;EAEA,IAAI,CAACZ,aAAA,KAAkB,CAACa,KAAA,CAAMC,OAAO,CAACd,aAAA,KAAkB,CAACA,aAAA,EAAee,QAAA,CAASb,IAAA,CAAKG,IAAI,IAAI;IAC5F,IAAI,YAAYH,IAAA,IAAQA,IAAA,CAAKe,MAAM,IAAIf,IAAA,CAAKG,IAAI,KAAK,YAAY;MAC/D;MACA;MACA;MACA;MACAO,KAAK,CAAC,uBAAuB,GAAG,GAAGM,MAAA,CAAOhB,IAAA,CAAKe,MAAM,IAAI,MAAM;IACjE;EACF;EAEA,IAAIE,iBAAA,GAA4B;EAChC,KAAK,MAAMC,GAAA,IAAOC,MAAA,CAAOC,IAAI,CAACV,KAAA,GAAQ;IACpC;IACAO,iBAAA,IAAqB,GAAGC,GAAA,KAAQR,KAAK,CAACQ,GAAA,CAAI,GAAG;EAC/C;EACA,MAAMG,gBAAA,GAAmBJ,iBAAA,EAAmBK,MAAA,GAAS,WAAWL,iBAAA,GAAoB,GAAG;EAEvF,OAAO;IACLf,gBAAA,EAAkBA,gBAAA,IAAoBD,gBAAA;IACtCgB,iBAAA;IACAI;EACF;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToHtml/shared/types.js

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

package/dist/features/converters/lexicalToHtml/shared/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToHtml/shared/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nexport type ProvidedCSS = {\n  'padding-inline-start'?: string\n  'text-align'?: string\n}\n\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"names":[],"mappings":"AAOA,WAEyB"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToHtml/shared/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nexport type ProvidedCSS = {\n  'padding-inline-start'?: string\n  'text-align'?: string\n}\n\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"mappings":"AAOA","ignoreList":[]}

package/dist/features/converters/lexicalToHtml/sync/converters/blockquote.js

@@ -1,10 +1,13 @@
 export const BlockquoteHTMLConverter = {
-    quote: ({ node, nodesToHTML, providedStyleTag })=>{
-        const children = nodesToHTML({
-            nodes: node.children
-        }).join('');
-        return `<blockquote${providedStyleTag}>${children}</blockquote>`;
-    }
+  quote: ({
+    node,
+    nodesToHTML,
+    providedStyleTag
+  }) => {
+    const children = nodesToHTML({
+      nodes: node.children
+    }).join('');
+    return `<blockquote${providedStyleTag}>${children}</blockquote>`;
+  }
 };
-
 //# sourceMappingURL=blockquote.js.map

package/dist/features/converters/lexicalToHtml/sync/converters/blockquote.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/features/converters/lexicalToHtml/sync/converters/blockquote.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverters } from '../types.js'\n\nexport const BlockquoteHTMLConverter: HTMLConverters<SerializedQuoteNode> = {\n  quote: ({ node, nodesToHTML, providedStyleTag }) => {\n    const children = nodesToHTML({\n      nodes: node.children,\n    }).join('')\n\n    return `<blockquote${providedStyleTag}>${children}</blockquote>`\n  },\n}\n"],"names":["BlockquoteHTMLConverter","quote","node","nodesToHTML","providedStyleTag","children","nodes","join"],"mappings":"AAGA,OAAO,MAAMA,0BAA+D;IAC1EC,OAAO,CAAC,EAAEC,IAAI,EAAEC,WAAW,EAAEC,gBAAgB,EAAE;QAC7C,MAAMC,WAAWF,YAAY;YAC3BG,OAAOJ,KAAKG,QAAQ;QACtB,GAAGE,IAAI,CAAC;QAER,OAAO,CAAC,WAAW,EAAEH,iBAAiB,CAAC,EAAEC,SAAS,aAAa,CAAC;IAClE;AACF,EAAC"}
+{"version":3,"file":"blockquote.js","names":["BlockquoteHTMLConverter","quote","node","nodesToHTML","providedStyleTag","children","nodes","join"],"sources":["../../../../../../src/features/converters/lexicalToHtml/sync/converters/blockquote.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverters } from '../types.js'\n\nexport const BlockquoteHTMLConverter: HTMLConverters<SerializedQuoteNode> = {\n  quote: ({ node, nodesToHTML, providedStyleTag }) => {\n    const children = nodesToHTML({\n      nodes: node.children,\n    }).join('')\n\n    return `<blockquote${providedStyleTag}>${children}</blockquote>`\n  },\n}\n"],"mappings":"AAGA,OAAO,MAAMA,uBAAA,GAA+D;EAC1EC,KAAA,EAAOA,CAAC;IAAEC,IAAI;IAAEC,WAAW;IAAEC;EAAgB,CAAE;IAC7C,MAAMC,QAAA,GAAWF,WAAA,CAAY;MAC3BG,KAAA,EAAOJ,IAAA,CAAKG;IACd,GAAGE,IAAI,CAAC;IAER,OAAO,cAAcH,gBAAA,IAAoBC,QAAA,eAAuB;EAClE;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToHtml/sync/converters/heading.js

@@ -1,10 +1,13 @@
 export const HeadingHTMLConverter = {
-    heading: ({ node, nodesToHTML, providedStyleTag })=>{
-        const children = nodesToHTML({
-            nodes: node.children
-        }).join('');
-        return `<${node.tag}${providedStyleTag}>${children}</${node.tag}>`;
-    }
+  heading: ({
+    node,
+    nodesToHTML,
+    providedStyleTag
+  }) => {
+    const children = nodesToHTML({
+      nodes: node.children
+    }).join('');
+    return `<${node.tag}${providedStyleTag}>${children}</${node.tag}>`;
+  }
 };
-
 //# sourceMappingURL=heading.js.map

package/dist/features/converters/lexicalToHtml/sync/converters/heading.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/features/converters/lexicalToHtml/sync/converters/heading.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverters } from '../types.js'\n\nexport const HeadingHTMLConverter: HTMLConverters<SerializedHeadingNode> = {\n  heading: ({ node, nodesToHTML, providedStyleTag }) => {\n    const children = nodesToHTML({\n      nodes: node.children,\n    }).join('')\n\n    return `<${node.tag}${providedStyleTag}>${children}</${node.tag}>`\n  },\n}\n"],"names":["HeadingHTMLConverter","heading","node","nodesToHTML","providedStyleTag","children","nodes","join","tag"],"mappings":"AAGA,OAAO,MAAMA,uBAA8D;IACzEC,SAAS,CAAC,EAAEC,IAAI,EAAEC,WAAW,EAAEC,gBAAgB,EAAE;QAC/C,MAAMC,WAAWF,YAAY;YAC3BG,OAAOJ,KAAKG,QAAQ;QACtB,GAAGE,IAAI,CAAC;QAER,OAAO,CAAC,CAAC,EAAEL,KAAKM,GAAG,GAAGJ,iBAAiB,CAAC,EAAEC,SAAS,EAAE,EAAEH,KAAKM,GAAG,CAAC,CAAC,CAAC;IACpE;AACF,EAAC"}
+{"version":3,"file":"heading.js","names":["HeadingHTMLConverter","heading","node","nodesToHTML","providedStyleTag","children","nodes","join","tag"],"sources":["../../../../../../src/features/converters/lexicalToHtml/sync/converters/heading.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverters } from '../types.js'\n\nexport const HeadingHTMLConverter: HTMLConverters<SerializedHeadingNode> = {\n  heading: ({ node, nodesToHTML, providedStyleTag }) => {\n    const children = nodesToHTML({\n      nodes: node.children,\n    }).join('')\n\n    return `<${node.tag}${providedStyleTag}>${children}</${node.tag}>`\n  },\n}\n"],"mappings":"AAGA,OAAO,MAAMA,oBAAA,GAA8D;EACzEC,OAAA,EAASA,CAAC;IAAEC,IAAI;IAAEC,WAAW;IAAEC;EAAgB,CAAE;IAC/C,MAAMC,QAAA,GAAWF,WAAA,CAAY;MAC3BG,KAAA,EAAOJ,IAAA,CAAKG;IACd,GAAGE,IAAI,CAAC;IAER,OAAO,IAAIL,IAAA,CAAKM,GAAG,GAAGJ,gBAAA,IAAoBC,QAAA,KAAaH,IAAA,CAAKM,GAAG,GAAG;EACpE;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToHtml/sync/converters/horizontalRule.js

@@ -1,5 +1,4 @@
 export const HorizontalRuleHTMLConverter = {
-    horizontalrule: '<hr />'
+  horizontalrule: '<hr />'
 };
-
 //# sourceMappingURL=horizontalRule.js.map

package/dist/features/converters/lexicalToHtml/sync/converters/horizontalRule.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/features/converters/lexicalToHtml/sync/converters/horizontalRule.ts"],"sourcesContent":["import type { SerializedHorizontalRuleNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverters } from '../types.js'\nexport const HorizontalRuleHTMLConverter: HTMLConverters<SerializedHorizontalRuleNode> = {\n  horizontalrule: '<hr />',\n}\n"],"names":["HorizontalRuleHTMLConverter","horizontalrule"],"mappings":"AAEA,OAAO,MAAMA,8BAA4E;IACvFC,gBAAgB;AAClB,EAAC"}
+{"version":3,"file":"horizontalRule.js","names":["HorizontalRuleHTMLConverter","horizontalrule"],"sources":["../../../../../../src/features/converters/lexicalToHtml/sync/converters/horizontalRule.ts"],"sourcesContent":["import type { SerializedHorizontalRuleNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverters } from '../types.js'\nexport const HorizontalRuleHTMLConverter: HTMLConverters<SerializedHorizontalRuleNode> = {\n  horizontalrule: '<hr />',\n}\n"],"mappings":"AAEA,OAAO,MAAMA,2BAAA,GAA4E;EACvFC,cAAA,EAAgB;AAClB","ignoreList":[]}

package/dist/features/converters/lexicalToHtml/sync/converters/linebreak.js

@@ -1,5 +1,4 @@
 export const LinebreakHTMLConverter = {
-    linebreak: '<br />'
+  linebreak: '<br />'
 };
-
 //# sourceMappingURL=linebreak.js.map

package/dist/features/converters/lexicalToHtml/sync/converters/linebreak.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/features/converters/lexicalToHtml/sync/converters/linebreak.ts"],"sourcesContent":["import type { SerializedLineBreakNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverters } from '../types.js'\n\nexport const LinebreakHTMLConverter: HTMLConverters<SerializedLineBreakNode> = {\n  linebreak: '<br />',\n}\n"],"names":["LinebreakHTMLConverter","linebreak"],"mappings":"AAGA,OAAO,MAAMA,yBAAkE;IAC7EC,WAAW;AACb,EAAC"}
+{"version":3,"file":"linebreak.js","names":["LinebreakHTMLConverter","linebreak"],"sources":["../../../../../../src/features/converters/lexicalToHtml/sync/converters/linebreak.ts"],"sourcesContent":["import type { SerializedLineBreakNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverters } from '../types.js'\n\nexport const LinebreakHTMLConverter: HTMLConverters<SerializedLineBreakNode> = {\n  linebreak: '<br />',\n}\n"],"mappings":"AAGA,OAAO,MAAMA,sBAAA,GAAkE;EAC7EC,SAAA,EAAW;AACb","ignoreList":[]}

package/dist/features/converters/lexicalToHtml/sync/converters/link.js

@@ -1,28 +1,36 @@
-export const LinkHTMLConverter = ({ internalDocToHref })=>({
-        autolink: ({ node, nodesToHTML, providedStyleTag })=>{
-            const children = nodesToHTML({
-                nodes: node.children
-            }).join('');
-            return `<a${providedStyleTag} href="${node.fields.url}"${node.fields.newTab ? ' rel="noopener noreferrer" target="_blank"' : ''}>${children}</a>`;
-        },
-        link: ({ node, nodesToHTML, providedStyleTag })=>{
-            const children = nodesToHTML({
-                nodes: node.children
-            }).join('');
-            let href = node.fields.url ?? '';
-            if (node.fields.linkType === 'internal') {
-                if (internalDocToHref) {
-                    href = internalDocToHref({
-                        linkNode: node
-                    });
-                } else {
-                    console.error('Lexical => HTML converter: Link converter: found internal link, but internalDocToHref is not provided');
-                    href = '#';
-                }
-            }
-            // fallback
-            return `<a${providedStyleTag} href="${href}"${node.fields.newTab ? ' rel="noopener noreferrer" target="_blank"' : ''}>${children}</a>`;
-        }
-    });
-
+export const LinkHTMLConverter = ({
+  internalDocToHref
+}) => ({
+  autolink: ({
+    node,
+    nodesToHTML,
+    providedStyleTag
+  }) => {
+    const children = nodesToHTML({
+      nodes: node.children
+    }).join('');
+    return `<a${providedStyleTag} href="${node.fields.url}"${node.fields.newTab ? ' rel="noopener noreferrer" target="_blank"' : ''}>${children}</a>`;
+  },
+  link: ({
+    node,
+    nodesToHTML,
+    providedStyleTag
+  }) => {
+    const children = nodesToHTML({
+      nodes: node.children
+    }).join('');
+    let href = node.fields.url ?? '';
+    if (node.fields.linkType === 'internal') {
+      if (internalDocToHref) {
+        href = internalDocToHref({
+          linkNode: node
+        });
+      } else {
+        console.error('Lexical => HTML converter: Link converter: found internal link, but internalDocToHref is not provided');
+        href = '#'; // fallback
+      }
+    }
+    return `<a${providedStyleTag} href="${href}"${node.fields.newTab ? ' rel="noopener noreferrer" target="_blank"' : ''}>${children}</a>`;
+  }
+});
 //# sourceMappingURL=link.js.map