@payloadcms/richtext-lexical 3.68.0-internal-debug.591ab42 → 3.68.0-internal.2b8df4a

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

@@ -1,94 +1,102 @@
-/* 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 { defaultHTMLConverters } 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 function convertLexicalToHTML({ className, converters, data, disableContainer, disableIndent, disableTextAlign }) {
-    if (hasText(data)) {
-        let finalConverters = {};
-        if (converters) {
-            if (typeof converters === 'function') {
-                finalConverters = converters({
-                    defaultConverters: defaultHTMLConverters
-                });
-            } else {
-                finalConverters = converters;
-            }
-        } else {
-            finalConverters = defaultHTMLConverters;
-        }
-        const html = convertLexicalNodesToHTML({
-            converters: finalConverters,
-            disableIndent,
-            disableTextAlign,
-            nodes: data?.root?.children,
-            parent: data?.root
-        }).join('');
-        if (disableContainer) {
-            return html;
-        } else {
-            return `<div class="${className ?? 'payload-richtext'}">${html}</div>`;
-        }
+export function convertLexicalToHTML({
+  className,
+  converters,
+  data,
+  disableContainer,
+  disableIndent,
+  disableTextAlign
+}) {
+  if (hasText(data)) {
+    let finalConverters = {};
+    if (converters) {
+      if (typeof converters === 'function') {
+        finalConverters = converters({
+          defaultConverters: defaultHTMLConverters
+        });
+      } else {
+        finalConverters = converters;
+      }
+    } else {
+      finalConverters = defaultHTMLConverters;
     }
+    const html = convertLexicalNodesToHTML({
+      converters: finalConverters,
+      disableIndent,
+      disableTextAlign,
+      nodes: data?.root?.children,
+      parent: data?.root
+    }).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 function convertLexicalNodesToHTML({ converters, disableIndent, disableTextAlign, nodes, parent }) {
-    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' ? converterForNode({
-                    childIndex: i,
-                    converters,
-                    node,
-                    nodesToHTML: (args)=>{
-                        return convertLexicalNodesToHTML({
-                            converters: args.converters ?? converters,
-                            disableIndent: args.disableIndent ?? disableIndent,
-                            disableTextAlign: args.disableTextAlign ?? disableTextAlign,
-                            nodes: args.nodes,
-                            parent: args.parent ?? {
-                                ...node,
-                                parent
-                            }
-                        });
-                    },
-                    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 function convertLexicalNodesToHTML({
+  converters,
+  disableIndent,
+  disableTextAlign,
+  nodes,
+  parent
+}) {
+  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' ? converterForNode({
+          childIndex: i,
+          converters,
+          node,
+          nodesToHTML: args => {
+            return convertLexicalNodesToHTML({
+              converters: args.converters ?? converters,
+              disableIndent: args.disableIndent ?? disableIndent,
+              disableTextAlign: args.disableTextAlign ?? disableTextAlign,
+              nodes: args.nodes,
+              parent: args.parent ?? {
+                ...node,
+                parent
+              }
+            });
+          },
+          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/sync/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToHtml/sync/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 { HTMLConverter, HTMLConverters, HTMLConvertersFunction } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\nimport { findConverterForNode } from '../shared/findConverterForNode.js'\nimport { defaultHTMLConverters } from './defaultConverters.js'\n\nexport type ConvertLexicalToHTMLArgs = {\n  /**\n   * Override class names for the container.\n   */\n  className?: string\n  converters?: HTMLConverters | HTMLConvertersFunction\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}\n\nexport function convertLexicalToHTML({\n  className,\n  converters,\n  data,\n  disableContainer,\n  disableIndent,\n  disableTextAlign,\n}: ConvertLexicalToHTMLArgs): string {\n  if (hasText(data)) {\n    let finalConverters: HTMLConverters = {}\n    if (converters) {\n      if (typeof converters === 'function') {\n        finalConverters = converters({ defaultConverters: defaultHTMLConverters })\n      } else {\n        finalConverters = converters\n      }\n    } else {\n      finalConverters = defaultHTMLConverters\n    }\n\n    const html = convertLexicalNodesToHTML({\n      converters: finalConverters,\n      disableIndent,\n      disableTextAlign,\n      nodes: data?.root?.children,\n      parent: data?.root,\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 function convertLexicalNodesToHTML({\n  converters,\n  disableIndent,\n  disableTextAlign,\n  nodes,\n  parent,\n}: {\n  converters: HTMLConverters\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n}): string[] {\n  const unknownConverter: HTMLConverter<any> = converters.unknown as HTMLConverter<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            ? converterForNode({\n                childIndex: i,\n                converters,\n                node,\n                nodesToHTML: (args) => {\n                  return convertLexicalNodesToHTML({\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                  })\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","defaultHTMLConverters","convertLexicalToHTML","className","converters","data","disableContainer","disableIndent","disableTextAlign","finalConverters","defaultConverters","html","convertLexicalNodesToHTML","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,GAM7B,SAASA,OAAO,QAAQ,kCAAiC;AACzD,SAASC,oBAAoB,QAAQ,oCAAmC;AACxE,SAASC,qBAAqB,QAAQ,yBAAwB;AAG5D;;GAEC,GAID;;GAEC,GAED;;GAEC,GAED;;GAEC,GAIH,OAAO,SAASC,qBAAqB,EACnCC,SAAS,EACTC,UAAU,EACVC,IAAI,EACJC,gBAAgB,EAChBC,aAAa,EACbC,gBAAgB,EACS;IACzB,IAAIT,QAAQM,OAAO;QACjB,IAAII,kBAAkC,CAAC;QACvC,IAAIL,YAAY;YACd,IAAI,OAAOA,eAAe,YAAY;gBACpCK,kBAAkBL,WAAW;oBAAEM,mBAAmBT;gBAAsB;YAC1E,OAAO;gBACLQ,kBAAkBL;YACpB;QACF,OAAO;YACLK,kBAAkBR;QACpB;QAEA,MAAMU,OAAOC,0BAA0B;YACrCR,YAAYK;YACZF;YACAC;YACAK,OAAOR,MAAMS,MAAMC;YACnBC,QAAQX,MAAMS;QAChB,GAAGG,IAAI,CAAC;QAER,IAAIX,kBAAkB;YACpB,OAAOK;QACT,OAAO;YACL,OAAO,CAAC,YAAY,EAAER,aAAa,mBAAmB,EAAE,EAAEQ,KAAK,MAAM,CAAC;QACxE;IACF;IACA,IAAIL,kBAAkB;QACpB,OAAO;IACT,OAAO;QACL,OAAO,CAAC,YAAY,EAAEH,aAAa,mBAAmB,QAAQ,CAAC;IACjE;AACF;AAEA,OAAO,SAASS,0BAA0B,EACxCR,UAAU,EACVG,aAAa,EACbC,gBAAgB,EAChBK,KAAK,EACLG,MAAM,EAOP;IACC,MAAME,mBAAuCd,WAAWe,OAAO;IAE/D,MAAMC,YAAsB,EAAE;IAE9B,IAAIC,IAAI,CAAC;IACT,KAAK,MAAMC,QAAQT,MAAO;QACxBQ;QACA,MAAM,EAAEE,gBAAgB,EAAEC,iBAAiB,EAAEC,gBAAgB,EAAE,GAAGzB,qBAAqB;YACrFI;YACAG;YACAC;YACAc;YACAJ;QACF;QAEA,IAAI;YACF,IAAIQ;YAEJ,IAAIH,kBAAkB;gBACpB,MAAMI,YACJ,OAAOJ,qBAAqB,aACxBA,iBAAiB;oBACfK,YAAYP;oBACZjB;oBACAkB;oBACAO,aAAa,CAACC;wBACZ,OAAOlB,0BAA0B;4BAC/BR,YAAY0B,KAAK1B,UAAU,IAAIA;4BAC/BG,eAAeuB,KAAKvB,aAAa,IAAIA;4BACrCC,kBAAkBsB,KAAKtB,gBAAgB,IAAIA;4BAC3CK,OAAOiB,KAAKjB,KAAK;4BACjBG,QAAQc,KAAKd,MAAM,IAAI;gCACrB,GAAGM,IAAI;gCACPN;4BACF;wBACF;oBACF;oBACAA;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","defaultHTMLConverters","convertLexicalToHTML","className","converters","data","disableContainer","disableIndent","disableTextAlign","finalConverters","defaultConverters","html","convertLexicalNodesToHTML","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/sync/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 { HTMLConverter, HTMLConverters, HTMLConvertersFunction } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\nimport { findConverterForNode } from '../shared/findConverterForNode.js'\nimport { defaultHTMLConverters } from './defaultConverters.js'\n\nexport type ConvertLexicalToHTMLArgs = {\n  /**\n   * Override class names for the container.\n   */\n  className?: string\n  converters?: HTMLConverters | HTMLConvertersFunction\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}\n\nexport function convertLexicalToHTML({\n  className,\n  converters,\n  data,\n  disableContainer,\n  disableIndent,\n  disableTextAlign,\n}: ConvertLexicalToHTMLArgs): string {\n  if (hasText(data)) {\n    let finalConverters: HTMLConverters = {}\n    if (converters) {\n      if (typeof converters === 'function') {\n        finalConverters = converters({ defaultConverters: defaultHTMLConverters })\n      } else {\n        finalConverters = converters\n      }\n    } else {\n      finalConverters = defaultHTMLConverters\n    }\n\n    const html = convertLexicalNodesToHTML({\n      converters: finalConverters,\n      disableIndent,\n      disableTextAlign,\n      nodes: data?.root?.children,\n      parent: data?.root,\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 function convertLexicalNodesToHTML({\n  converters,\n  disableIndent,\n  disableTextAlign,\n  nodes,\n  parent,\n}: {\n  converters: HTMLConverters\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n}): string[] {\n  const unknownConverter: HTMLConverter<any> = converters.unknown as HTMLConverter<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            ? converterForNode({\n                childIndex: i,\n                converters,\n                node,\n                nodesToHTML: (args) => {\n                  return convertLexicalNodesToHTML({\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                  })\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,+BAMA,SAASA,OAAO,QAAQ;AACxB,SAASC,oBAAoB,QAAQ;AACrC,SAASC,qBAAqB,QAAQ;AAuBtC,OAAO,SAASC,qBAAqB;EACnCC,SAAS;EACTC,UAAU;EACVC,IAAI;EACJC,gBAAgB;EAChBC,aAAa;EACbC;AAAgB,CACS;EACzB,IAAIT,OAAA,CAAQM,IAAA,GAAO;IACjB,IAAII,eAAA,GAAkC,CAAC;IACvC,IAAIL,UAAA,EAAY;MACd,IAAI,OAAOA,UAAA,KAAe,YAAY;QACpCK,eAAA,GAAkBL,UAAA,CAAW;UAAEM,iBAAA,EAAmBT;QAAsB;MAC1E,OAAO;QACLQ,eAAA,GAAkBL,UAAA;MACpB;IACF,OAAO;MACLK,eAAA,GAAkBR,qBAAA;IACpB;IAEA,MAAMU,IAAA,GAAOC,yBAAA,CAA0B;MACrCR,UAAA,EAAYK,eAAA;MACZF,aAAA;MACAC,gBAAA;MACAK,KAAA,EAAOR,IAAA,EAAMS,IAAA,EAAMC,QAAA;MACnBC,MAAA,EAAQX,IAAA,EAAMS;IAChB,GAAGG,IAAI,CAAC;IAER,IAAIX,gBAAA,EAAkB;MACpB,OAAOK,IAAA;IACT,OAAO;MACL,OAAO,eAAeR,SAAA,IAAa,uBAAuBQ,IAAA,QAAY;IACxE;EACF;EACA,IAAIL,gBAAA,EAAkB;IACpB,OAAO;EACT,OAAO;IACL,OAAO,eAAeH,SAAA,IAAa,4BAA4B;EACjE;AACF;AAEA,OAAO,SAASS,0BAA0B;EACxCR,UAAU;EACVG,aAAa;EACbC,gBAAgB;EAChBK,KAAK;EACLG;AAAM,CAOP;EACC,MAAME,gBAAA,GAAuCd,UAAA,CAAWe,OAAO;EAE/D,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,GAAGzB,oBAAA,CAAqB;MACrFI,UAAA;MACAG,aAAA;MACAC,gBAAA;MACAc,IAAA;MACAJ;IACF;IAEA,IAAI;MACF,IAAIQ,QAAA;MAEJ,IAAIH,gBAAA,EAAkB;QACpB,MAAMI,SAAA,GACJ,OAAOJ,gBAAA,KAAqB,aACxBA,gBAAA,CAAiB;UACfK,UAAA,EAAYP,CAAA;UACZjB,UAAA;UACAkB,IAAA;UACAO,WAAA,EAAcC,IAAA;YACZ,OAAOlB,yBAAA,CAA0B;cAC/BR,UAAA,EAAY0B,IAAA,CAAK1B,UAAU,IAAIA,UAAA;cAC/BG,aAAA,EAAeuB,IAAA,CAAKvB,aAAa,IAAIA,aAAA;cACrCC,gBAAA,EAAkBsB,IAAA,CAAKtB,gBAAgB,IAAIA,gBAAA;cAC3CK,KAAA,EAAOiB,IAAA,CAAKjB,KAAK;cACjBG,MAAA,EAAQc,IAAA,CAAKd,MAAM,IAAI;gBACrB,GAAGM,IAAI;gBACPN;cACF;YACF;UACF;UACAA,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/sync/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/sync/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToHtml/sync/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\n\nexport type HTMLConverter<T extends { [key: string]: any; type?: string } = SerializedLexicalNode> =\n\n    | ((args: {\n        childIndex: number\n        converters: HTMLConverters\n        node: T\n        nodesToHTML: (args: {\n          converters?: HTMLConverters\n          disableIndent?: boolean | string[]\n          disableTextAlign?: boolean | string[]\n          nodes: SerializedLexicalNode[]\n          parent?: SerializedLexicalNodeWithParent\n        }) => string[]\n        parent: SerializedLexicalNodeWithParent\n        providedCSSString: string\n        providedStyleTag: string\n      }) => string)\n    | string\n\nexport type HTMLConverters<\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]: HTMLConverter<any>\n      }\n    | HTMLConverter<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: HTMLConverter<\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    >]?: HTMLConverter<\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    >]?: HTMLConverter<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n  unknown?: HTMLConverter<SerializedLexicalNode>\n}\n\nexport type HTMLConvertersFunction<\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: HTMLConverters<DefaultNodeTypes> }) => HTMLConverters<T>\n"],"names":[],"mappings":"AA+B4E,0FAA0F;AACnF,0FAA0F;AA4C7K,WAKwF"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToHtml/sync/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\n\nexport type HTMLConverter<T extends { [key: string]: any; type?: string } = SerializedLexicalNode> =\n\n    | ((args: {\n        childIndex: number\n        converters: HTMLConverters\n        node: T\n        nodesToHTML: (args: {\n          converters?: HTMLConverters\n          disableIndent?: boolean | string[]\n          disableTextAlign?: boolean | string[]\n          nodes: SerializedLexicalNode[]\n          parent?: SerializedLexicalNodeWithParent\n        }) => string[]\n        parent: SerializedLexicalNodeWithParent\n        providedCSSString: string\n        providedStyleTag: string\n      }) => string)\n    | string\n\nexport type HTMLConverters<\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]: HTMLConverter<any>\n      }\n    | HTMLConverter<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: HTMLConverter<\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    >]?: HTMLConverter<\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    >]?: HTMLConverter<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n  unknown?: HTMLConverter<SerializedLexicalNode>\n}\n\nexport type HTMLConvertersFunction<\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: HTMLConverters<DefaultNodeTypes> }) => HTMLConverters<T>\n"],"mappings":"AA4EA","ignoreList":[]}

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

@@ -1,10 +1,7 @@
 export const LinebreakHTMLConverter = {
-    converter () {
-        return `<br>`;
-    },
-    nodeTypes: [
-        'linebreak'
-    ]
+  converter() {
+    return `<br>`;
+  },
+  nodeTypes: ['linebreak']
 };
-
 //# sourceMappingURL=linebreak.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/linebreak.ts"],"sourcesContent":["import type { SerializedLineBreakNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nexport const LinebreakHTMLConverter: HTMLConverter<SerializedLineBreakNode> = {\n  converter() {\n    return `<br>`\n  },\n  nodeTypes: ['linebreak'],\n}\n"],"names":["LinebreakHTMLConverter","converter","nodeTypes"],"mappings":"AAGA,OAAO,MAAMA,yBAAiE;IAC5EC;QACE,OAAO,CAAC,IAAI,CAAC;IACf;IACAC,WAAW;QAAC;KAAY;AAC1B,EAAC"}
+{"version":3,"file":"linebreak.js","names":["LinebreakHTMLConverter","converter","nodeTypes"],"sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/linebreak.ts"],"sourcesContent":["import type { SerializedLineBreakNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nexport const LinebreakHTMLConverter: HTMLConverter<SerializedLineBreakNode> = {\n  converter() {\n    return `<br>`\n  },\n  nodeTypes: ['linebreak'],\n}\n"],"mappings":"AAGA,OAAO,MAAMA,sBAAA,GAAiE;EAC5EC,UAAA;IACE,OAAO,MAAM;EACf;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

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

@@ -1,33 +1,38 @@
 import { convertLexicalNodesToHTML } from '../index.js';
 export const ParagraphHTMLConverter = {
-    async converter ({ 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
-        });
-        const style = [
-            node.format ? `text-align: ${node.format};` : '',
-            // 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
-            node.indent > 0 ? `padding-inline-start: ${node.indent * 40}px;` : ''
-        ].filter(Boolean).join(' ');
-        return `<p${style ? ` style='${style}'` : ''}>${childrenText}</p>`;
-    },
-    nodeTypes: [
-        'paragraph'
-    ]
+  async converter({
+    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
+    });
+    const style = [node.format ? `text-align: ${node.format};` : '',
+    // 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
+    node.indent > 0 ? `padding-inline-start: ${node.indent * 40}px;` : ''].filter(Boolean).join(' ');
+    return `<p${style ? ` style='${style}'` : ''}>${childrenText}</p>`;
+  },
+  nodeTypes: ['paragraph']
 };
-
 //# sourceMappingURL=paragraph.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/paragraph.ts"],"sourcesContent":["import type { SerializedParagraphNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nimport { convertLexicalNodesToHTML } from '../index.js'\n\nexport const ParagraphHTMLConverter: HTMLConverter<SerializedParagraphNode> = {\n  async converter({\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    const style = [\n      node.format ? `text-align: ${node.format};` : '',\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      node.indent > 0 ? `padding-inline-start: ${node.indent * 40}px;` : '',\n    ]\n      .filter(Boolean)\n      .join(' ')\n    return `<p${style ? ` style='${style}'` : ''}>${childrenText}</p>`\n  },\n  nodeTypes: ['paragraph'],\n}\n"],"names":["convertLexicalNodesToHTML","ParagraphHTMLConverter","converter","converters","currentDepth","depth","draft","node","overrideAccess","parent","req","showHiddenFields","childrenText","lexicalNodes","children","style","format","indent","filter","Boolean","join","nodeTypes"],"mappings":"AAGA,SAASA,yBAAyB,QAAQ,cAAa;AAEvD,OAAO,MAAMC,yBAAiE;IAC5E,MAAMC,WAAU,EACdC,UAAU,EACVC,YAAY,EACZC,KAAK,EACLC,KAAK,EACLC,IAAI,EACJC,cAAc,EACdC,MAAM,EACNC,GAAG,EACHC,gBAAgB,EACjB;QACC,MAAMC,eAAe,MAAMZ,0BAA0B;YACnDG;YACAC;YACAC;YACAC;YACAO,cAAcN,KAAKO,QAAQ;YAC3BN;YACAC,QAAQ;gBACN,GAAGF,IAAI;gBACPE;YACF;YACAC;YACAC;QACF;QACA,MAAMI,QAAQ;YACZR,KAAKS,MAAM,GAAG,CAAC,YAAY,EAAET,KAAKS,MAAM,CAAC,CAAC,CAAC,GAAG;YAC9C,yEAAyE;YACzE,wDAAwD;YACxD,mBAAmB;YACnB,6EAA6E;YAC7ET,KAAKU,MAAM,GAAG,IAAI,CAAC,sBAAsB,EAAEV,KAAKU,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG;SACpE,CACEC,MAAM,CAACC,SACPC,IAAI,CAAC;QACR,OAAO,CAAC,EAAE,EAAEL,QAAQ,CAAC,QAAQ,EAAEA,MAAM,CAAC,CAAC,GAAG,GAAG,CAAC,EAAEH,aAAa,IAAI,CAAC;IACpE;IACAS,WAAW;QAAC;KAAY;AAC1B,EAAC"}
+{"version":3,"file":"paragraph.js","names":["convertLexicalNodesToHTML","ParagraphHTMLConverter","converter","converters","currentDepth","depth","draft","node","overrideAccess","parent","req","showHiddenFields","childrenText","lexicalNodes","children","style","format","indent","filter","Boolean","join","nodeTypes"],"sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/paragraph.ts"],"sourcesContent":["import type { SerializedParagraphNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nimport { convertLexicalNodesToHTML } from '../index.js'\n\nexport const ParagraphHTMLConverter: HTMLConverter<SerializedParagraphNode> = {\n  async converter({\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    const style = [\n      node.format ? `text-align: ${node.format};` : '',\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      node.indent > 0 ? `padding-inline-start: ${node.indent * 40}px;` : '',\n    ]\n      .filter(Boolean)\n      .join(' ')\n    return `<p${style ? ` style='${style}'` : ''}>${childrenText}</p>`\n  },\n  nodeTypes: ['paragraph'],\n}\n"],"mappings":"AAGA,SAASA,yBAAyB,QAAQ;AAE1C,OAAO,MAAMC,sBAAA,GAAiE;EAC5E,MAAMC,UAAU;IACdC,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;IACA,MAAMI,KAAA,GAAQ,CACZR,IAAA,CAAKS,MAAM,GAAG,eAAeT,IAAA,CAAKS,MAAM,GAAG,GAAG;IAC9C;IACA;IACA;IACA;IACAT,IAAA,CAAKU,MAAM,GAAG,IAAI,yBAAyBV,IAAA,CAAKU,MAAM,GAAG,OAAO,GAAG,GACpE,CACEC,MAAM,CAACC,OAAA,EACPC,IAAI,CAAC;IACR,OAAO,KAAKL,KAAA,GAAQ,WAAWA,KAAA,GAAQ,GAAG,MAAMH,YAAA,MAAkB;EACpE;EACAS,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

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

@@ -1,10 +1,9 @@
 export const TabHTMLConverter = {
-    converter ({ node }) {
-        return node.text;
-    },
-    nodeTypes: [
-        'tab'
-    ]
+  converter({
+    node
+  }) {
+    return node.text;
+  },
+  nodeTypes: ['tab']
 };
-
 //# sourceMappingURL=tab.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/tab.ts"],"sourcesContent":["import type { SerializedTabNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nexport const TabHTMLConverter: HTMLConverter<SerializedTabNode> = {\n  converter({ node }) {\n    return node.text\n  },\n  nodeTypes: ['tab'],\n}\n"],"names":["TabHTMLConverter","converter","node","text","nodeTypes"],"mappings":"AAGA,OAAO,MAAMA,mBAAqD;IAChEC,WAAU,EAAEC,IAAI,EAAE;QAChB,OAAOA,KAAKC,IAAI;IAClB;IACAC,WAAW;QAAC;KAAM;AACpB,EAAC"}
+{"version":3,"file":"tab.js","names":["TabHTMLConverter","converter","node","text","nodeTypes"],"sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/tab.ts"],"sourcesContent":["import type { SerializedTabNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nexport const TabHTMLConverter: HTMLConverter<SerializedTabNode> = {\n  converter({ node }) {\n    return node.text\n  },\n  nodeTypes: ['tab'],\n}\n"],"mappings":"AAGA,OAAO,MAAMA,gBAAA,GAAqD;EAChEC,UAAU;IAAEC;EAAI,CAAE;IAChB,OAAOA,IAAA,CAAKC,IAAI;EAClB;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

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

@@ -1,34 +1,33 @@
 import escapeHTML from 'escape-html';
 import { NodeFormat } from '../../../../../lexical/utils/nodeFormat.js';
 export const TextHTMLConverter = {
-    converter ({ node }) {
-        let text = escapeHTML(node.text);
-        if (node.format & NodeFormat.IS_BOLD) {
-            text = `<strong>${text}</strong>`;
-        }
-        if (node.format & NodeFormat.IS_ITALIC) {
-            text = `<em>${text}</em>`;
-        }
-        if (node.format & NodeFormat.IS_STRIKETHROUGH) {
-            text = `<span style="text-decoration: line-through">${text}</span>`;
-        }
-        if (node.format & NodeFormat.IS_UNDERLINE) {
-            text = `<span style="text-decoration: underline">${text}</span>`;
-        }
-        if (node.format & NodeFormat.IS_CODE) {
-            text = `<code>${text}</code>`;
-        }
-        if (node.format & NodeFormat.IS_SUBSCRIPT) {
-            text = `<sub>${text}</sub>`;
-        }
-        if (node.format & NodeFormat.IS_SUPERSCRIPT) {
-            text = `<sup>${text}</sup>`;
-        }
-        return text;
-    },
-    nodeTypes: [
-        'text'
-    ]
+  converter({
+    node
+  }) {
+    let text = escapeHTML(node.text);
+    if (node.format & NodeFormat.IS_BOLD) {
+      text = `<strong>${text}</strong>`;
+    }
+    if (node.format & NodeFormat.IS_ITALIC) {
+      text = `<em>${text}</em>`;
+    }
+    if (node.format & NodeFormat.IS_STRIKETHROUGH) {
+      text = `<span style="text-decoration: line-through">${text}</span>`;
+    }
+    if (node.format & NodeFormat.IS_UNDERLINE) {
+      text = `<span style="text-decoration: underline">${text}</span>`;
+    }
+    if (node.format & NodeFormat.IS_CODE) {
+      text = `<code>${text}</code>`;
+    }
+    if (node.format & NodeFormat.IS_SUBSCRIPT) {
+      text = `<sub>${text}</sub>`;
+    }
+    if (node.format & NodeFormat.IS_SUPERSCRIPT) {
+      text = `<sup>${text}</sup>`;
+    }
+    return text;
+  },
+  nodeTypes: ['text']
 };
-
 //# sourceMappingURL=text.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/text.ts"],"sourcesContent":["import escapeHTML from 'escape-html'\n\nimport type { SerializedTextNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nimport { NodeFormat } from '../../../../../lexical/utils/nodeFormat.js'\n\nexport const TextHTMLConverter: HTMLConverter<SerializedTextNode> = {\n  converter({ node }) {\n    let text = escapeHTML(node.text)\n\n    if (node.format & NodeFormat.IS_BOLD) {\n      text = `<strong>${text}</strong>`\n    }\n    if (node.format & NodeFormat.IS_ITALIC) {\n      text = `<em>${text}</em>`\n    }\n    if (node.format & NodeFormat.IS_STRIKETHROUGH) {\n      text = `<span style=\"text-decoration: line-through\">${text}</span>`\n    }\n    if (node.format & NodeFormat.IS_UNDERLINE) {\n      text = `<span style=\"text-decoration: underline\">${text}</span>`\n    }\n    if (node.format & NodeFormat.IS_CODE) {\n      text = `<code>${text}</code>`\n    }\n    if (node.format & NodeFormat.IS_SUBSCRIPT) {\n      text = `<sub>${text}</sub>`\n    }\n    if (node.format & NodeFormat.IS_SUPERSCRIPT) {\n      text = `<sup>${text}</sup>`\n    }\n\n    return text\n  },\n  nodeTypes: ['text'],\n}\n"],"names":["escapeHTML","NodeFormat","TextHTMLConverter","converter","node","text","format","IS_BOLD","IS_ITALIC","IS_STRIKETHROUGH","IS_UNDERLINE","IS_CODE","IS_SUBSCRIPT","IS_SUPERSCRIPT","nodeTypes"],"mappings":"AAAA,OAAOA,gBAAgB,cAAa;AAKpC,SAASC,UAAU,QAAQ,6CAA4C;AAEvE,OAAO,MAAMC,oBAAuD;IAClEC,WAAU,EAAEC,IAAI,EAAE;QAChB,IAAIC,OAAOL,WAAWI,KAAKC,IAAI;QAE/B,IAAID,KAAKE,MAAM,GAAGL,WAAWM,OAAO,EAAE;YACpCF,OAAO,CAAC,QAAQ,EAAEA,KAAK,SAAS,CAAC;QACnC;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWO,SAAS,EAAE;YACtCH,OAAO,CAAC,IAAI,EAAEA,KAAK,KAAK,CAAC;QAC3B;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWQ,gBAAgB,EAAE;YAC7CJ,OAAO,CAAC,4CAA4C,EAAEA,KAAK,OAAO,CAAC;QACrE;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWS,YAAY,EAAE;YACzCL,OAAO,CAAC,yCAAyC,EAAEA,KAAK,OAAO,CAAC;QAClE;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWU,OAAO,EAAE;YACpCN,OAAO,CAAC,MAAM,EAAEA,KAAK,OAAO,CAAC;QAC/B;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWW,YAAY,EAAE;YACzCP,OAAO,CAAC,KAAK,EAAEA,KAAK,MAAM,CAAC;QAC7B;QACA,IAAID,KAAKE,MAAM,GAAGL,WAAWY,cAAc,EAAE;YAC3CR,OAAO,CAAC,KAAK,EAAEA,KAAK,MAAM,CAAC;QAC7B;QAEA,OAAOA;IACT;IACAS,WAAW;QAAC;KAAO;AACrB,EAAC"}
+{"version":3,"file":"text.js","names":["escapeHTML","NodeFormat","TextHTMLConverter","converter","node","text","format","IS_BOLD","IS_ITALIC","IS_STRIKETHROUGH","IS_UNDERLINE","IS_CODE","IS_SUBSCRIPT","IS_SUPERSCRIPT","nodeTypes"],"sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/text.ts"],"sourcesContent":["import escapeHTML from 'escape-html'\n\nimport type { SerializedTextNode } from '../../../../../nodeTypes.js'\nimport type { HTMLConverter } from '../types.js'\n\nimport { NodeFormat } from '../../../../../lexical/utils/nodeFormat.js'\n\nexport const TextHTMLConverter: HTMLConverter<SerializedTextNode> = {\n  converter({ node }) {\n    let text = escapeHTML(node.text)\n\n    if (node.format & NodeFormat.IS_BOLD) {\n      text = `<strong>${text}</strong>`\n    }\n    if (node.format & NodeFormat.IS_ITALIC) {\n      text = `<em>${text}</em>`\n    }\n    if (node.format & NodeFormat.IS_STRIKETHROUGH) {\n      text = `<span style=\"text-decoration: line-through\">${text}</span>`\n    }\n    if (node.format & NodeFormat.IS_UNDERLINE) {\n      text = `<span style=\"text-decoration: underline\">${text}</span>`\n    }\n    if (node.format & NodeFormat.IS_CODE) {\n      text = `<code>${text}</code>`\n    }\n    if (node.format & NodeFormat.IS_SUBSCRIPT) {\n      text = `<sub>${text}</sub>`\n    }\n    if (node.format & NodeFormat.IS_SUPERSCRIPT) {\n      text = `<sup>${text}</sup>`\n    }\n\n    return text\n  },\n  nodeTypes: ['text'],\n}\n"],"mappings":"AAAA,OAAOA,UAAA,MAAgB;AAKvB,SAASC,UAAU,QAAQ;AAE3B,OAAO,MAAMC,iBAAA,GAAuD;EAClEC,UAAU;IAAEC;EAAI,CAAE;IAChB,IAAIC,IAAA,GAAOL,UAAA,CAAWI,IAAA,CAAKC,IAAI;IAE/B,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWM,OAAO,EAAE;MACpCF,IAAA,GAAO,WAAWA,IAAA,WAAe;IACnC;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWO,SAAS,EAAE;MACtCH,IAAA,GAAO,OAAOA,IAAA,OAAW;IAC3B;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWQ,gBAAgB,EAAE;MAC7CJ,IAAA,GAAO,+CAA+CA,IAAA,SAAa;IACrE;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWS,YAAY,EAAE;MACzCL,IAAA,GAAO,4CAA4CA,IAAA,SAAa;IAClE;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWU,OAAO,EAAE;MACpCN,IAAA,GAAO,SAASA,IAAA,SAAa;IAC/B;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWW,YAAY,EAAE;MACzCP,IAAA,GAAO,QAAQA,IAAA,QAAY;IAC7B;IACA,IAAID,IAAA,CAAKE,MAAM,GAAGL,UAAA,CAAWY,cAAc,EAAE;MAC3CR,IAAA,GAAO,QAAQA,IAAA,QAAY;IAC7B;IAEA,OAAOA,IAAA;EACT;EACAS,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

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

@@ -4,11 +4,6 @@ import { TabHTMLConverter } from './converters/tab.js';
 import { TextHTMLConverter } from './converters/text.js';
 /**
  * @deprecated - will be removed in 4.0
- */ export const defaultHTMLConverters = [
-    ParagraphHTMLConverter,
-    TextHTMLConverter,
-    LinebreakHTMLConverter,
-    TabHTMLConverter
-];
-
+ */
+export const defaultHTMLConverters = [ParagraphHTMLConverter, TextHTMLConverter, LinebreakHTMLConverter, TabHTMLConverter];
 //# sourceMappingURL=defaultConverters.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/lexicalToHtml_deprecated/converter/defaultConverters.ts"],"sourcesContent":["import type { HTMLConverter } from './types.js'\n\nimport { LinebreakHTMLConverter } from './converters/linebreak.js'\nimport { ParagraphHTMLConverter } from './converters/paragraph.js'\nimport { TabHTMLConverter } from './converters/tab.js'\nimport { TextHTMLConverter } from './converters/text.js'\n\n/**\n * @deprecated - will be removed in 4.0\n */\nexport const defaultHTMLConverters: HTMLConverter<any>[] = [\n  ParagraphHTMLConverter,\n  TextHTMLConverter,\n  LinebreakHTMLConverter,\n  TabHTMLConverter,\n]\n"],"names":["LinebreakHTMLConverter","ParagraphHTMLConverter","TabHTMLConverter","TextHTMLConverter","defaultHTMLConverters"],"mappings":"AAEA,SAASA,sBAAsB,QAAQ,4BAA2B;AAClE,SAASC,sBAAsB,QAAQ,4BAA2B;AAClE,SAASC,gBAAgB,QAAQ,sBAAqB;AACtD,SAASC,iBAAiB,QAAQ,uBAAsB;AAExD;;CAEC,GACD,OAAO,MAAMC,wBAA8C;IACzDH;IACAE;IACAH;IACAE;CACD,CAAA"}
+{"version":3,"file":"defaultConverters.js","names":["LinebreakHTMLConverter","ParagraphHTMLConverter","TabHTMLConverter","TextHTMLConverter","defaultHTMLConverters"],"sources":["../../../../../src/features/converters/lexicalToHtml_deprecated/converter/defaultConverters.ts"],"sourcesContent":["import type { HTMLConverter } from './types.js'\n\nimport { LinebreakHTMLConverter } from './converters/linebreak.js'\nimport { ParagraphHTMLConverter } from './converters/paragraph.js'\nimport { TabHTMLConverter } from './converters/tab.js'\nimport { TextHTMLConverter } from './converters/text.js'\n\n/**\n * @deprecated - will be removed in 4.0\n */\nexport const defaultHTMLConverters: HTMLConverter<any>[] = [\n  ParagraphHTMLConverter,\n  TextHTMLConverter,\n  LinebreakHTMLConverter,\n  TabHTMLConverter,\n]\n"],"mappings":"AAEA,SAASA,sBAAsB,QAAQ;AACvC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,gBAAgB,QAAQ;AACjC,SAASC,iBAAiB,QAAQ;AAElC;;;AAGA,OAAO,MAAMC,qBAAA,GAA8C,CACzDH,sBAAA,EACAE,iBAAA,EACAH,sBAAA,EACAE,gBAAA,CACD","ignoreList":[]}