@payloadcms/richtext-lexical 3.29.0-internal.2984e42 → 3.29.0-internal.37e46b5

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

@@ -1,5 +0,0 @@
-import type { SerializedLexicalNode } from 'lexical';
-export type SerializedLexicalNodeWithParent = {
-    parent?: SerializedLexicalNode;
-} & SerializedLexicalNode;
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,MAAM,MAAM,+BAA+B,GAAG;IAC5C,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAC/B,GAAG,qBAAqB,CAAA"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"mappings":"AACA","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/sync/index.d.ts

@@ -1,22 +0,0 @@
-import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
-import type { SerializedLexicalNodeWithParent } from '../shared/types.js';
-import type { PlaintextConverters } from './types.js';
-export type ConvertLexicalToPlaintextArgs = {
-    /**
-     * A map of node types to their corresponding plaintext converter functions.
-     * This is optional - if not provided, the following heuristic will be used:
-     *
-     * - If the node has a `text` property, it will be used as the plaintext.
-     * - If the node has a `children` property, the children will be recursively converted to plaintext.
-     * - If the node has neither, it will be ignored.
-     **/
-    converters?: PlaintextConverters;
-    data: SerializedEditorState;
-};
-export declare function convertLexicalToPlaintext({ converters, data, }: ConvertLexicalToPlaintextArgs): string;
-export declare function convertLexicalNodesToPlaintext({ converters, nodes, parent, }: {
-    converters: PlaintextConverters;
-    nodes: SerializedLexicalNode[];
-    parent: SerializedLexicalNodeWithParent;
-}): string[];
-//# sourceMappingURL=index.d.ts.map

package/dist/features/converters/lexicalToPlaintext/sync/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAE3E,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAKrD,MAAM,MAAM,6BAA6B,GAAG;IAC1C;;;;;;;QAOI;IACJ,UAAU,CAAC,EAAE,mBAAmB,CAAA;IAChC,IAAI,EAAE,qBAAqB,CAAA;CAC5B,CAAA;AAED,wBAAgB,yBAAyB,CAAC,EACxC,UAAU,EACV,IAAI,GACL,EAAE,6BAA6B,GAAG,MAAM,CAWxC;AAED,wBAAgB,8BAA8B,CAAC,EAC7C,UAAU,EACV,KAAK,EACL,MAAM,GACP,EAAE;IACD,UAAU,EAAE,mBAAmB,CAAA;IAC/B,KAAK,EAAE,qBAAqB,EAAE,CAAA;IAC9B,MAAM,EAAE,+BAA+B,CAAA;CACxC,GAAG,MAAM,EAAE,CAoEX"}

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

