@payloadcms/richtext-lexical 3.29.0-internal.3471e81 → 3.29.0-internal.7b98279

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

@@ -1 +0,0 @@
-{"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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToHtml/sync/types.ts"],"names":[],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"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}\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":"AA2EA","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"linebreak.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/linebreak.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,uBAAuB,CAKzE,CAAA"}

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

@@ -1 +0,0 @@
-{"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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"paragraph.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/paragraph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAIhD,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,uBAAuB,CAmCzE,CAAA"}

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

@@ -1 +0,0 @@
-{"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      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,IAC9CT,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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tab.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/tab.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAAC,iBAAiB,CAK7D,CAAA"}

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

@@ -1 +0,0 @@
-{"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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToHtml_deprecated/converter/converters/text.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAIhD,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,kBAAkB,CA6B/D,CAAA"}

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

@@ -1 +0,0 @@
-{"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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToHtml_deprecated/converter/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAO/C;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,GAAG,CAAC,EAKrD,CAAA"}

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

@@ -1 +0,0 @@
-{"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":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToHtml_deprecated/converter/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAC3E,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAItD,OAAO,KAAK,EAAE,aAAa,EAAE,+BAA+B,EAAE,MAAM,YAAY,CAAA;AAIhF;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,qBAAqB,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,GAAG,CACA;IACE;;OAEG;IACH,OAAO,CAAC,EAAE,KAAK,CAAA;IACf;;;;;OAKG;IACH,GAAG,EAAE,cAAc,CAAA;CACpB,GACD;IACE;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;;;OAKG;IACH,GAAG,CAAC,EAAE,IAAI,GAAG,SAAS,CAAA;CACvB,CACJ,CAAA;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,EACzC,UAAU,EACV,YAAY,EACZ,IAAI,EACJ,KAAK,EACL,KAAK,EACL,cAAc,EACd,OAAO,EACP,GAAG,EACH,gBAAgB,GACjB,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CA2B5C;AAED;;GAEG;AACH,wBAAsB,yBAAyB,CAAC,EAC9C,UAAU,EACV,YAAY,EACZ,KAAK,EACL,KAAK,EACL,YAAY,EACZ,cAAc,EACd,MAAM,EACN,GAAG,EACH,gBAAgB,GACjB,EAAE;IACD,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,YAAY,EAAE,qBAAqB,EAAE,CAAA;IACrC,cAAc,EAAE,OAAO,CAAA;IACvB,MAAM,EAAE,+BAA+B,CAAA;IACvC;;OAEG;IACH,GAAG,EAAE,IAAI,GAAG,cAAc,CAAA;IAC1B,gBAAgB,EAAE,OAAO,CAAA;CAC1B,GAAG,OAAO,CAAC,MAAM,CAAC,CA8ClB"}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/features/converters/lexicalToJSX/Component/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToJSX/Component/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,0BAA0B,CAAA;AACjC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAK1D,MAAM,MAAM,qBAAqB,CAC/B,CAAC,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3C,gBAAgB,GAChB,mBAAmB,CAAC;IAAE,SAAS,CAAC,EAAE,IAAI,GAAG,MAAM,CAAA;CAAE,CAAC,GAClD,yBAAyB,CAAC;IAAE,SAAS,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,IAC7E,CAAC,IAAI,EAAE;IAAE,iBAAiB,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAA;CAAE,KAAK,aAAa,CAAC,CAAC,CAAC,CAAA;AAEtF,KAAK,aAAa,GAAG;IACnB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;OAEG;IACH,UAAU,CAAC,EAAE,aAAa,GAAG,qBAAqB,CAAA;IAClD;;OAEG;IACH,IAAI,EAAE,qBAAqB,CAAA;IAC3B;;OAEG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;IAClC;;OAEG;IACH,gBAAgB,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;CACtC,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CAwC5C,CAAA"}

package/dist/features/converters/lexicalToJSX/Component/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["React","defaultJSXConverters","convertLexicalToJSX","RichText","className","converters","data","editorState","disableContainer","disableIndent","disableTextAlign","finalConverters","defaultConverters","content","Array","isArray","_jsx","_Fragment"],"sources":["../../../../../src/features/converters/lexicalToJSX/Component/index.tsx"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\n\nimport React from 'react'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nimport type { JSXConverters } from '../converter/types.js'\n\nimport { defaultJSXConverters } from '../converter/defaultConverters.js'\nimport { convertLexicalToJSX } from '../converter/index.js'\n\nexport type JSXConvertersFunction<\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: JSXConverters<DefaultNodeTypes> }) => JSXConverters<T>\n\ntype RichTextProps = {\n  /**\n   * Override class names for the container.\n   */\n  className?: string\n  /**\n   * Custom converters to transform your nodes to JSX. Can be an object or a function that receives the default converters.\n   */\n  converters?: JSXConverters | JSXConvertersFunction\n  /**\n   * Serialized editor state to render.\n   */\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 const RichText: React.FC<RichTextProps> = ({\n  className,\n  converters,\n  data: editorState,\n  disableContainer,\n  disableIndent,\n  disableTextAlign,\n}) => {\n  if (!editorState) {\n    return null\n  }\n\n  let finalConverters: JSXConverters = {}\n  if (converters) {\n    if (typeof converters === 'function') {\n      finalConverters = converters({ defaultConverters: defaultJSXConverters })\n    } else {\n      finalConverters = converters\n    }\n  } else {\n    finalConverters = defaultJSXConverters\n  }\n\n  const content =\n    editorState &&\n    !Array.isArray(editorState) &&\n    typeof editorState === 'object' &&\n    'root' in editorState &&\n    convertLexicalToJSX({\n      converters: finalConverters,\n      data: editorState,\n      disableIndent,\n      disableTextAlign,\n    })\n\n  if (disableContainer) {\n    return <>{content}</>\n  }\n\n  return <div className={className ?? 'payload-richtext'}>{content}</div>\n}\n"],"mappings":";AAEA,OAAOA,KAAA,MAAW;AASlB,SAASC,oBAAoB,QAAQ;AACrC,SAASC,mBAAmB,QAAQ;AAoCpC,OAAO,MAAMC,QAAA,GAAoCA,CAAC;EAChDC,SAAS;EACTC,UAAU;EACVC,IAAA,EAAMC,WAAW;EACjBC,gBAAgB;EAChBC,aAAa;EACbC;AAAgB,CACjB;EACC,IAAI,CAACH,WAAA,EAAa;IAChB,OAAO;EACT;EAEA,IAAII,eAAA,GAAiC,CAAC;EACtC,IAAIN,UAAA,EAAY;IACd,IAAI,OAAOA,UAAA,KAAe,YAAY;MACpCM,eAAA,GAAkBN,UAAA,CAAW;QAAEO,iBAAA,EAAmBX;MAAqB;IACzE,OAAO;MACLU,eAAA,GAAkBN,UAAA;IACpB;EACF,OAAO;IACLM,eAAA,GAAkBV,oBAAA;EACpB;EAEA,MAAMY,OAAA,GACJN,WAAA,IACA,CAACO,KAAA,CAAMC,OAAO,CAACR,WAAA,KACf,OAAOA,WAAA,KAAgB,YACvB,UAAUA,WAAA,IACVL,mBAAA,CAAoB;IAClBG,UAAA,EAAYM,eAAA;IACZL,IAAA,EAAMC,WAAA;IACNE,aAAA;IACAC;EACF;EAEF,IAAIF,gBAAA,EAAkB;IACpB,oBAAOQ,IAAA,CAAAC,SAAA;gBAAGJ;;EACZ;EAEA,oBAAOG,IAAA,CAAC;IAAIZ,SAAA,EAAWA,SAAA,IAAa;cAAqBS;;AAC3D","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/converters/blockquote.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blockquote.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/blockquote.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AACtE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,mBAAmB,CAQrE,CAAA"}

package/dist/features/converters/lexicalToJSX/converter/converters/blockquote.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"blockquote.js","names":["BlockquoteJSXConverter","quote","node","nodesToJSX","children","nodes","_jsx"],"sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/blockquote.tsx"],"sourcesContent":["import type { SerializedQuoteNode } from '../../../../../nodeTypes.js'\nimport type { JSXConverters } from '../types.js'\n\nexport const BlockquoteJSXConverter: JSXConverters<SerializedQuoteNode> = {\n  quote: ({ node, nodesToJSX }) => {\n    const children = nodesToJSX({\n      nodes: node.children,\n    })\n\n    return <blockquote>{children}</blockquote>\n  },\n}\n"],"mappings":";AAGA,OAAO,MAAMA,sBAAA,GAA6D;EACxEC,KAAA,EAAOA,CAAC;IAAEC,IAAI;IAAEC;EAAU,CAAE;IAC1B,MAAMC,QAAA,GAAWD,UAAA,CAAW;MAC1BE,KAAA,EAAOH,IAAA,CAAKE;IACd;IAEA,oBAAOE,IAAA,CAAC;gBAAYF;;EACtB;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/converters/heading.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"heading.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/heading.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAA;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,mBAAmB,EAAE,aAAa,CAAC,qBAAqB,CAUpE,CAAA"}