@@ -1,79 +0,0 @@
-/* eslint-disable no-console */import { hasText } from '../../../../validate/hasText.js';
-import { findConverterForNode } from '../shared/findConverterForNode.js';
-export function convertLexicalToPlaintext({
-  converters,
-  data
-}) {
-  if (hasText(data)) {
-    const plaintext = convertLexicalNodesToPlaintext({
-      converters: converters ?? {},
-      nodes: data?.root?.children,
-      parent: data?.root
-    }).join('');
-    return plaintext;
-  }
-  return '';
-}
-export function convertLexicalNodesToPlaintext({
-  converters,
-  nodes,
-  parent
-}) {
-  const plainTextArray = [];
-  let i = -1;
-  for (const node of nodes) {
-    i++;
-    const converter = findConverterForNode({
-      converters,
-      node
-    });
-    if (converter) {
-      try {
-        const converted = typeof converter === 'function' ? converter({
-          childIndex: i,
-          converters,
-          node,
-          nodesToPlaintext: args => {
-            return convertLexicalNodesToPlaintext({
-              converters: args.converters ?? converters,
-              nodes: args.nodes,
-              parent: args.parent ?? {
-                ...node,
-                parent
-              }
-            });
-          },
-          parent
-        }) : converter;
-        if (converted && typeof converted === 'string') {
-          plainTextArray.push(converted);
-        }
-      } catch (error) {
-        console.error('Error converting lexical node to plaintext:', error, 'node:', node);
-      }
-    } else {
-      // Default plaintext converter heuristic
-      if (node.type === 'paragraph') {
-        if (plainTextArray?.length) {
-          // Only add a new line if there is already text in the array
-          plainTextArray.push('\n\n');
-        }
-      } else if (node.type === 'linebreak') {
-        plainTextArray.push('\n');
-      } else if (node.type === 'tab') {
-        plainTextArray.push('\t');
-      } else if ('text' in node && node.text) {
-        plainTextArray.push(node.text);
-      }
-      if ('children' in node && node.children) {
-        plainTextArray.push(...convertLexicalNodesToPlaintext({
-          converters,
-          nodes: node.children,
-          parent: node
-        }));
-      }
-    }
-  }
-  return plainTextArray.filter(Boolean);
-}
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["hasText","findConverterForNode","convertLexicalToPlaintext","converters","data","plaintext","convertLexicalNodesToPlaintext","nodes","root","children","parent","join","plainTextArray","i","node","converter","converted","childIndex","nodesToPlaintext","args","push","error","console","type","length","text","filter","Boolean"],"sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/index.ts"],"sourcesContent":["/* eslint-disable no-console */\nimport type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\nimport type { PlaintextConverters } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\nimport { findConverterForNode } from '../shared/findConverterForNode.js'\n\nexport type ConvertLexicalToPlaintextArgs = {\n  /**\n   * A map of node types to their corresponding plaintext converter functions.\n   * This is optional - if not provided, the following heuristic will be used:\n   *\n   * - If the node has a `text` property, it will be used as the plaintext.\n   * - If the node has a `children` property, the children will be recursively converted to plaintext.\n   * - If the node has neither, it will be ignored.\n   **/\n  converters?: PlaintextConverters\n  data: SerializedEditorState\n}\n\nexport function convertLexicalToPlaintext({\n  converters,\n  data,\n}: ConvertLexicalToPlaintextArgs): string {\n  if (hasText(data)) {\n    const plaintext = convertLexicalNodesToPlaintext({\n      converters: converters ?? {},\n      nodes: data?.root?.children,\n      parent: data?.root,\n    }).join('')\n\n    return plaintext\n  }\n  return ''\n}\n\nexport function convertLexicalNodesToPlaintext({\n  converters,\n  nodes,\n  parent,\n}: {\n  converters: PlaintextConverters\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n}): string[] {\n  const plainTextArray: string[] = []\n\n  let i = -1\n  for (const node of nodes) {\n    i++\n\n    const converter = findConverterForNode({\n      converters,\n      node,\n    })\n\n    if (converter) {\n      try {\n        const converted =\n          typeof converter === 'function'\n            ? converter({\n                childIndex: i,\n                converters,\n                node,\n                nodesToPlaintext: (args) => {\n                  return convertLexicalNodesToPlaintext({\n                    converters: args.converters ?? converters,\n                    nodes: args.nodes,\n                    parent: args.parent ?? {\n                      ...node,\n                      parent,\n                    },\n                  })\n                },\n                parent,\n              })\n            : converter\n\n        if (converted && typeof converted === 'string') {\n          plainTextArray.push(converted)\n        }\n      } catch (error) {\n        console.error('Error converting lexical node to plaintext:', error, 'node:', node)\n      }\n    } else {\n      // Default plaintext converter heuristic\n      if (node.type === 'paragraph') {\n        if (plainTextArray?.length) {\n          // Only add a new line if there is already text in the array\n          plainTextArray.push('\\n\\n')\n        }\n      } else if (node.type === 'linebreak') {\n        plainTextArray.push('\\n')\n      } else if (node.type === 'tab') {\n        plainTextArray.push('\\t')\n      } else if ('text' in node && node.text) {\n        plainTextArray.push(node.text as string)\n      }\n\n      if ('children' in node && node.children) {\n        plainTextArray.push(\n          ...convertLexicalNodesToPlaintext({\n            converters,\n            nodes: node.children as SerializedLexicalNode[],\n            parent: node,\n          }),\n        )\n      }\n    }\n  }\n\n  return plainTextArray.filter(Boolean)\n}\n"],"mappings":"AAAA,+BAMA,SAASA,OAAO,QAAQ;AACxB,SAASC,oBAAoB,QAAQ;AAerC,OAAO,SAASC,0BAA0B;EACxCC,UAAU;EACVC;AAAI,CAC0B;EAC9B,IAAIJ,OAAA,CAAQI,IAAA,GAAO;IACjB,MAAMC,SAAA,GAAYC,8BAAA,CAA+B;MAC/CH,UAAA,EAAYA,UAAA,IAAc,CAAC;MAC3BI,KAAA,EAAOH,IAAA,EAAMI,IAAA,EAAMC,QAAA;MACnBC,MAAA,EAAQN,IAAA,EAAMI;IAChB,GAAGG,IAAI,CAAC;IAER,OAAON,SAAA;EACT;EACA,OAAO;AACT;AAEA,OAAO,SAASC,+BAA+B;EAC7CH,UAAU;EACVI,KAAK;EACLG;AAAM,CAKP;EACC,MAAME,cAAA,GAA2B,EAAE;EAEnC,IAAIC,CAAA,GAAI,CAAC;EACT,KAAK,MAAMC,IAAA,IAAQP,KAAA,EAAO;IACxBM,CAAA;IAEA,MAAME,SAAA,GAAYd,oBAAA,CAAqB;MACrCE,UAAA;MACAW;IACF;IAEA,IAAIC,SAAA,EAAW;MACb,IAAI;QACF,MAAMC,SAAA,GACJ,OAAOD,SAAA,KAAc,aACjBA,SAAA,CAAU;UACRE,UAAA,EAAYJ,CAAA;UACZV,UAAA;UACAW,IAAA;UACAI,gBAAA,EAAmBC,IAAA;YACjB,OAAOb,8BAAA,CAA+B;cACpCH,UAAA,EAAYgB,IAAA,CAAKhB,UAAU,IAAIA,UAAA;cAC/BI,KAAA,EAAOY,IAAA,CAAKZ,KAAK;cACjBG,MAAA,EAAQS,IAAA,CAAKT,MAAM,IAAI;gBACrB,GAAGI,IAAI;gBACPJ;cACF;YACF;UACF;UACAA;QACF,KACAK,SAAA;QAEN,IAAIC,SAAA,IAAa,OAAOA,SAAA,KAAc,UAAU;UAC9CJ,cAAA,CAAeQ,IAAI,CAACJ,SAAA;QACtB;MACF,EAAE,OAAOK,KAAA,EAAO;QACdC,OAAA,CAAQD,KAAK,CAAC,+CAA+CA,KAAA,EAAO,SAASP,IAAA;MAC/E;IACF,OAAO;MACL;MACA,IAAIA,IAAA,CAAKS,IAAI,KAAK,aAAa;QAC7B,IAAIX,cAAA,EAAgBY,MAAA,EAAQ;UAC1B;UACAZ,cAAA,CAAeQ,IAAI,CAAC;QACtB;MACF,OAAO,IAAIN,IAAA,CAAKS,IAAI,KAAK,aAAa;QACpCX,cAAA,CAAeQ,IAAI,CAAC;MACtB,OAAO,IAAIN,IAAA,CAAKS,IAAI,KAAK,OAAO;QAC9BX,cAAA,CAAeQ,IAAI,CAAC;MACtB,OAAO,IAAI,UAAUN,IAAA,IAAQA,IAAA,CAAKW,IAAI,EAAE;QACtCb,cAAA,CAAeQ,IAAI,CAACN,IAAA,CAAKW,IAAI;MAC/B;MAEA,IAAI,cAAcX,IAAA,IAAQA,IAAA,CAAKL,QAAQ,EAAE;QACvCG,cAAA,CAAeQ,IAAI,IACdd,8BAAA,CAA+B;UAChCH,UAAA;UACAI,KAAA,EAAOO,IAAA,CAAKL,QAAQ;UACpBC,MAAA,EAAQI;QACV;MAEJ;IACF;EACF;EAEA,OAAOF,cAAA,CAAec,MAAM,CAACC,OAAA;AAC/B","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/sync/types.d.ts

@@ -1,60 +0,0 @@
-import type { SerializedLexicalNode } from 'lexical';
-import type { DefaultNodeTypes, SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js';
-import type { SerializedLexicalNodeWithParent } from '../shared/types.js';
-export type PlaintextConverter<T extends {
-    [key: string]: any;
-    type?: string;
-} = SerializedLexicalNode> = ((args: {
-    childIndex: number;
-    converters: PlaintextConverters;
-    node: T;
-    nodesToPlaintext: (args: {
-        converters?: PlaintextConverters;
-        nodes: SerializedLexicalNode[];
-        parent?: SerializedLexicalNodeWithParent;
-    }) => string[];
-    parent: SerializedLexicalNodeWithParent;
-}) => string) | string;
-export type DefaultPlaintextNodeTypes = DefaultNodeTypes | SerializedBlockNode<{
-    blockName?: null | string;
-    blockType: string;
-}> | SerializedInlineBlockNode<{
-    blockName?: null | string;
-    blockType: string;
-}>;
-export type PlaintextConverters<T extends {
-    [key: string]: any;
-    type?: string;
-} = DefaultPlaintextNodeTypes> = {
-    [key: string]: {
-        [blockSlug: string]: PlaintextConverter<any>;
-    } | PlaintextConverter<any> | undefined;
-} & {
-    [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: PlaintextConverter<Extract<T, {
-        type: nodeType;
-    }>>;
-} & {
-    blocks?: {
-        [K in Extract<Extract<T, {
-            type: 'block';
-        }> extends SerializedBlockNode<infer B> ? B extends {
-            blockType: string;
-        } ? B['blockType'] : never : never, string>]?: PlaintextConverter<Extract<T, {
-            type: 'block';
-        }> extends SerializedBlockNode<infer B> ? SerializedBlockNode<Extract<B, {
-            blockType: K;
-        }>> : SerializedBlockNode>;
-    };
-    inlineBlocks?: {
-        [K in Extract<Extract<T, {
-            type: 'inlineBlock';
-        }> extends SerializedInlineBlockNode<infer B> ? B extends {
-            blockType: string;
-        } ? B['blockType'] : never : never, string>]?: PlaintextConverter<Extract<T, {
-            type: 'inlineBlock';
-        }> extends SerializedInlineBlockNode<infer B> ? SerializedInlineBlockNode<Extract<B, {
-            blockType: K;
-        }>> : SerializedInlineBlockNode>;
-    };
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/features/converters/lexicalToPlaintext/sync/types.d.ts.map

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

package/dist/features/converters/lexicalToPlaintext/sync/types.js

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToPlaintext/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 PlaintextConverter<\n  T extends { [key: string]: any; type?: string } = SerializedLexicalNode,\n> =\n  | ((args: {\n      childIndex: number\n      converters: PlaintextConverters\n      node: T\n      nodesToPlaintext: (args: {\n        converters?: PlaintextConverters\n        nodes: SerializedLexicalNode[]\n        parent?: SerializedLexicalNodeWithParent\n      }) => string[]\n      parent: SerializedLexicalNodeWithParent\n    }) => string)\n  | string\n\nexport type DefaultPlaintextNodeTypes =\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 }>\n\nexport type PlaintextConverters<\n  T extends { [key: string]: any; type?: string } = DefaultPlaintextNodeTypes,\n> = {\n  [key: string]:\n    | {\n        [blockSlug: string]: PlaintextConverter<any>\n      }\n    | PlaintextConverter<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: PlaintextConverter<\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    >]?: PlaintextConverter<\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    >]?: PlaintextConverter<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n}\n"],"mappings":"AA8BA","ignoreList":[]}

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