package/dist/features/converters/lexicalToJSX/converter/converters/heading.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"heading.js","names":["HeadingJSXConverter","heading","node","nodesToJSX","children","nodes","NodeTag","tag","_jsx"],"sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/heading.tsx"],"sourcesContent":["import type { SerializedHeadingNode } from '../../../../../nodeTypes.js'\nimport type { JSXConverters } from '../types.js'\n\nexport const HeadingJSXConverter: JSXConverters<SerializedHeadingNode> = {\n  heading: ({ node, nodesToJSX }) => {\n    const children = nodesToJSX({\n      nodes: node.children,\n    })\n\n    const NodeTag = node.tag\n\n    return <NodeTag>{children}</NodeTag>\n  },\n}\n"],"mappings":";AAGA,OAAO,MAAMA,mBAAA,GAA4D;EACvEC,OAAA,EAASA,CAAC;IAAEC,IAAI;IAAEC;EAAU,CAAE;IAC5B,MAAMC,QAAA,GAAWD,UAAA,CAAW;MAC1BE,KAAA,EAAOH,IAAA,CAAKE;IACd;IAEA,MAAME,OAAA,GAAUJ,IAAA,CAAKK,GAAG;IAExB,oBAAOC,IAAA,CAACF,OAAA;gBAASF;;EACnB;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/converters/horizontalRule.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"horizontalRule.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/horizontalRule.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAA;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,eAAO,MAAM,0BAA0B,EAAE,aAAa,CAAC,4BAA4B,CAElF,CAAA"}

package/dist/features/converters/lexicalToJSX/converter/converters/horizontalRule.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"horizontalRule.js","names":["HorizontalRuleJSXConverter","horizontalrule","_jsx"],"sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/horizontalRule.tsx"],"sourcesContent":["import type { SerializedHorizontalRuleNode } from '../../../../../nodeTypes.js'\nimport type { JSXConverters } from '../types.js'\nexport const HorizontalRuleJSXConverter: JSXConverters<SerializedHorizontalRuleNode> = {\n  horizontalrule: <hr />,\n}\n"],"mappings":";AAEA,OAAO,MAAMA,0BAAA,GAA0E;EACrFC,cAAA,eAAgBC,IAAA,CAAC;AACnB","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/converters/linebreak.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"linebreak.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/linebreak.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,uBAAuB,CAExE,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"linebreak.js","names":["LinebreakJSXConverter","linebreak","_jsx"],"sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/linebreak.tsx"],"sourcesContent":["import type { SerializedLineBreakNode } from '../../../../../nodeTypes.js'\nimport type { JSXConverters } from '../types.js'\n\nexport const LinebreakJSXConverter: JSXConverters<SerializedLineBreakNode> = {\n  linebreak: <br />,\n}\n"],"mappings":";AAGA,OAAO,MAAMA,qBAAA,GAAgE;EAC3EC,SAAA,eAAWC,IAAA,CAAC;AACd","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/converters/link.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/link.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAC7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,gBAAgB,EAAE,CAAC,IAAI,EAAE;IACpC,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,kBAAkB,CAAA;KAAE,KAAK,MAAM,CAAA;CACvE,KAAK,aAAa,CAAC,sBAAsB,GAAG,kBAAkB,CAyC7D,CAAA"}

package/dist/features/converters/lexicalToJSX/converter/converters/link.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"link.js","names":["LinkJSXConverter","internalDocToHref","autolink","node","nodesToJSX","children","nodes","rel","fields","newTab","undefined","target","_jsx","href","url","link","linkType","linkNode","console","error"],"sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/link.tsx"],"sourcesContent":["import type { SerializedAutoLinkNode, SerializedLinkNode } from '../../../../../nodeTypes.js'\nimport type { JSXConverters } from '../types.js'\n\nexport const LinkJSXConverter: (args: {\n  internalDocToHref?: (args: { linkNode: SerializedLinkNode }) => string\n}) => JSXConverters<SerializedAutoLinkNode | SerializedLinkNode> = ({ internalDocToHref }) => ({\n  autolink: ({ node, nodesToJSX }) => {\n    const children = nodesToJSX({\n      nodes: node.children,\n    })\n\n    const rel: string | undefined = node.fields.newTab ? 'noopener noreferrer' : undefined\n    const target: string | undefined = node.fields.newTab ? '_blank' : undefined\n\n    return (\n      <a href={node.fields.url} {...{ rel, target }}>\n        {children}\n      </a>\n    )\n  },\n  link: ({ node, nodesToJSX }) => {\n    const children = nodesToJSX({\n      nodes: node.children,\n    })\n\n    const rel: string | undefined = node.fields.newTab ? 'noopener noreferrer' : undefined\n    const target: string | undefined = node.fields.newTab ? '_blank' : undefined\n\n    let href: string = node.fields.url ?? ''\n    if (node.fields.linkType === 'internal') {\n      if (internalDocToHref) {\n        href = internalDocToHref({ linkNode: node })\n      } else {\n        console.error(\n          'Lexical => JSX converter: Link converter: found internal link, but internalDocToHref is not provided',\n        )\n        href = '#' // fallback\n      }\n    }\n\n    return (\n      <a href={href} {...{ rel, target }}>\n        {children}\n      </a>\n    )\n  },\n})\n"],"mappings":";AAGA,OAAO,MAAMA,gBAAA,GAEsDA,CAAC;EAAEC;AAAiB,CAAE,MAAM;EAC7FC,QAAA,EAAUA,CAAC;IAAEC,IAAI;IAAEC;EAAU,CAAE;IAC7B,MAAMC,QAAA,GAAWD,UAAA,CAAW;MAC1BE,KAAA,EAAOH,IAAA,CAAKE;IACd;IAEA,MAAME,GAAA,GAA0BJ,IAAA,CAAKK,MAAM,CAACC,MAAM,GAAG,wBAAwBC,SAAA;IAC7E,MAAMC,MAAA,GAA6BR,IAAA,CAAKK,MAAM,CAACC,MAAM,GAAG,WAAWC,SAAA;IAEnE,oBACEE,IAAA,CAAC;MAAEC,IAAA,EAAMV,IAAA,CAAKK,MAAM,CAACM,GAAG;MAAQP,GAAA;MAAKI,MAAA;gBAClCN;;EAGP;EACAU,IAAA,EAAMA,CAAC;IAAEZ,IAAI;IAAEC;EAAU,CAAE;IACzB,MAAMC,QAAA,GAAWD,UAAA,CAAW;MAC1BE,KAAA,EAAOH,IAAA,CAAKE;IACd;IAEA,MAAME,GAAA,GAA0BJ,IAAA,CAAKK,MAAM,CAACC,MAAM,GAAG,wBAAwBC,SAAA;IAC7E,MAAMC,MAAA,GAA6BR,IAAA,CAAKK,MAAM,CAACC,MAAM,GAAG,WAAWC,SAAA;IAEnE,IAAIG,IAAA,GAAeV,IAAA,CAAKK,MAAM,CAACM,GAAG,IAAI;IACtC,IAAIX,IAAA,CAAKK,MAAM,CAACQ,QAAQ,KAAK,YAAY;MACvC,IAAIf,iBAAA,EAAmB;QACrBY,IAAA,GAAOZ,iBAAA,CAAkB;UAAEgB,QAAA,EAAUd;QAAK;MAC5C,OAAO;QACLe,OAAA,CAAQC,KAAK,CACX;QAEFN,IAAA,GAAO,IAAI;QAAA;MACb;IACF;IAEA,oBACED,IAAA,CAAC;MAAEC,IAAA,EAAMA,IAAA;MAAYN,GAAA;MAAKI,MAAA;gBACvBN;;EAGP;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/converters/list.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/list.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAC7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAAC,sBAAsB,GAAG,kBAAkB,CAqDvF,CAAA"}

package/dist/features/converters/lexicalToJSX/converter/converters/list.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"list.js","names":["v4","uuidv4","ListJSXConverter","list","node","nodesToJSX","children","nodes","NodeTag","tag","_jsx","className","listType","listitem","parent","hasSubLists","some","child","type","uuid","checked","role","style","listStyleType","tabIndex","value","_jsxs","_Fragment","id","readOnly","htmlFor","undefined"],"sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/list.tsx"],"sourcesContent":["import { v4 as uuidv4 } from 'uuid'\n\nimport type { SerializedListItemNode, SerializedListNode } from '../../../../../nodeTypes.js'\nimport type { JSXConverters } from '../types.js'\n\nexport const ListJSXConverter: JSXConverters<SerializedListItemNode | SerializedListNode> = {\n  list: ({ node, nodesToJSX }) => {\n    const children = nodesToJSX({\n      nodes: node.children,\n    })\n\n    const NodeTag = node.tag\n\n    return <NodeTag className={`list-${node?.listType}`}>{children}</NodeTag>\n  },\n  listitem: ({ node, nodesToJSX, parent }) => {\n    const hasSubLists = node.children.some((child) => child.type === 'list')\n\n    const children = nodesToJSX({\n      nodes: node.children,\n    })\n\n    if ('listType' in parent && parent?.listType === 'check') {\n      const uuid = uuidv4()\n\n      return (\n        <li\n          aria-checked={node.checked ? 'true' : 'false'}\n          className={`list-item-checkbox${node.checked ? ' list-item-checkbox-checked' : ' list-item-checkbox-unchecked'}${hasSubLists ? ' nestedListItem' : ''}`}\n          // eslint-disable-next-line jsx-a11y/no-noninteractive-element-to-interactive-role\n          role=\"checkbox\"\n          style={{ listStyleType: 'none' }}\n          tabIndex={-1}\n          value={node?.value}\n        >\n          {hasSubLists ? (\n            children\n          ) : (\n            <>\n              <input checked={node.checked} id={uuid} readOnly={true} type=\"checkbox\" />\n              <label htmlFor={uuid}>{children}</label>\n              <br />\n            </>\n          )}\n        </li>\n      )\n    } else {\n      return (\n        <li\n          className={`${hasSubLists ? 'nestedListItem' : ''}`}\n          style={hasSubLists ? { listStyleType: 'none' } : undefined}\n          value={node?.value}\n        >\n          {children}\n        </li>\n      )\n    }\n  },\n}\n"],"mappings":";AAAA,SAASA,EAAA,IAAMC,MAAM,QAAQ;AAK7B,OAAO,MAAMC,gBAAA,GAA+E;EAC1FC,IAAA,EAAMA,CAAC;IAAEC,IAAI;IAAEC;EAAU,CAAE;IACzB,MAAMC,QAAA,GAAWD,UAAA,CAAW;MAC1BE,KAAA,EAAOH,IAAA,CAAKE;IACd;IAEA,MAAME,OAAA,GAAUJ,IAAA,CAAKK,GAAG;IAExB,oBAAOC,IAAA,CAACF,OAAA;MAAQG,SAAA,EAAW,QAAQP,IAAA,EAAMQ,QAAA,EAAU;gBAAGN;;EACxD;EACAO,QAAA,EAAUA,CAAC;IAAET,IAAI;IAAEC,UAAU;IAAES;EAAM,CAAE;IACrC,MAAMC,WAAA,GAAcX,IAAA,CAAKE,QAAQ,CAACU,IAAI,CAAEC,KAAA,IAAUA,KAAA,CAAMC,IAAI,KAAK;IAEjE,MAAMZ,QAAA,GAAWD,UAAA,CAAW;MAC1BE,KAAA,EAAOH,IAAA,CAAKE;IACd;IAEA,IAAI,cAAcQ,MAAA,IAAUA,MAAA,EAAQF,QAAA,KAAa,SAAS;MACxD,MAAMO,IAAA,GAAOlB,MAAA;MAEb,oBACES,IAAA,CAAC;QACC,gBAAcN,IAAA,CAAKgB,OAAO,GAAG,SAAS;QACtCT,SAAA,EAAW,qBAAqBP,IAAA,CAAKgB,OAAO,GAAG,gCAAgC,kCAAkCL,WAAA,GAAc,oBAAoB,IAAI;QACvJ;QACAM,IAAA,EAAK;QACLC,KAAA,EAAO;UAAEC,aAAA,EAAe;QAAO;QAC/BC,QAAA,EAAU,CAAC;QACXC,KAAA,EAAOrB,IAAA,EAAMqB,KAAA;kBAEZV,WAAA,GACCT,QAAA,gBAEAoB,KAAA,CAAAC,SAAA;kCACEjB,IAAA,CAAC;YAAMU,OAAA,EAAShB,IAAA,CAAKgB,OAAO;YAAEQ,EAAA,EAAIT,IAAA;YAAMU,QAAA,EAAU;YAAMX,IAAA,EAAK;2BAC7DR,IAAA,CAAC;YAAMoB,OAAA,EAASX,IAAA;sBAAOb;2BACvBI,IAAA,CAAC;;;IAKX,OAAO;MACL,oBACEA,IAAA,CAAC;QACCC,SAAA,EAAW,GAAGI,WAAA,GAAc,mBAAmB,IAAI;QACnDO,KAAA,EAAOP,WAAA,GAAc;UAAEQ,aAAA,EAAe;QAAO,IAAIQ,SAAA;QACjDN,KAAA,EAAOrB,IAAA,EAAMqB,KAAA;kBAEZnB;;IAGP;EACF;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/converters/paragraph.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"paragraph.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/paragraph.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,uBAAuB,CAgBxE,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"paragraph.js","names":["ParagraphJSXConverter","paragraph","node","nodesToJSX","children","nodes","length","_jsx"],"sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/paragraph.tsx"],"sourcesContent":["import type { SerializedParagraphNode } from '../../../../../nodeTypes.js'\nimport type { JSXConverters } from '../types.js'\n\nexport const ParagraphJSXConverter: JSXConverters<SerializedParagraphNode> = {\n  paragraph: ({ node, nodesToJSX }) => {\n    const children = nodesToJSX({\n      nodes: node.children,\n    })\n\n    if (!children?.length) {\n      return (\n        <p>\n          <br />\n        </p>\n      )\n    }\n\n    return <p>{children}</p>\n  },\n}\n"],"mappings":";AAGA,OAAO,MAAMA,qBAAA,GAAgE;EAC3EC,SAAA,EAAWA,CAAC;IAAEC,IAAI;IAAEC;EAAU,CAAE;IAC9B,MAAMC,QAAA,GAAWD,UAAA,CAAW;MAC1BE,KAAA,EAAOH,IAAA,CAAKE;IACd;IAEA,IAAI,CAACA,QAAA,EAAUE,MAAA,EAAQ;MACrB,oBACEC,IAAA,CAAC;kBACC,aAAAA,IAAA,CAAC;;IAGP;IAEA,oBAAOA,IAAA,CAAC;gBAAGH;;EACb;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/converters/tab.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tab.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/tab.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,eAAe,EAAE,aAAa,CAAC,iBAAiB,CAE5D,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"tab.js","names":["TabJSXConverter","tab"],"sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/tab.tsx"],"sourcesContent":["import type { SerializedTabNode } from '../../../../../nodeTypes.js'\nimport type { JSXConverters } from '../types.js'\n\nexport const TabJSXConverter: JSXConverters<SerializedTabNode> = {\n  tab: '\\t',\n}\n"],"mappings":"AAGA,OAAO,MAAMA,eAAA,GAAoD;EAC/DC,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/converters/table.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/table.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,mBAAmB,EACnB,sBAAsB,EACvB,MAAM,6BAA6B,CAAA;AACpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAC3C,uBAAuB,GAAG,mBAAmB,GAAG,sBAAsB,CAgDvE,CAAA"}