@@ -1,8 +0,0 @@
-import type { SerializedLexicalNode } from 'lexical';
-import type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js';
-import type { DefaultNodeTypes, TypedEditorState } from '../../../nodeTypes.js';
-export declare const convertMarkdownToLexical: <TNodeTypes extends SerializedLexicalNode = DefaultNodeTypes>({ editorConfig, markdown, }: {
-    editorConfig: SanitizedServerEditorConfig;
-    markdown: string;
-}) => TypedEditorState<TNodeTypes>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/markdownToLexical/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAIpD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAA;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAK/E,eAAO,MAAM,wBAAwB,GACnC,UAAU,SAAS,qBAAqB,kDAIvC;IACD,YAAY,EAAE,2BAA2B,CAAA;IACzC,QAAQ,EAAE,MAAM,CAAA;CACjB,KAAG,gBAAgB,CAAC,UAAU,CAiB9B,CAAA"}

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

@@ -1,21 +0,0 @@
-import { createHeadlessEditor } from '@lexical/headless';
-import { getEnabledNodes } from '../../../lexical/nodes/index.js';
-import { $convertFromMarkdownString } from '../../../packages/@lexical/markdown/index.js';
-export const convertMarkdownToLexical = ({
-  editorConfig,
-  markdown
-}) => {
-  const headlessEditor = createHeadlessEditor({
-    nodes: getEnabledNodes({
-      editorConfig
-    })
-  });
-  headlessEditor.update(() => {
-    $convertFromMarkdownString(markdown, editorConfig.features.markdownTransformers);
-  }, {
-    discrete: true
-  });
-  const editorJSON = headlessEditor.getEditorState().toJSON();
-  return editorJSON;
-};
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["createHeadlessEditor","getEnabledNodes","$convertFromMarkdownString","convertMarkdownToLexical","editorConfig","markdown","headlessEditor","nodes","update","features","markdownTransformers","discrete","editorJSON","getEditorState","toJSON"],"sources":["../../../../src/features/converters/markdownToLexical/index.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js'\nimport type { DefaultNodeTypes, TypedEditorState } from '../../../nodeTypes.js'\n\nimport { getEnabledNodes } from '../../../lexical/nodes/index.js'\nimport { $convertFromMarkdownString } from '../../../packages/@lexical/markdown/index.js'\n\nexport const convertMarkdownToLexical = <\n  TNodeTypes extends SerializedLexicalNode = DefaultNodeTypes,\n>({\n  editorConfig,\n  markdown,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n  markdown: string\n}): TypedEditorState<TNodeTypes> => {\n  const headlessEditor = createHeadlessEditor({\n    nodes: getEnabledNodes({\n      editorConfig,\n    }),\n  })\n\n  headlessEditor.update(\n    () => {\n      $convertFromMarkdownString(markdown, editorConfig.features.markdownTransformers)\n    },\n    { discrete: true },\n  )\n\n  const editorJSON = headlessEditor.getEditorState().toJSON()\n\n  return editorJSON as TypedEditorState<TNodeTypes>\n}\n"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ;AAKrC,SAASC,eAAe,QAAQ;AAChC,SAASC,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,wBAAA,GAA2BA,CAEtC;EACAC,YAAY;EACZC;AAAQ,CAIT;EACC,MAAMC,cAAA,GAAiBN,oBAAA,CAAqB;IAC1CO,KAAA,EAAON,eAAA,CAAgB;MACrBG;IACF;EACF;EAEAE,cAAA,CAAeE,MAAM,CACnB;IACEN,0BAAA,CAA2BG,QAAA,EAAUD,YAAA,CAAaK,QAAQ,CAACC,oBAAoB;EACjF,GACA;IAAEC,QAAA,EAAU;EAAK;EAGnB,MAAMC,UAAA,GAAaN,cAAA,CAAeO,cAAc,GAAGC,MAAM;EAEzD,OAAOF,UAAA;AACT","ignoreList":[]}