package/dist/features/converters/lexicalToJSX/converter/converters/table.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"table.js","names":["TableJSXConverter","table","node","nodesToJSX","children","nodes","_jsx","className","style","borderCollapse","tablecell","TagName","headerState","headerStateClass","backgroundColor","undefined","border","padding","colSpan","rowSpan","tablerow"],"sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/table.tsx"],"sourcesContent":["import type {\n  SerializedTableCellNode,\n  SerializedTableNode,\n  SerializedTableRowNode,\n} from '../../../../../nodeTypes.js'\nimport type { JSXConverters } from '../types.js'\n\nexport const TableJSXConverter: JSXConverters<\n  SerializedTableCellNode | SerializedTableNode | SerializedTableRowNode\n> = {\n  table: ({ node, nodesToJSX }) => {\n    const children = nodesToJSX({\n      nodes: node.children,\n    })\n    return (\n      <div className=\"lexical-table-container\">\n        <table className=\"lexical-table\" style={{ borderCollapse: 'collapse' }}>\n          <tbody>{children}</tbody>\n        </table>\n      </div>\n    )\n  },\n  tablecell: ({ node, nodesToJSX }) => {\n    const children = nodesToJSX({\n      nodes: node.children,\n    })\n\n    const TagName = node.headerState > 0 ? 'th' : 'td' // Use capital letter to denote a component\n    const headerStateClass = `lexical-table-cell-header-${node.headerState}`\n    const style = {\n      backgroundColor: node.backgroundColor || undefined, // Use undefined to avoid setting the style property if not needed\n      border: '1px solid #ccc',\n      padding: '8px',\n    }\n\n    // Note: JSX does not support setting attributes directly as strings, so you must convert the colSpan and rowSpan to numbers\n    const colSpan = node.colSpan && node.colSpan > 1 ? node.colSpan : undefined\n    const rowSpan = node.rowSpan && node.rowSpan > 1 ? node.rowSpan : undefined\n\n    return (\n      <TagName\n        className={`lexical-table-cell ${headerStateClass}`}\n        colSpan={colSpan} // colSpan and rowSpan will only be added if they are not null\n        rowSpan={rowSpan}\n        style={style}\n      >\n        {children}\n      </TagName>\n    )\n  },\n  tablerow: ({ node, nodesToJSX }) => {\n    const children = nodesToJSX({\n      nodes: node.children,\n    })\n    return <tr className=\"lexical-table-row\">{children}</tr>\n  },\n}\n"],"mappings":";AAOA,OAAO,MAAMA,iBAAA,GAET;EACFC,KAAA,EAAOA,CAAC;IAAEC,IAAI;IAAEC;EAAU,CAAE;IAC1B,MAAMC,QAAA,GAAWD,UAAA,CAAW;MAC1BE,KAAA,EAAOH,IAAA,CAAKE;IACd;IACA,oBACEE,IAAA,CAAC;MAAIC,SAAA,EAAU;gBACb,aAAAD,IAAA,CAAC;QAAMC,SAAA,EAAU;QAAgBC,KAAA,EAAO;UAAEC,cAAA,EAAgB;QAAW;kBACnE,aAAAH,IAAA,CAAC;oBAAOF;;;;EAIhB;EACAM,SAAA,EAAWA,CAAC;IAAER,IAAI;IAAEC;EAAU,CAAE;IAC9B,MAAMC,QAAA,GAAWD,UAAA,CAAW;MAC1BE,KAAA,EAAOH,IAAA,CAAKE;IACd;IAEA,MAAMO,OAAA,GAAUT,IAAA,CAAKU,WAAW,GAAG,IAAI,OAAO,KAAK;IAAA;IACnD,MAAMC,gBAAA,GAAmB,6BAA6BX,IAAA,CAAKU,WAAW,EAAE;IACxE,MAAMJ,KAAA,GAAQ;MACZM,eAAA,EAAiBZ,IAAA,CAAKY,eAAe,IAAIC,SAAA;MACzCC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;IAEA;IACA,MAAMC,OAAA,GAAUhB,IAAA,CAAKgB,OAAO,IAAIhB,IAAA,CAAKgB,OAAO,GAAG,IAAIhB,IAAA,CAAKgB,OAAO,GAAGH,SAAA;IAClE,MAAMI,OAAA,GAAUjB,IAAA,CAAKiB,OAAO,IAAIjB,IAAA,CAAKiB,OAAO,GAAG,IAAIjB,IAAA,CAAKiB,OAAO,GAAGJ,SAAA;IAElE,oBACET,IAAA,CAACK,OAAA;MACCJ,SAAA,EAAW,sBAAsBM,gBAAA,EAAkB;MACnDK,OAAA,EAASA,OAAA;MACTC,OAAA,EAASA,OAAA;MACTX,KAAA,EAAOA,KAAA;gBAENJ;;EAGP;EACAgB,QAAA,EAAUA,CAAC;IAAElB,IAAI;IAAEC;EAAU,CAAE;IAC7B,MAAMC,QAAA,GAAWD,UAAA,CAAW;MAC1BE,KAAA,EAAOH,IAAA,CAAKE;IACd;IACA,oBAAOE,IAAA,CAAC;MAAGC,SAAA,EAAU;gBAAqBH;;EAC5C;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/converters/text.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/text.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAIhD,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAAC,kBAAkB,CA4B9D,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"text.js","names":["React","NodeFormat","TextJSXConverter","text","node","format","IS_BOLD","_jsx","IS_ITALIC","IS_STRIKETHROUGH","style","textDecoration","IS_UNDERLINE","IS_CODE","IS_SUBSCRIPT","IS_SUPERSCRIPT"],"sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/text.tsx"],"sourcesContent":["import React from 'react'\n\nimport type { SerializedTextNode } from '../../../../../nodeTypes.js'\nimport type { JSXConverters } from '../types.js'\n\nimport { NodeFormat } from '../../../../../lexical/utils/nodeFormat.js'\n\nexport const TextJSXConverter: JSXConverters<SerializedTextNode> = {\n  text: ({ node }) => {\n    let text: React.ReactNode = 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={{ textDecoration: 'line-through' }}>{text}</span>\n    }\n    if (node.format & NodeFormat.IS_UNDERLINE) {\n      text = <span style={{ textDecoration: '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}\n"],"mappings":";AAAA,OAAOA,KAAA,MAAW;AAKlB,SAASC,UAAU,QAAQ;AAE3B,OAAO,MAAMC,gBAAA,GAAsD;EACjEC,IAAA,EAAMA,CAAC;IAAEC;EAAI,CAAE;IACb,IAAID,IAAA,GAAwBC,IAAA,CAAKD,IAAI;IAErC,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWK,OAAO,EAAE;MACpCH,IAAA,gBAAOI,IAAA,CAAC;kBAAQJ;;IAClB;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWO,SAAS,EAAE;MACtCL,IAAA,gBAAOI,IAAA,CAAC;kBAAIJ;;IACd;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWQ,gBAAgB,EAAE;MAC7CN,IAAA,gBAAOI,IAAA,CAAC;QAAKG,KAAA,EAAO;UAAEC,cAAA,EAAgB;QAAe;kBAAIR;;IAC3D;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWW,YAAY,EAAE;MACzCT,IAAA,gBAAOI,IAAA,CAAC;QAAKG,KAAA,EAAO;UAAEC,cAAA,EAAgB;QAAY;kBAAIR;;IACxD;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWY,OAAO,EAAE;MACpCV,IAAA,gBAAOI,IAAA,CAAC;kBAAMJ;;IAChB;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWa,YAAY,EAAE;MACzCX,IAAA,gBAAOI,IAAA,CAAC;kBAAKJ;;IACf;IACA,IAAIC,IAAA,CAAKC,MAAM,GAAGJ,UAAA,CAAWc,cAAc,EAAE;MAC3CZ,IAAA,gBAAOI,IAAA,CAAC;kBAAKJ;;IACf;IAEA,OAAOA,IAAA;EACT;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/converters/upload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/upload.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,oBAAoB,CA6ElE,CAAA"}

package/dist/features/converters/lexicalToJSX/converter/converters/upload.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"upload.js","names":["UploadJSXConverter","upload","node","uploadNode","value","uploadDoc","url","mimeType","startsWith","_jsx","href","rel","filename","sizes","Object","keys","length","alt","height","src","width","pictureJSX","size","imageSize","filesize","imageSizeURL","push","media","srcSet","type"],"sources":["../../../../../../src/features/converters/lexicalToJSX/converter/converters/upload.tsx"],"sourcesContent":["import type { FileData, FileSizeImproved, TypeWithID } from 'payload'\n\nimport type { SerializedUploadNode } from '../../../../../nodeTypes.js'\nimport type { UploadDataImproved } from '../../../../upload/server/nodes/UploadNode.js'\nimport type { JSXConverters } from '../types.js'\n\nexport const UploadJSXConverter: JSXConverters<SerializedUploadNode> = {\n  upload: ({ node }) => {\n    // TO-DO (v4): SerializedUploadNode should use UploadData_P4\n    const uploadNode = node as UploadDataImproved\n    if (typeof uploadNode.value !== 'object') {\n      return null\n    }\n\n    const uploadDoc = uploadNode.value as FileData & TypeWithID\n\n    const url = uploadDoc.url\n\n    /**\n     * If the upload is not an image, return a link to the upload\n     */\n    if (!uploadDoc.mimeType.startsWith('image')) {\n      return (\n        <a href={url} rel=\"noopener noreferrer\">\n          {uploadDoc.filename}\n        </a>\n      )\n    }\n\n    /**\n     * If the upload is a simple image with no different sizes, return a simple img tag\n     */\n    if (!uploadDoc.sizes || !Object.keys(uploadDoc.sizes).length) {\n      return (\n        <img alt={uploadDoc.filename} height={uploadDoc.height} src={url} width={uploadDoc.width} />\n      )\n    }\n\n    /**\n     * If the upload is an image with different sizes, return a picture element\n     */\n    const pictureJSX: React.ReactNode[] = []\n\n    // Iterate through each size in the data.sizes object\n    for (const size in uploadDoc.sizes) {\n      const imageSize = uploadDoc.sizes[size] as FileSizeImproved\n\n      // Skip if any property of the size object is null\n      if (\n        !imageSize ||\n        !imageSize.width ||\n        !imageSize.height ||\n        !imageSize.mimeType ||\n        !imageSize.filesize ||\n        !imageSize.filename ||\n        !imageSize.url\n      ) {\n        continue\n      }\n      const imageSizeURL = imageSize?.url\n\n      pictureJSX.push(\n        <source\n          key={size}\n          media={`(max-width: ${imageSize.width}px)`}\n          srcSet={imageSizeURL}\n          type={imageSize.mimeType}\n        />,\n      )\n    }\n\n    // Add the default img tag\n    pictureJSX.push(\n      <img\n        alt={uploadDoc?.filename}\n        height={uploadDoc?.height}\n        key={'image'}\n        src={url}\n        width={uploadDoc?.width}\n      />,\n    )\n    return <picture>{pictureJSX}</picture>\n  },\n}\n"],"mappings":";AAMA,OAAO,MAAMA,kBAAA,GAA0D;EACrEC,MAAA,EAAQA,CAAC;IAAEC;EAAI,CAAE;IACf;IACA,MAAMC,UAAA,GAAaD,IAAA;IACnB,IAAI,OAAOC,UAAA,CAAWC,KAAK,KAAK,UAAU;MACxC,OAAO;IACT;IAEA,MAAMC,SAAA,GAAYF,UAAA,CAAWC,KAAK;IAElC,MAAME,GAAA,GAAMD,SAAA,CAAUC,GAAG;IAEzB;;;IAGA,IAAI,CAACD,SAAA,CAAUE,QAAQ,CAACC,UAAU,CAAC,UAAU;MAC3C,oBACEC,IAAA,CAAC;QAAEC,IAAA,EAAMJ,GAAA;QAAKK,GAAA,EAAI;kBACfN,SAAA,CAAUO;;IAGjB;IAEA;;;IAGA,IAAI,CAACP,SAAA,CAAUQ,KAAK,IAAI,CAACC,MAAA,CAAOC,IAAI,CAACV,SAAA,CAAUQ,KAAK,EAAEG,MAAM,EAAE;MAC5D,oBACEP,IAAA,CAAC;QAAIQ,GAAA,EAAKZ,SAAA,CAAUO,QAAQ;QAAEM,MAAA,EAAQb,SAAA,CAAUa,MAAM;QAAEC,GAAA,EAAKb,GAAA;QAAKc,KAAA,EAAOf,SAAA,CAAUe;;IAEvF;IAEA;;;IAGA,MAAMC,UAAA,GAAgC,EAAE;IAExC;IACA,KAAK,MAAMC,IAAA,IAAQjB,SAAA,CAAUQ,KAAK,EAAE;MAClC,MAAMU,SAAA,GAAYlB,SAAA,CAAUQ,KAAK,CAACS,IAAA,CAAK;MAEvC;MACA,IACE,CAACC,SAAA,IACD,CAACA,SAAA,CAAUH,KAAK,IAChB,CAACG,SAAA,CAAUL,MAAM,IACjB,CAACK,SAAA,CAAUhB,QAAQ,IACnB,CAACgB,SAAA,CAAUC,QAAQ,IACnB,CAACD,SAAA,CAAUX,QAAQ,IACnB,CAACW,SAAA,CAAUjB,GAAG,EACd;QACA;MACF;MACA,MAAMmB,YAAA,GAAeF,SAAA,EAAWjB,GAAA;MAEhCe,UAAA,CAAWK,IAAI,cACbjB,IAAA,CAAC;QAECkB,KAAA,EAAO,eAAeJ,SAAA,CAAUH,KAAK,KAAK;QAC1CQ,MAAA,EAAQH,YAAA;QACRI,IAAA,EAAMN,SAAA,CAAUhB;SAHXe,IAAA;IAMX;IAEA;IACAD,UAAA,CAAWK,IAAI,cACbjB,IAAA,CAAC;MACCQ,GAAA,EAAKZ,SAAA,EAAWO,QAAA;MAChBM,MAAA,EAAQb,SAAA,EAAWa,MAAA;MAEnBC,GAAA,EAAKb,GAAA;MACLc,KAAA,EAAOf,SAAA,EAAWe;OAFb;IAKT,oBAAOX,IAAA,CAAC;gBAASY;;EACnB;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/defaultConverters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToJSX/converter/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAc/C,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC,gBAAgB,CAYhE,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"defaultConverters.js","names":["BlockquoteJSXConverter","HeadingJSXConverter","HorizontalRuleJSXConverter","LinebreakJSXConverter","LinkJSXConverter","ListJSXConverter","ParagraphJSXConverter","TabJSXConverter","TableJSXConverter","TextJSXConverter","UploadJSXConverter","defaultJSXConverters"],"sources":["../../../../../src/features/converters/lexicalToJSX/converter/defaultConverters.ts"],"sourcesContent":["import type { DefaultNodeTypes } from '../../../../nodeTypes.js'\nimport type { JSXConverters } from './types.js'\n\nimport { BlockquoteJSXConverter } from './converters/blockquote.js'\nimport { HeadingJSXConverter } from './converters/heading.js'\nimport { HorizontalRuleJSXConverter } from './converters/horizontalRule.js'\nimport { LinebreakJSXConverter } from './converters/linebreak.js'\nimport { LinkJSXConverter } from './converters/link.js'\nimport { ListJSXConverter } from './converters/list.js'\nimport { ParagraphJSXConverter } from './converters/paragraph.js'\nimport { TabJSXConverter } from './converters/tab.js'\nimport { TableJSXConverter } from './converters/table.js'\nimport { TextJSXConverter } from './converters/text.js'\nimport { UploadJSXConverter } from './converters/upload.js'\n\nexport const defaultJSXConverters: JSXConverters<DefaultNodeTypes> = {\n  ...ParagraphJSXConverter,\n  ...TextJSXConverter,\n  ...LinebreakJSXConverter,\n  ...BlockquoteJSXConverter,\n  ...TableJSXConverter,\n  ...HeadingJSXConverter,\n  ...HorizontalRuleJSXConverter,\n  ...ListJSXConverter,\n  ...LinkJSXConverter({}),\n  ...UploadJSXConverter,\n  ...TabJSXConverter,\n}\n"],"mappings":"AAGA,SAASA,sBAAsB,QAAQ;AACvC,SAASC,mBAAmB,QAAQ;AACpC,SAASC,0BAA0B,QAAQ;AAC3C,SAASC,qBAAqB,QAAQ;AACtC,SAASC,gBAAgB,QAAQ;AACjC,SAASC,gBAAgB,QAAQ;AACjC,SAASC,qBAAqB,QAAQ;AACtC,SAASC,eAAe,QAAQ;AAChC,SAASC,iBAAiB,QAAQ;AAClC,SAASC,gBAAgB,QAAQ;AACjC,SAASC,kBAAkB,QAAQ;AAEnC,OAAO,MAAMC,oBAAA,GAAwD;EACnE,GAAGL,qBAAqB;EACxB,GAAGG,gBAAgB;EACnB,GAAGN,qBAAqB;EACxB,GAAGH,sBAAsB;EACzB,GAAGQ,iBAAiB;EACpB,GAAGP,mBAAmB;EACtB,GAAGC,0BAA0B;EAC7B,GAAGG,gBAAgB;EACnB,GAAGD,gBAAA,CAAiB,CAAC,EAAE;EACvB,GAAGM,kBAAkB;EACrB,GAAGH;AACL","ignoreList":[]}

package/dist/features/converters/lexicalToJSX/converter/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToJSX/converter/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAE3E,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,KAAK,EAAgB,aAAa,EAAE,+BAA+B,EAAE,MAAM,YAAY,CAAA;AAI9F,MAAM,MAAM,uBAAuB,GAAG;IACpC,UAAU,EAAE,aAAa,CAAA;IACzB,IAAI,EAAE,qBAAqB,CAAA;IAC3B,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;IAClC,gBAAgB,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;CACtC,CAAA;AAED,wBAAgB,mBAAmB,CAAC,EAClC,UAAU,EACV,IAAI,EACJ,aAAa,EACb,gBAAgB,GACjB,EAAE,uBAAuB,GAAG,KAAK,CAAC,SAAS,CAW3C;AAED,wBAAgB,wBAAwB,CAAC,EACvC,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,KAAK,EACL,MAAM,GACP,EAAE;IACD,UAAU,EAAE,aAAa,CAAA;IACzB,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;IAClC,gBAAgB,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAA;IACrC,KAAK,EAAE,qBAAqB,EAAE,CAAA;IAC9B,MAAM,EAAE,+BAA+B,CAAA;CACxC,GAAG,KAAK,CAAC,SAAS,EAAE,CA+HpB"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["React","hasText","convertLexicalToJSX","converters","data","disableIndent","disableTextAlign","convertLexicalNodesToJSX","nodes","root","children","parent","_jsx","_Fragment","unknownConverter","unknown","jsxArray","map","node","i","converterForNode","type","blocks","fields","blockType","console","error","inlineBlocks","reactNode","converted","childIndex","nodesToJSX","args","style","Array","isArray","includes","format","textAlign","indent","paddingInlineStart","Number","isValidElement","newStyle","props","cloneElement","key","filter","Boolean"],"sources":["../../../../../src/features/converters/lexicalToJSX/converter/index.tsx"],"sourcesContent":["import type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nimport React from 'react'\n\nimport type { SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js'\nimport type { JSXConverter, JSXConverters, SerializedLexicalNodeWithParent } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\n\nexport type ConvertLexicalToJSXArgs = {\n  converters: JSXConverters\n  data: SerializedEditorState\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n}\n\nexport function convertLexicalToJSX({\n  converters,\n  data,\n  disableIndent,\n  disableTextAlign,\n}: ConvertLexicalToJSXArgs): React.ReactNode {\n  if (hasText(data)) {\n    return convertLexicalNodesToJSX({\n      converters,\n      disableIndent,\n      disableTextAlign,\n      nodes: data?.root?.children,\n      parent: data?.root,\n    })\n  }\n  return <></>\n}\n\nexport function convertLexicalNodesToJSX({\n  converters,\n  disableIndent,\n  disableTextAlign,\n  nodes,\n  parent,\n}: {\n  converters: JSXConverters\n  disableIndent?: boolean | string[]\n  disableTextAlign?: boolean | string[]\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n}): React.ReactNode[] {\n  const unknownConverter: JSXConverter<any> = converters.unknown as JSXConverter<any>\n\n  const jsxArray: React.ReactNode[] = nodes.map((node, i) => {\n    let converterForNode: JSXConverter<any> | undefined\n    if (node.type === 'block') {\n      converterForNode = converters?.blocks?.[(node as SerializedBlockNode)?.fields?.blockType]\n      if (!converterForNode) {\n        console.error(\n          `Lexical => JSX 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 =\n        converters?.inlineBlocks?.[(node as SerializedInlineBlockNode)?.fields?.blockType]\n      if (!converterForNode) {\n        console.error(\n          `Lexical => JSX 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 JSXConverter<any>\n    }\n\n    try {\n      if (!converterForNode && unknownConverter) {\n        converterForNode = unknownConverter\n      }\n\n      let reactNode: React.ReactNode\n      if (converterForNode) {\n        const converted =\n          typeof converterForNode === 'function'\n            ? converterForNode({\n                childIndex: i,\n                converters,\n                node,\n                nodesToJSX: (args) => {\n                  return convertLexicalNodesToJSX({\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              })\n            : converterForNode\n        reactNode = converted\n      } else {\n        reactNode = <span key={i}>unknown node</span>\n      }\n\n      const style: React.CSSProperties = {}\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.textAlign = 'center'\n              break\n            case 'end':\n              style.textAlign = 'right'\n              break\n            case 'justify':\n              style.textAlign = 'justify'\n              break\n            case 'left':\n              //style.textAlign = 'left'\n              // Do nothing, as left is the default\n              break\n            case 'right':\n              style.textAlign = 'right'\n              break\n            case 'start':\n              style.textAlign = 'left'\n              break\n          }\n        }\n      }\n\n      if (\n        !disableIndent &&\n        (!Array.isArray(disableIndent) || !disableIndent?.includes(node.type))\n      ) {\n        if ('indent' in node && node.indent && node.type !== 'listitem') {\n          style.paddingInlineStart = `${Number(node.indent) * 2}em`\n        }\n      }\n\n      if (React.isValidElement(reactNode)) {\n        // Inject style into reactNode\n        if (style.textAlign || style.paddingInlineStart) {\n          const newStyle = {\n            ...style,\n            // @ts-expect-error type better later\n            ...(reactNode?.props?.style ?? {}),\n            // reactNode style comes after, thus a textAlign specified in the converter has priority over the one we inject here\n          }\n\n          return React.cloneElement(reactNode, {\n            key: i,\n            // @ts-expect-error type better later\n            style: newStyle,\n          })\n        }\n        return React.cloneElement(reactNode, {\n          key: i,\n        })\n      }\n\n      return reactNode\n    } catch (error) {\n      console.error('Error converting lexical node to JSX:', error, 'node:', node)\n      return null\n    }\n  })\n\n  return jsxArray.filter(Boolean)\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToJSX/converter/types.ts"],"names":[],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToJSX/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nexport type JSXConverter<T extends { [key: string]: any; type?: string } = SerializedLexicalNode> =\n  | ((args: {\n      childIndex: number\n      converters: JSXConverters\n      node: T\n      nodesToJSX: (args: {\n        converters?: JSXConverters\n        disableIndent?: boolean | string[]\n        disableTextAlign?: boolean | string[]\n        nodes: SerializedLexicalNode[]\n        parent?: SerializedLexicalNodeWithParent\n      }) => React.ReactNode[]\n      parent: SerializedLexicalNodeWithParent\n    }) => React.ReactNode)\n  | React.ReactNode\n\nexport type JSXConverters<\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]: JSXConverter<any>\n      }\n    | JSXConverter<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: JSXConverter<\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    >]?: JSXConverter<\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    >]?: JSXConverter<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n}\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"mappings":"AAqEA","ignoreList":[]}

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

@@ -1,7 +0,0 @@
-import type { SerializedEditorState } from 'lexical';
-import type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js';
-export declare const convertLexicalToMarkdown: ({ data, editorConfig, }: {
-    data: SerializedEditorState;
-    editorConfig: SanitizedServerEditorConfig;
-}) => string;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/lexicalToMarkdown/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAIpD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAA;AAKnF,eAAO,MAAM,wBAAwB,4BAGlC;IACD,IAAI,EAAE,qBAAqB,CAAA;IAC3B,YAAY,EAAE,2BAA2B,CAAA;CAC1C,KAAG,MAoBH,CAAA"}

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

@@ -1,24 +0,0 @@
-import { createHeadlessEditor } from '@lexical/headless';
-import { getEnabledNodes } from '../../../lexical/nodes/index.js';
-import { $convertToMarkdownString } from '../../../packages/@lexical/markdown/index.js';
-export const convertLexicalToMarkdown = ({
-  data,
-  editorConfig
-}) => {
-  const headlessEditor = createHeadlessEditor({
-    nodes: getEnabledNodes({
-      editorConfig
-    })
-  });
-  headlessEditor.update(() => {
-    headlessEditor.setEditorState(headlessEditor.parseEditorState(data));
-  }, {
-    discrete: true
-  });
-  let markdown = '';
-  headlessEditor.getEditorState().read(() => {
-    markdown = $convertToMarkdownString(editorConfig?.features?.markdownTransformers);
-  });
-  return markdown;
-};
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["createHeadlessEditor","getEnabledNodes","$convertToMarkdownString","convertLexicalToMarkdown","data","editorConfig","headlessEditor","nodes","update","setEditorState","parseEditorState","discrete","markdown","getEditorState","read","features","markdownTransformers"],"sources":["../../../../src/features/converters/lexicalToMarkdown/index.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js'\n\nimport { getEnabledNodes } from '../../../lexical/nodes/index.js'\nimport { $convertToMarkdownString } from '../../../packages/@lexical/markdown/index.js'\n\nexport const convertLexicalToMarkdown = ({\n  data,\n  editorConfig,\n}: {\n  data: SerializedEditorState\n  editorConfig: SanitizedServerEditorConfig\n}): string => {\n  const headlessEditor = createHeadlessEditor({\n    nodes: getEnabledNodes({\n      editorConfig,\n    }),\n  })\n\n  headlessEditor.update(\n    () => {\n      headlessEditor.setEditorState(headlessEditor.parseEditorState(data))\n    },\n    { discrete: true },\n  )\n\n  let markdown: string = ''\n  headlessEditor.getEditorState().read(() => {\n    markdown = $convertToMarkdownString(editorConfig?.features?.markdownTransformers)\n  })\n\n  return markdown\n}\n"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ;AAIrC,SAASC,eAAe,QAAQ;AAChC,SAASC,wBAAwB,QAAQ;AAEzC,OAAO,MAAMC,wBAAA,GAA2BA,CAAC;EACvCC,IAAI;EACJC;AAAY,CAIb;EACC,MAAMC,cAAA,GAAiBN,oBAAA,CAAqB;IAC1CO,KAAA,EAAON,eAAA,CAAgB;MACrBI;IACF;EACF;EAEAC,cAAA,CAAeE,MAAM,CACnB;IACEF,cAAA,CAAeG,cAAc,CAACH,cAAA,CAAeI,gBAAgB,CAACN,IAAA;EAChE,GACA;IAAEO,QAAA,EAAU;EAAK;EAGnB,IAAIC,QAAA,GAAmB;EACvBN,cAAA,CAAeO,cAAc,GAAGC,IAAI,CAAC;IACnCF,QAAA,GAAWV,wBAAA,CAAyBG,YAAA,EAAcU,QAAA,EAAUC,oBAAA;EAC9D;EAEA,OAAOJ,QAAA;AACT","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/convertLexicalToPlaintext.spec.js

@@ -1,84 +0,0 @@
-import { convertLexicalToPlaintext } from './sync/index.js';
-function textNode(text, bold) {
-  return {
-    type: 'text',
-    detail: 0,
-    format: bold ? 1 : 0,
-    mode: 'normal',
-    style: '',
-    text,
-    version: 1
-  };
-}
-function linebreakNode() {
-  return {
-    type: 'linebreak',
-    version: 1
-  };
-}
-function tabNode() {
-  return {
-    type: 'tab',
-    detail: 0,
-    format: 0,
-    mode: 'normal',
-    style: '',
-    text: '',
-    version: 1
-  };
-}
-function paragraphNode(children) {
-  return {
-    type: 'paragraph',
-    children,
-    direction: 'ltr',
-    format: '',
-    indent: 0,
-    textFormat: 0,
-    version: 1
-  };
-}
-function rootNode(nodes) {
-  return {
-    root: {
-      type: 'root',
-      children: nodes,
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      version: 1
-    }
-  };
-}
-describe('convertLexicalToPlaintext', () => {
-  it('ensure paragraph with text is correctly converted', () => {
-    const data = rootNode([paragraphNode([textNode('Basic Text')])]);
-    const plaintext = convertLexicalToPlaintext({
-      data
-    });
-    console.log('plaintext', plaintext);
-    expect(plaintext).toBe('Basic Text');
-  });
-  it('ensure paragraph with multiple text nodes is correctly converted', () => {
-    const data = rootNode([paragraphNode([textNode('Basic Text'), textNode(' Bold', true), textNode(' Text')])]);
-    const plaintext = convertLexicalToPlaintext({
-      data
-    });
-    expect(plaintext).toBe('Basic Text Bold Text');
-  });
-  it('ensure linebreaks are converted correctly', () => {
-    const data = rootNode([paragraphNode([textNode('Basic Text'), linebreakNode(), textNode('Next Line')])]);
-    const plaintext = convertLexicalToPlaintext({
-      data
-    });
-    expect(plaintext).toBe('Basic Text\nNext Line');
-  });
-  it('ensure tabs are converted correctly', () => {
-    const data = rootNode([paragraphNode([textNode('Basic Text'), tabNode(), textNode('Next Line')])]);
-    const plaintext = convertLexicalToPlaintext({
-      data
-    });
-    expect(plaintext).toBe('Basic Text\tNext Line');
-  });
-});
-//# sourceMappingURL=convertLexicalToPlaintext.spec.js.map

package/dist/features/converters/lexicalToPlaintext/convertLexicalToPlaintext.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"convertLexicalToPlaintext.spec.js","names":["convertLexicalToPlaintext","textNode","text","bold","type","detail","format","mode","style","version","linebreakNode","tabNode","paragraphNode","children","direction","indent","textFormat","rootNode","nodes","root","describe","it","data","plaintext","console","log","expect","toBe"],"sources":["../../../../src/features/converters/lexicalToPlaintext/convertLexicalToPlaintext.spec.ts"],"sourcesContent":["import type {\n  DefaultNodeTypes,\n  DefaultTypedEditorState,\n  SerializedTabNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n  SerializedLineBreakNode,\n} from '../../../nodeTypes.js'\nimport { convertLexicalToPlaintext } from './sync/index.js'\n\nfunction textNode(text: string, bold?: boolean): SerializedTextNode {\n  return {\n    type: 'text',\n    detail: 0,\n    format: bold ? 1 : 0,\n    mode: 'normal',\n    style: '',\n    text,\n    version: 1,\n  }\n}\n\nfunction linebreakNode(): SerializedLineBreakNode {\n  return {\n    type: 'linebreak',\n    version: 1,\n  }\n}\n\nfunction tabNode(): SerializedTabNode {\n  return {\n    type: 'tab',\n    detail: 0,\n    format: 0,\n    mode: 'normal',\n    style: '',\n    text: '',\n    version: 1,\n  }\n}\n\nfunction paragraphNode(children: DefaultNodeTypes[]): SerializedParagraphNode {\n  return {\n    type: 'paragraph',\n    children,\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    textFormat: 0,\n    version: 1,\n  }\n}\n\nfunction rootNode(nodes: DefaultNodeTypes[]): DefaultTypedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: nodes,\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n}\n\ndescribe('convertLexicalToPlaintext', () => {\n  it('ensure paragraph with text is correctly converted', () => {\n    const data: DefaultTypedEditorState = rootNode([paragraphNode([textNode('Basic Text')])])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    console.log('plaintext', plaintext)\n    expect(plaintext).toBe('Basic Text')\n  })\n\n  it('ensure paragraph with multiple text nodes is correctly converted', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      paragraphNode([textNode('Basic Text'), textNode(' Bold', true), textNode(' Text')]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('Basic Text Bold Text')\n  })\n\n  it('ensure linebreaks are converted correctly', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      paragraphNode([textNode('Basic Text'), linebreakNode(), textNode('Next Line')]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('Basic Text\\nNext Line')\n  })\n\n  it('ensure tabs are converted correctly', () => {\n    const data: DefaultTypedEditorState = rootNode([\n      paragraphNode([textNode('Basic Text'), tabNode(), textNode('Next Line')]),\n    ])\n\n    const plaintext = convertLexicalToPlaintext({\n      data,\n    })\n\n    expect(plaintext).toBe('Basic Text\\tNext Line')\n  })\n})\n"],"mappings":"AAQA,SAASA,yBAAyB,QAAQ;AAE1C,SAASC,SAASC,IAAY,EAAEC,IAAc;EAC5C,OAAO;IACLC,IAAA,EAAM;IACNC,MAAA,EAAQ;IACRC,MAAA,EAAQH,IAAA,GAAO,IAAI;IACnBI,IAAA,EAAM;IACNC,KAAA,EAAO;IACPN,IAAA;IACAO,OAAA,EAAS;EACX;AACF;AAEA,SAASC,cAAA;EACP,OAAO;IACLN,IAAA,EAAM;IACNK,OAAA,EAAS;EACX;AACF;AAEA,SAASE,QAAA;EACP,OAAO;IACLP,IAAA,EAAM;IACNC,MAAA,EAAQ;IACRC,MAAA,EAAQ;IACRC,IAAA,EAAM;IACNC,KAAA,EAAO;IACPN,IAAA,EAAM;IACNO,OAAA,EAAS;EACX;AACF;AAEA,SAASG,cAAcC,QAA4B;EACjD,OAAO;IACLT,IAAA,EAAM;IACNS,QAAA;IACAC,SAAA,EAAW;IACXR,MAAA,EAAQ;IACRS,MAAA,EAAQ;IACRC,UAAA,EAAY;IACZP,OAAA,EAAS;EACX;AACF;AAEA,SAASQ,SAASC,KAAyB;EACzC,OAAO;IACLC,IAAA,EAAM;MACJf,IAAA,EAAM;MACNS,QAAA,EAAUK,KAAA;MACVJ,SAAA,EAAW;MACXR,MAAA,EAAQ;MACRS,MAAA,EAAQ;MACRN,OAAA,EAAS;IACX;EACF;AACF;AAEAW,QAAA,CAAS,6BAA6B;EACpCC,EAAA,CAAG,qDAAqD;IACtD,MAAMC,IAAA,GAAgCL,QAAA,CAAS,CAACL,aAAA,CAAc,CAACX,QAAA,CAAS,cAAc,EAAE;IAExF,MAAMsB,SAAA,GAAYvB,yBAAA,CAA0B;MAC1CsB;IACF;IAEAE,OAAA,CAAQC,GAAG,CAAC,aAAaF,SAAA;IACzBG,MAAA,CAAOH,SAAA,EAAWI,IAAI,CAAC;EACzB;EAEAN,EAAA,CAAG,oEAAoE;IACrE,MAAMC,IAAA,GAAgCL,QAAA,CAAS,CAC7CL,aAAA,CAAc,CAACX,QAAA,CAAS,eAAeA,QAAA,CAAS,SAAS,OAAOA,QAAA,CAAS,SAAS,EACnF;IAED,MAAMsB,SAAA,GAAYvB,yBAAA,CAA0B;MAC1CsB;IACF;IAEAI,MAAA,CAAOH,SAAA,EAAWI,IAAI,CAAC;EACzB;EAEAN,EAAA,CAAG,6CAA6C;IAC9C,MAAMC,IAAA,GAAgCL,QAAA,CAAS,CAC7CL,aAAA,CAAc,CAACX,QAAA,CAAS,eAAeS,aAAA,IAAiBT,QAAA,CAAS,aAAa,EAC/E;IAED,MAAMsB,SAAA,GAAYvB,yBAAA,CAA0B;MAC1CsB;IACF;IAEAI,MAAA,CAAOH,SAAA,EAAWI,IAAI,CAAC;EACzB;EAEAN,EAAA,CAAG,uCAAuC;IACxC,MAAMC,IAAA,GAAgCL,QAAA,CAAS,CAC7CL,aAAA,CAAc,CAACX,QAAA,CAAS,eAAeU,OAAA,IAAWV,QAAA,CAAS,aAAa,EACzE;IAED,MAAMsB,SAAA,GAAYvB,yBAAA,CAA0B;MAC1CsB;IACF;IAEAI,MAAA,CAAOH,SAAA,EAAWI,IAAI,CAAC;EACzB;AACF","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/shared/findConverterForNode.d.ts

@@ -1,7 +0,0 @@
-import type { SerializedLexicalNode } from 'lexical';
-import type { PlaintextConverter, PlaintextConverters } from '../sync/types.js';
-export declare function findConverterForNode<TConverters extends PlaintextConverters, TConverter extends PlaintextConverter<any>>({ converters, node, }: {
-    converters: TConverters;
-    node: SerializedLexicalNode;
-}): TConverter | undefined;
-//# sourceMappingURL=findConverterForNode.d.ts.map

package/dist/features/converters/lexicalToPlaintext/shared/findConverterForNode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"findConverterForNode.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/findConverterForNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAGpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAE/E,wBAAgB,oBAAoB,CAClC,WAAW,SAAS,mBAAmB,EACvC,UAAU,SAAS,kBAAkB,CAAC,GAAG,CAAC,EAC1C,EACA,UAAU,EAEV,IAAI,GACL,EAAE;IACD,UAAU,EAAE,WAAW,CAAA;IACvB,IAAI,EAAE,qBAAqB,CAAA;CAC5B,GAAG,UAAU,GAAG,SAAS,CAezB"}

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

@@ -1,15 +0,0 @@
-export function findConverterForNode({
-  converters,
-  node
-}) {
-  let converterForNode;
-  if (node.type === 'block') {
-    converterForNode = converters?.blocks?.[node?.fields?.blockType];
-  } else if (node.type === 'inlineBlock') {
-    converterForNode = converters?.inlineBlocks?.[node?.fields?.blockType];
-  } else {
-    converterForNode = converters[node.type];
-  }
-  return converterForNode;
-}
-//# sourceMappingURL=findConverterForNode.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"findConverterForNode.js","names":["findConverterForNode","converters","node","converterForNode","type","blocks","fields","blockType","inlineBlocks"],"sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/findConverterForNode.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js'\nimport type { PlaintextConverter, PlaintextConverters } from '../sync/types.js'\n\nexport function findConverterForNode<\n  TConverters extends PlaintextConverters,\n  TConverter extends PlaintextConverter<any>,\n>({\n  converters,\n\n  node,\n}: {\n  converters: TConverters\n  node: SerializedLexicalNode\n}): TConverter | undefined {\n  let converterForNode: TConverter | undefined\n  if (node.type === 'block') {\n    converterForNode = converters?.blocks?.[\n      (node as SerializedBlockNode)?.fields?.blockType\n    ] as TConverter\n  } else if (node.type === 'inlineBlock') {\n    converterForNode = converters?.inlineBlocks?.[\n      (node as SerializedInlineBlockNode)?.fields?.blockType\n    ] as TConverter\n  } else {\n    converterForNode = converters[node.type] as TConverter\n  }\n\n  return converterForNode\n}\n"],"mappings":"AAKA,OAAO,SAASA,qBAGd;EACAC,UAAU;EAEVC;AAAI,CAIL;EACC,IAAIC,gBAAA;EACJ,IAAID,IAAA,CAAKE,IAAI,KAAK,SAAS;IACzBD,gBAAA,GAAmBF,UAAA,EAAYI,MAAA,GAC5BH,IAAA,EAA8BI,MAAA,EAAQC,SAAA,CACxC;EACH,OAAO,IAAIL,IAAA,CAAKE,IAAI,KAAK,eAAe;IACtCD,gBAAA,GAAmBF,UAAA,EAAYO,YAAA,GAC5BN,IAAA,EAAoCI,MAAA,EAAQC,SAAA,CAC9C;EACH,OAAO;IACLJ,gBAAA,GAAmBF,UAAU,CAACC,IAAA,CAAKE,IAAI,CAAC;EAC1C;EAEA,OAAOD,gBAAA;AACT","ignoreList":[]}