@ruya.sa/richtext-lexical 3.71.7

package/dist/packages/@lexical/markdown/importTextMatchTransformer.js

@@ -0,0 +1,54 @@
+export function findOutermostTextMatchTransformer(textNode_, textMatchTransformers) {
+  const textNode = textNode_;
+  let foundMatchStartIndex = undefined;
+  let foundMatchEndIndex = undefined;
+  let foundMatchTransformer = undefined;
+  let foundMatch = undefined;
+  for (const transformer of textMatchTransformers) {
+    if (!transformer.replace || !transformer.importRegExp) {
+      continue;
+    }
+    const match = textNode.getTextContent().match(transformer.importRegExp);
+    if (!match) {
+      continue;
+    }
+    const startIndex = match.index || 0;
+    const endIndex = transformer.getEndIndex ? transformer.getEndIndex(textNode, match) : startIndex + match[0].length;
+    if (endIndex === false) {
+      continue;
+    }
+    if (foundMatchStartIndex === undefined || foundMatchEndIndex === undefined || startIndex < foundMatchStartIndex && endIndex > foundMatchEndIndex) {
+      foundMatchStartIndex = startIndex;
+      foundMatchEndIndex = endIndex;
+      foundMatchTransformer = transformer;
+      foundMatch = match;
+    }
+  }
+  if (foundMatchStartIndex === undefined || foundMatchEndIndex === undefined || foundMatchTransformer === undefined || foundMatch === undefined) {
+    return null;
+  }
+  return {
+    endIndex: foundMatchEndIndex,
+    match: foundMatch,
+    startIndex: foundMatchStartIndex,
+    transformer: foundMatchTransformer
+  };
+}
+export function importFoundTextMatchTransformer(textNode, startIndex, endIndex, transformer, match) {
+  let nodeAfter, nodeBefore, transformedNode;
+  if (startIndex === 0) {
+    [transformedNode, nodeAfter] = textNode.splitText(endIndex);
+  } else {
+    [nodeBefore, transformedNode, nodeAfter] = textNode.splitText(startIndex, endIndex);
+  }
+  if (!transformer.replace) {
+    return null;
+  }
+  const potentialTransformedNode = transformedNode ? transformer.replace(transformedNode, match) : undefined;
+  return {
+    nodeAfter,
+    nodeBefore,
+    transformedNode: potentialTransformedNode || undefined
+  };
+}
+//# sourceMappingURL=importTextMatchTransformer.js.map

package/dist/packages/@lexical/markdown/importTextMatchTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"importTextMatchTransformer.js","names":["findOutermostTextMatchTransformer","textNode_","textMatchTransformers","textNode","foundMatchStartIndex","undefined","foundMatchEndIndex","foundMatchTransformer","foundMatch","transformer","replace","importRegExp","match","getTextContent","startIndex","index","endIndex","getEndIndex","length","importFoundTextMatchTransformer","nodeAfter","nodeBefore","transformedNode","splitText","potentialTransformedNode"],"sources":["../../../../src/packages/@lexical/markdown/importTextMatchTransformer.ts"],"sourcesContent":["import { type TextNode } from 'lexical'\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport type { TextMatchTransformer } from './MarkdownTransformers.js'\n\nexport function findOutermostTextMatchTransformer(\n  textNode_: TextNode,\n  textMatchTransformers: Array<TextMatchTransformer>,\n): {\n  endIndex: number\n  match: RegExpMatchArray\n  startIndex: number\n  transformer: TextMatchTransformer\n} | null {\n  const textNode = textNode_\n\n  let foundMatchStartIndex: number | undefined = undefined\n  let foundMatchEndIndex: number | undefined = undefined\n  let foundMatchTransformer: TextMatchTransformer | undefined = undefined\n  let foundMatch: RegExpMatchArray | undefined = undefined\n\n  for (const transformer of textMatchTransformers) {\n    if (!transformer.replace || !transformer.importRegExp) {\n      continue\n    }\n    const match = textNode.getTextContent().match(transformer.importRegExp)\n\n    if (!match) {\n      continue\n    }\n\n    const startIndex = match.index || 0\n    const endIndex = transformer.getEndIndex\n      ? transformer.getEndIndex(textNode, match)\n      : startIndex + match[0].length\n\n    if (endIndex === false) {\n      continue\n    }\n\n    if (\n      foundMatchStartIndex === undefined ||\n      foundMatchEndIndex === undefined ||\n      (startIndex < foundMatchStartIndex && endIndex > foundMatchEndIndex)\n    ) {\n      foundMatchStartIndex = startIndex\n      foundMatchEndIndex = endIndex\n      foundMatchTransformer = transformer\n      foundMatch = match\n    }\n  }\n\n  if (\n    foundMatchStartIndex === undefined ||\n    foundMatchEndIndex === undefined ||\n    foundMatchTransformer === undefined ||\n    foundMatch === undefined\n  ) {\n    return null\n  }\n\n  return {\n    endIndex: foundMatchEndIndex,\n    match: foundMatch,\n    startIndex: foundMatchStartIndex,\n    transformer: foundMatchTransformer,\n  }\n}\n\nexport function importFoundTextMatchTransformer(\n  textNode: TextNode,\n  startIndex: number,\n  endIndex: number,\n  transformer: TextMatchTransformer,\n  match: RegExpMatchArray,\n): {\n  nodeAfter: TextNode | undefined // If split\n  nodeBefore: TextNode | undefined // If split\n  transformedNode?: TextNode\n} | null {\n  let nodeAfter, nodeBefore, transformedNode\n\n  if (startIndex === 0) {\n    ;[transformedNode, nodeAfter] = textNode.splitText(endIndex)\n  } else {\n    ;[nodeBefore, transformedNode, nodeAfter] = textNode.splitText(startIndex, endIndex)\n  }\n\n  if (!transformer.replace) {\n    return null\n  }\n  const potentialTransformedNode = transformedNode\n    ? transformer.replace(transformedNode, match)\n    : undefined\n\n  return {\n    nodeAfter,\n    nodeBefore,\n    transformedNode: potentialTransformedNode || undefined,\n  }\n}\n"],"mappings":"AAWA,OAAO,SAASA,kCACdC,SAAmB,EACnBC,qBAAkD;EAOlD,MAAMC,QAAA,GAAWF,SAAA;EAEjB,IAAIG,oBAAA,GAA2CC,SAAA;EAC/C,IAAIC,kBAAA,GAAyCD,SAAA;EAC7C,IAAIE,qBAAA,GAA0DF,SAAA;EAC9D,IAAIG,UAAA,GAA2CH,SAAA;EAE/C,KAAK,MAAMI,WAAA,IAAeP,qBAAA,EAAuB;IAC/C,IAAI,CAACO,WAAA,CAAYC,OAAO,IAAI,CAACD,WAAA,CAAYE,YAAY,EAAE;MACrD;IACF;IACA,MAAMC,KAAA,GAAQT,QAAA,CAASU,cAAc,GAAGD,KAAK,CAACH,WAAA,CAAYE,YAAY;IAEtE,IAAI,CAACC,KAAA,EAAO;MACV;IACF;IAEA,MAAME,UAAA,GAAaF,KAAA,CAAMG,KAAK,IAAI;IAClC,MAAMC,QAAA,GAAWP,WAAA,CAAYQ,WAAW,GACpCR,WAAA,CAAYQ,WAAW,CAACd,QAAA,EAAUS,KAAA,IAClCE,UAAA,GAAaF,KAAK,CAAC,EAAE,CAACM,MAAM;IAEhC,IAAIF,QAAA,KAAa,OAAO;MACtB;IACF;IAEA,IACEZ,oBAAA,KAAyBC,SAAA,IACzBC,kBAAA,KAAuBD,SAAA,IACtBS,UAAA,GAAaV,oBAAA,IAAwBY,QAAA,GAAWV,kBAAA,EACjD;MACAF,oBAAA,GAAuBU,UAAA;MACvBR,kBAAA,GAAqBU,QAAA;MACrBT,qBAAA,GAAwBE,WAAA;MACxBD,UAAA,GAAaI,KAAA;IACf;EACF;EAEA,IACER,oBAAA,KAAyBC,SAAA,IACzBC,kBAAA,KAAuBD,SAAA,IACvBE,qBAAA,KAA0BF,SAAA,IAC1BG,UAAA,KAAeH,SAAA,EACf;IACA,OAAO;EACT;EAEA,OAAO;IACLW,QAAA,EAAUV,kBAAA;IACVM,KAAA,EAAOJ,UAAA;IACPM,UAAA,EAAYV,oBAAA;IACZK,WAAA,EAAaF;EACf;AACF;AAEA,OAAO,SAASY,gCACdhB,QAAkB,EAClBW,UAAkB,EAClBE,QAAgB,EAChBP,WAAiC,EACjCG,KAAuB;EAMvB,IAAIQ,SAAA,EAAWC,UAAA,EAAYC,eAAA;EAE3B,IAAIR,UAAA,KAAe,GAAG;IACnB,CAACQ,eAAA,EAAiBF,SAAA,CAAU,GAAGjB,QAAA,CAASoB,SAAS,CAACP,QAAA;EACrD,OAAO;IACJ,CAACK,UAAA,EAAYC,eAAA,EAAiBF,SAAA,CAAU,GAAGjB,QAAA,CAASoB,SAAS,CAACT,UAAA,EAAYE,QAAA;EAC7E;EAEA,IAAI,CAACP,WAAA,CAAYC,OAAO,EAAE;IACxB,OAAO;EACT;EACA,MAAMc,wBAAA,GAA2BF,eAAA,GAC7Bb,WAAA,CAAYC,OAAO,CAACY,eAAA,EAAiBV,KAAA,IACrCP,SAAA;EAEJ,OAAO;IACLe,SAAA;IACAC,UAAA;IACAC,eAAA,EAAiBE,wBAAA,IAA4BnB;EAC/C;AACF","ignoreList":[]}

package/dist/packages/@lexical/markdown/importTextTransformers.d.ts

@@ -0,0 +1,18 @@
+import { type TextNode } from 'lexical';
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { TextFormatTransformersIndex } from './MarkdownImport.js';
+import type { TextMatchTransformer } from './MarkdownTransformers.js';
+/**
+ * Handles applying both text format and text match transformers.
+ * It finds the outermost text format or text match and applies it,
+ * then recursively calls itself to apply the next outermost transformer,
+ * until there are no more transformers to apply.
+ */
+export declare function importTextTransformers(textNode: TextNode, textFormatTransformersIndex: TextFormatTransformersIndex, textMatchTransformers: Array<TextMatchTransformer>): void;
+//# sourceMappingURL=importTextTransformers.d.ts.map

package/dist/packages/@lexical/markdown/importTextTransformers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"importTextTransformers.d.ts","sourceRoot":"","sources":["../../../../src/packages/@lexical/markdown/importTextTransformers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEpD;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAA;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAWrE;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,QAAQ,EAClB,2BAA2B,EAAE,2BAA2B,EACxD,qBAAqB,EAAE,KAAK,CAAC,oBAAoB,CAAC,QAwFnD"}

package/dist/packages/@lexical/markdown/importTextTransformers.js

@@ -0,0 +1,54 @@
+import { $isTextNode } from 'lexical';
+import { findOutermostTextFormatTransformer, importTextFormatTransformer } from './importTextFormatTransformer.js';
+import { findOutermostTextMatchTransformer, importFoundTextMatchTransformer } from './importTextMatchTransformer.js';
+/**
+ * Handles applying both text format and text match transformers.
+ * It finds the outermost text format or text match and applies it,
+ * then recursively calls itself to apply the next outermost transformer,
+ * until there are no more transformers to apply.
+ */
+export function importTextTransformers(textNode, textFormatTransformersIndex, textMatchTransformers) {
+  let foundTextFormat = findOutermostTextFormatTransformer(textNode, textFormatTransformersIndex);
+  let foundTextMatch = findOutermostTextMatchTransformer(textNode, textMatchTransformers);
+  if (foundTextFormat && foundTextMatch) {
+    // Find the outermost transformer
+    if (foundTextFormat.startIndex <= foundTextMatch.startIndex && foundTextFormat.endIndex >= foundTextMatch.endIndex) {
+      // foundTextFormat wraps foundTextMatch - apply foundTextFormat by setting foundTextMatch to null
+      foundTextMatch = null;
+    } else {
+      // foundTextMatch wraps foundTextFormat - apply foundTextMatch by setting foundTextFormat to null
+      foundTextFormat = null;
+    }
+  }
+  if (foundTextFormat) {
+    const result = importTextFormatTransformer(textNode, foundTextFormat.startIndex, foundTextFormat.endIndex, foundTextFormat.transformer, foundTextFormat.match);
+    if (result.nodeAfter && $isTextNode(result.nodeAfter) && !result.nodeAfter.hasFormat('code')) {
+      importTextTransformers(result.nodeAfter, textFormatTransformersIndex, textMatchTransformers);
+    }
+    if (result.nodeBefore && $isTextNode(result.nodeBefore) && !result.nodeBefore.hasFormat('code')) {
+      importTextTransformers(result.nodeBefore, textFormatTransformersIndex, textMatchTransformers);
+    }
+    if (result.transformedNode && $isTextNode(result.transformedNode) && !result.transformedNode.hasFormat('code')) {
+      importTextTransformers(result.transformedNode, textFormatTransformersIndex, textMatchTransformers);
+    }
+  } else if (foundTextMatch) {
+    const result = importFoundTextMatchTransformer(textNode, foundTextMatch.startIndex, foundTextMatch.endIndex, foundTextMatch.transformer, foundTextMatch.match);
+    if (!result) {
+      return;
+    }
+    if (result.nodeAfter && $isTextNode(result.nodeAfter) && !result.nodeAfter.hasFormat('code')) {
+      importTextTransformers(result.nodeAfter, textFormatTransformersIndex, textMatchTransformers);
+    }
+    if (result.nodeBefore && $isTextNode(result.nodeBefore) && !result.nodeBefore.hasFormat('code')) {
+      importTextTransformers(result.nodeBefore, textFormatTransformersIndex, textMatchTransformers);
+    }
+    if (result.transformedNode && $isTextNode(result.transformedNode) && !result.transformedNode.hasFormat('code')) {
+      importTextTransformers(result.transformedNode, textFormatTransformersIndex, textMatchTransformers);
+    }
+  }
+  // Handle escape characters
+  const textContent = textNode.getTextContent();
+  const escapedText = textContent.replace(/\\([*_`~])/g, '$1');
+  textNode.setTextContent(escapedText);
+}
+//# sourceMappingURL=importTextTransformers.js.map

package/dist/packages/@lexical/markdown/importTextTransformers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"importTextTransformers.js","names":["$isTextNode","findOutermostTextFormatTransformer","importTextFormatTransformer","findOutermostTextMatchTransformer","importFoundTextMatchTransformer","importTextTransformers","textNode","textFormatTransformersIndex","textMatchTransformers","foundTextFormat","foundTextMatch","startIndex","endIndex","result","transformer","match","nodeAfter","hasFormat","nodeBefore","transformedNode","textContent","getTextContent","escapedText","replace","setTextContent"],"sources":["../../../../src/packages/@lexical/markdown/importTextTransformers.ts"],"sourcesContent":["import { $isTextNode, type TextNode } from 'lexical'\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport type { TextFormatTransformersIndex } from './MarkdownImport.js'\nimport type { TextMatchTransformer } from './MarkdownTransformers.js'\n\nimport {\n  findOutermostTextFormatTransformer,\n  importTextFormatTransformer,\n} from './importTextFormatTransformer.js'\nimport {\n  findOutermostTextMatchTransformer,\n  importFoundTextMatchTransformer,\n} from './importTextMatchTransformer.js'\n\n/**\n * Handles applying both text format and text match transformers.\n * It finds the outermost text format or text match and applies it,\n * then recursively calls itself to apply the next outermost transformer,\n * until there are no more transformers to apply.\n */\nexport function importTextTransformers(\n  textNode: TextNode,\n  textFormatTransformersIndex: TextFormatTransformersIndex,\n  textMatchTransformers: Array<TextMatchTransformer>,\n) {\n  let foundTextFormat = findOutermostTextFormatTransformer(textNode, textFormatTransformersIndex)\n\n  let foundTextMatch = findOutermostTextMatchTransformer(textNode, textMatchTransformers)\n\n  if (foundTextFormat && foundTextMatch) {\n    // Find the outermost transformer\n    if (\n      foundTextFormat.startIndex <= foundTextMatch.startIndex &&\n      foundTextFormat.endIndex >= foundTextMatch.endIndex\n    ) {\n      // foundTextFormat wraps foundTextMatch - apply foundTextFormat by setting foundTextMatch to null\n      foundTextMatch = null\n    } else {\n      // foundTextMatch wraps foundTextFormat - apply foundTextMatch by setting foundTextFormat to null\n      foundTextFormat = null\n    }\n  }\n\n  if (foundTextFormat) {\n    const result = importTextFormatTransformer(\n      textNode,\n      foundTextFormat.startIndex,\n      foundTextFormat.endIndex,\n      foundTextFormat.transformer,\n      foundTextFormat.match,\n    )\n\n    if (result.nodeAfter && $isTextNode(result.nodeAfter) && !result.nodeAfter.hasFormat('code')) {\n      importTextTransformers(result.nodeAfter, textFormatTransformersIndex, textMatchTransformers)\n    }\n    if (\n      result.nodeBefore &&\n      $isTextNode(result.nodeBefore) &&\n      !result.nodeBefore.hasFormat('code')\n    ) {\n      importTextTransformers(result.nodeBefore, textFormatTransformersIndex, textMatchTransformers)\n    }\n    if (\n      result.transformedNode &&\n      $isTextNode(result.transformedNode) &&\n      !result.transformedNode.hasFormat('code')\n    ) {\n      importTextTransformers(\n        result.transformedNode,\n        textFormatTransformersIndex,\n        textMatchTransformers,\n      )\n    }\n  } else if (foundTextMatch) {\n    const result = importFoundTextMatchTransformer(\n      textNode,\n      foundTextMatch.startIndex,\n      foundTextMatch.endIndex,\n      foundTextMatch.transformer,\n      foundTextMatch.match,\n    )\n    if (!result) {\n      return\n    }\n\n    if (result.nodeAfter && $isTextNode(result.nodeAfter) && !result.nodeAfter.hasFormat('code')) {\n      importTextTransformers(result.nodeAfter, textFormatTransformersIndex, textMatchTransformers)\n    }\n    if (\n      result.nodeBefore &&\n      $isTextNode(result.nodeBefore) &&\n      !result.nodeBefore.hasFormat('code')\n    ) {\n      importTextTransformers(result.nodeBefore, textFormatTransformersIndex, textMatchTransformers)\n    }\n    if (\n      result.transformedNode &&\n      $isTextNode(result.transformedNode) &&\n      !result.transformedNode.hasFormat('code')\n    ) {\n      importTextTransformers(\n        result.transformedNode,\n        textFormatTransformersIndex,\n        textMatchTransformers,\n      )\n    }\n  }\n  // Handle escape characters\n  const textContent = textNode.getTextContent()\n  const escapedText = textContent.replace(/\\\\([*_`~])/g, '$1')\n  textNode.setTextContent(escapedText)\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/packages/@lexical/markdown/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { ElementNode } from 'lexical';
+import type { ElementTransformer, MultilineElementTransformer, TextFormatTransformer, TextMatchTransformer, Transformer } from './MarkdownTransformers.js';
+import { registerMarkdownShortcuts } from './MarkdownShortcuts.js';
+import { BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, CHECK_LIST, HEADING, HIGHLIGHT, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, ORDERED_LIST, QUOTE, STRIKETHROUGH, UNORDERED_LIST } from './MarkdownTransformers.js';
+declare const ELEMENT_TRANSFORMERS: Array<ElementTransformer>;
+declare const MULTILINE_ELEMENT_TRANSFORMERS: Array<MultilineElementTransformer>;
+declare const TEXT_FORMAT_TRANSFORMERS: Array<TextFormatTransformer>;
+declare const TEXT_MATCH_TRANSFORMERS: Array<TextMatchTransformer>;
+declare const TRANSFORMERS: Array<Transformer>;
+/**
+ * Renders markdown from a string. The selection is moved to the start after the operation.
+ *
+ *  @param {boolean} [shouldPreserveNewLines] By setting this to true, new lines will be preserved between conversions
+ *  @param {boolean} [shouldMergeAdjacentLines] By setting this to true, adjacent non empty lines will be merged according to commonmark spec: https://spec.commonmark.org/0.24/#example-177. Not applicable if shouldPreserveNewLines = true.
+ */
+declare function $convertFromMarkdownString(markdown: string, transformers?: Array<Transformer>, node?: ElementNode, shouldPreserveNewLines?: boolean, shouldMergeAdjacentLines?: boolean): void;
+/**
+ * Renders string from markdown. The selection is moved to the start after the operation.
+ */
+declare function $convertToMarkdownString(transformers?: Array<Transformer>, node?: ElementNode, shouldPreserveNewLines?: boolean): string;
+export { $convertFromMarkdownString, $convertToMarkdownString, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, CHECK_LIST, ELEMENT_TRANSFORMERS, type ElementTransformer, HEADING, HIGHLIGHT, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, MULTILINE_ELEMENT_TRANSFORMERS, type MultilineElementTransformer, ORDERED_LIST, QUOTE, registerMarkdownShortcuts, STRIKETHROUGH, TEXT_FORMAT_TRANSFORMERS, TEXT_MATCH_TRANSFORMERS, type TextFormatTransformer, type TextMatchTransformer, type Transformer, TRANSFORMERS, UNORDERED_LIST, };
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/@lexical/markdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/packages/@lexical/markdown/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,OAAO,KAAK,EACV,kBAAkB,EAClB,2BAA2B,EAC3B,qBAAqB,EACrB,oBAAoB,EACpB,WAAW,EACZ,MAAM,2BAA2B,CAAA;AAIlC,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAA;AAClE,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,SAAS,EACT,eAAe,EACf,UAAU,EACV,OAAO,EACP,SAAS,EACT,WAAW,EACX,WAAW,EACX,iBAAiB,EAEjB,YAAY,EACZ,KAAK,EACL,aAAa,EACb,cAAc,EACf,MAAM,2BAA2B,CAAA;AAElC,QAAA,MAAM,oBAAoB,EAAE,KAAK,CAAC,kBAAkB,CAKnD,CAAA;AAED,QAAA,MAAM,8BAA8B,EAAE,KAAK,CAAC,2BAA2B,CAAM,CAAA;AAM7E,QAAA,MAAM,wBAAwB,EAAE,KAAK,CAAC,qBAAqB,CAU1D,CAAA;AAED,QAAA,MAAM,uBAAuB,EAAE,KAAK,CAAC,oBAAoB,CAAM,CAAA;AAE/D,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,WAAW,CAKpC,CAAA;AAED;;;;;GAKG;AACH,iBAAS,0BAA0B,CACjC,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,KAAK,CAAC,WAAW,CAAgB,EAC/C,IAAI,CAAC,EAAE,WAAW,EAClB,sBAAsB,UAAQ,EAC9B,wBAAwB,UAAO,GAC9B,IAAI,CAMN;AAED;;GAEG;AACH,iBAAS,wBAAwB,CAC/B,YAAY,GAAE,KAAK,CAAC,WAAW,CAAgB,EAC/C,IAAI,CAAC,EAAE,WAAW,EAClB,sBAAsB,GAAE,OAAe,GACtC,MAAM,CAGR;AAED,OAAO,EACL,0BAA0B,EAC1B,wBAAwB,EACxB,gBAAgB,EAChB,sBAAsB,EACtB,SAAS,EACT,eAAe,EACf,UAAU,EACV,oBAAoB,EACpB,KAAK,kBAAkB,EACvB,OAAO,EACP,SAAS,EACT,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,8BAA8B,EAC9B,KAAK,2BAA2B,EAChC,YAAY,EACZ,KAAK,EACL,yBAAyB,EACzB,aAAa,EACb,wBAAwB,EACxB,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,WAAW,EAChB,YAAY,EACZ,cAAc,GACf,CAAA"}

package/dist/packages/@lexical/markdown/index.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */import { createMarkdownExport } from './MarkdownExport.js';
+import { createMarkdownImport } from './MarkdownImport.js';
+import { registerMarkdownShortcuts } from './MarkdownShortcuts.js';
+import { BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, CHECK_LIST, HEADING, HIGHLIGHT, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, normalizeMarkdown, ORDERED_LIST, QUOTE, STRIKETHROUGH, UNORDERED_LIST } from './MarkdownTransformers.js';
+const ELEMENT_TRANSFORMERS = [HEADING, QUOTE, UNORDERED_LIST, ORDERED_LIST];
+const MULTILINE_ELEMENT_TRANSFORMERS = [];
+// Order of text format transformers matters:
+//
+// - code should go first as it prevents any transformations inside
+// - then longer tags match (e.g. ** or __ should go before * or _)
+const TEXT_FORMAT_TRANSFORMERS = [INLINE_CODE, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, HIGHLIGHT, ITALIC_STAR, ITALIC_UNDERSCORE, STRIKETHROUGH];
+const TEXT_MATCH_TRANSFORMERS = [];
+const TRANSFORMERS = [...ELEMENT_TRANSFORMERS, ...MULTILINE_ELEMENT_TRANSFORMERS, ...TEXT_FORMAT_TRANSFORMERS, ...TEXT_MATCH_TRANSFORMERS];
+/**
+ * Renders markdown from a string. The selection is moved to the start after the operation.
+ *
+ *  @param {boolean} [shouldPreserveNewLines] By setting this to true, new lines will be preserved between conversions
+ *  @param {boolean} [shouldMergeAdjacentLines] By setting this to true, adjacent non empty lines will be merged according to commonmark spec: https://spec.commonmark.org/0.24/#example-177. Not applicable if shouldPreserveNewLines = true.
+ */
+function $convertFromMarkdownString(markdown, transformers = TRANSFORMERS, node, shouldPreserveNewLines = false, shouldMergeAdjacentLines = true) {
+  const sanitizedMarkdown = shouldPreserveNewLines ? markdown : normalizeMarkdown(markdown, shouldMergeAdjacentLines);
+  const importMarkdown = createMarkdownImport(transformers, shouldPreserveNewLines);
+  return importMarkdown(sanitizedMarkdown, node);
+}
+/**
+ * Renders string from markdown. The selection is moved to the start after the operation.
+ */
+function $convertToMarkdownString(transformers = TRANSFORMERS, node, shouldPreserveNewLines = false) {
+  const exportMarkdown = createMarkdownExport(transformers, shouldPreserveNewLines);
+  return exportMarkdown(node);
+}
+export { $convertFromMarkdownString, $convertToMarkdownString, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, CHECK_LIST, ELEMENT_TRANSFORMERS, HEADING, HIGHLIGHT, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, MULTILINE_ELEMENT_TRANSFORMERS, ORDERED_LIST, QUOTE, registerMarkdownShortcuts, STRIKETHROUGH, TEXT_FORMAT_TRANSFORMERS, TEXT_MATCH_TRANSFORMERS, TRANSFORMERS, UNORDERED_LIST };
+//# sourceMappingURL=index.js.map

package/dist/packages/@lexical/markdown/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createMarkdownExport","createMarkdownImport","registerMarkdownShortcuts","BOLD_ITALIC_STAR","BOLD_ITALIC_UNDERSCORE","BOLD_STAR","BOLD_UNDERSCORE","CHECK_LIST","HEADING","HIGHLIGHT","INLINE_CODE","ITALIC_STAR","ITALIC_UNDERSCORE","normalizeMarkdown","ORDERED_LIST","QUOTE","STRIKETHROUGH","UNORDERED_LIST","ELEMENT_TRANSFORMERS","MULTILINE_ELEMENT_TRANSFORMERS","TEXT_FORMAT_TRANSFORMERS","TEXT_MATCH_TRANSFORMERS","TRANSFORMERS","$convertFromMarkdownString","markdown","transformers","node","shouldPreserveNewLines","shouldMergeAdjacentLines","sanitizedMarkdown","importMarkdown","$convertToMarkdownString","exportMarkdown"],"sources":["../../../../src/packages/@lexical/markdown/index.ts"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { ElementNode } from 'lexical'\n\nimport type {\n  ElementTransformer,\n  MultilineElementTransformer,\n  TextFormatTransformer,\n  TextMatchTransformer,\n  Transformer,\n} from './MarkdownTransformers.js'\n\nimport { createMarkdownExport } from './MarkdownExport.js'\nimport { createMarkdownImport } from './MarkdownImport.js'\nimport { registerMarkdownShortcuts } from './MarkdownShortcuts.js'\nimport {\n  BOLD_ITALIC_STAR,\n  BOLD_ITALIC_UNDERSCORE,\n  BOLD_STAR,\n  BOLD_UNDERSCORE,\n  CHECK_LIST,\n  HEADING,\n  HIGHLIGHT,\n  INLINE_CODE,\n  ITALIC_STAR,\n  ITALIC_UNDERSCORE,\n  normalizeMarkdown,\n  ORDERED_LIST,\n  QUOTE,\n  STRIKETHROUGH,\n  UNORDERED_LIST,\n} from './MarkdownTransformers.js'\n\nconst ELEMENT_TRANSFORMERS: Array<ElementTransformer> = [\n  HEADING,\n  QUOTE,\n  UNORDERED_LIST,\n  ORDERED_LIST,\n]\n\nconst MULTILINE_ELEMENT_TRANSFORMERS: Array<MultilineElementTransformer> = []\n\n// Order of text format transformers matters:\n//\n// - code should go first as it prevents any transformations inside\n// - then longer tags match (e.g. ** or __ should go before * or _)\nconst TEXT_FORMAT_TRANSFORMERS: Array<TextFormatTransformer> = [\n  INLINE_CODE,\n  BOLD_ITALIC_STAR,\n  BOLD_ITALIC_UNDERSCORE,\n  BOLD_STAR,\n  BOLD_UNDERSCORE,\n  HIGHLIGHT,\n  ITALIC_STAR,\n  ITALIC_UNDERSCORE,\n  STRIKETHROUGH,\n]\n\nconst TEXT_MATCH_TRANSFORMERS: Array<TextMatchTransformer> = []\n\nconst TRANSFORMERS: Array<Transformer> = [\n  ...ELEMENT_TRANSFORMERS,\n  ...MULTILINE_ELEMENT_TRANSFORMERS,\n  ...TEXT_FORMAT_TRANSFORMERS,\n  ...TEXT_MATCH_TRANSFORMERS,\n]\n\n/**\n * Renders markdown from a string. The selection is moved to the start after the operation.\n *\n *  @param {boolean} [shouldPreserveNewLines] By setting this to true, new lines will be preserved between conversions\n *  @param {boolean} [shouldMergeAdjacentLines] By setting this to true, adjacent non empty lines will be merged according to commonmark spec: https://spec.commonmark.org/0.24/#example-177. Not applicable if shouldPreserveNewLines = true.\n */\nfunction $convertFromMarkdownString(\n  markdown: string,\n  transformers: Array<Transformer> = TRANSFORMERS,\n  node?: ElementNode,\n  shouldPreserveNewLines = false,\n  shouldMergeAdjacentLines = true,\n): void {\n  const sanitizedMarkdown = shouldPreserveNewLines\n    ? markdown\n    : normalizeMarkdown(markdown, shouldMergeAdjacentLines)\n  const importMarkdown = createMarkdownImport(transformers, shouldPreserveNewLines)\n  return importMarkdown(sanitizedMarkdown, node)\n}\n\n/**\n * Renders string from markdown. The selection is moved to the start after the operation.\n */\nfunction $convertToMarkdownString(\n  transformers: Array<Transformer> = TRANSFORMERS,\n  node?: ElementNode,\n  shouldPreserveNewLines: boolean = false,\n): string {\n  const exportMarkdown = createMarkdownExport(transformers, shouldPreserveNewLines)\n  return exportMarkdown(node)\n}\n\nexport {\n  $convertFromMarkdownString,\n  $convertToMarkdownString,\n  BOLD_ITALIC_STAR,\n  BOLD_ITALIC_UNDERSCORE,\n  BOLD_STAR,\n  BOLD_UNDERSCORE,\n  CHECK_LIST,\n  ELEMENT_TRANSFORMERS,\n  type ElementTransformer,\n  HEADING,\n  HIGHLIGHT,\n  INLINE_CODE,\n  ITALIC_STAR,\n  ITALIC_UNDERSCORE,\n  MULTILINE_ELEMENT_TRANSFORMERS,\n  type MultilineElementTransformer,\n  ORDERED_LIST,\n  QUOTE,\n  registerMarkdownShortcuts,\n  STRIKETHROUGH,\n  TEXT_FORMAT_TRANSFORMERS,\n  TEXT_MATCH_TRANSFORMERS,\n  type TextFormatTransformer,\n  type TextMatchTransformer,\n  type Transformer,\n  TRANSFORMERS,\n  UNORDERED_LIST,\n}\n"],"mappings":"AAAA;;;;;;GAkBA,SAASA,oBAAoB,QAAQ;AACrC,SAASC,oBAAoB,QAAQ;AACrC,SAASC,yBAAyB,QAAQ;AAC1C,SACEC,gBAAgB,EAChBC,sBAAsB,EACtBC,SAAS,EACTC,eAAe,EACfC,UAAU,EACVC,OAAO,EACPC,SAAS,EACTC,WAAW,EACXC,WAAW,EACXC,iBAAiB,EACjBC,iBAAiB,EACjBC,YAAY,EACZC,KAAK,EACLC,aAAa,EACbC,cAAc,QACT;AAEP,MAAMC,oBAAA,GAAkD,CACtDV,OAAA,EACAO,KAAA,EACAE,cAAA,EACAH,YAAA,CACD;AAED,MAAMK,8BAAA,GAAqE,EAAE;AAE7E;AACA;AACA;AACA;AACA,MAAMC,wBAAA,GAAyD,CAC7DV,WAAA,EACAP,gBAAA,EACAC,sBAAA,EACAC,SAAA,EACAC,eAAA,EACAG,SAAA,EACAE,WAAA,EACAC,iBAAA,EACAI,aAAA,CACD;AAED,MAAMK,uBAAA,GAAuD,EAAE;AAE/D,MAAMC,YAAA,GAAmC,C,GACpCJ,oBAAA,E,GACAC,8BAAA,E,GACAC,wBAAA,E,GACAC,uBAAA,CACJ;AAED;;;;;;AAMA,SAASE,2BACPC,QAAgB,EAChBC,YAAA,GAAmCH,YAAY,EAC/CI,IAAkB,EAClBC,sBAAA,GAAyB,KAAK,EAC9BC,wBAAA,GAA2B,IAAI;EAE/B,MAAMC,iBAAA,GAAoBF,sBAAA,GACtBH,QAAA,GACAX,iBAAA,CAAkBW,QAAA,EAAUI,wBAAA;EAChC,MAAME,cAAA,GAAiB7B,oBAAA,CAAqBwB,YAAA,EAAcE,sBAAA;EAC1D,OAAOG,cAAA,CAAeD,iBAAA,EAAmBH,IAAA;AAC3C;AAEA;;;AAGA,SAASK,yBACPN,YAAA,GAAmCH,YAAY,EAC/CI,IAAkB,EAClBC,sBAAA,GAAkC,KAAK;EAEvC,MAAMK,cAAA,GAAiBhC,oBAAA,CAAqByB,YAAA,EAAcE,sBAAA;EAC1D,OAAOK,cAAA,CAAeN,IAAA;AACxB;AAEA,SACEH,0BAA0B,EAC1BQ,wBAAwB,EACxB5B,gBAAgB,EAChBC,sBAAsB,EACtBC,SAAS,EACTC,eAAe,EACfC,UAAU,EACVW,oBAAoB,EAEpBV,OAAO,EACPC,SAAS,EACTC,WAAW,EACXC,WAAW,EACXC,iBAAiB,EACjBO,8BAA8B,EAE9BL,YAAY,EACZC,KAAK,EACLb,yBAAyB,EACzBc,aAAa,EACbI,wBAAwB,EACxBC,uBAAuB,EAIvBC,YAAY,EACZL,cAAc","ignoreList":[]}

package/dist/packages/@lexical/markdown/utils.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { type ElementNode, type LexicalNode, type TextFormatType } from 'lexical';
+import type { ElementTransformer, MultilineElementTransformer, TextFormatTransformer, TextMatchTransformer, Transformer } from './MarkdownTransformers.js';
+type MarkdownFormatKind = 'bold' | 'code' | 'horizontalRule' | 'italic' | 'italic_bold' | 'link' | 'noTransformation' | 'paragraphBlockQuote' | 'paragraphCodeBlock' | 'paragraphH1' | 'paragraphH2' | 'paragraphH3' | 'paragraphH4' | 'paragraphH5' | 'paragraphH6' | 'paragraphOrderedList' | 'paragraphUnorderedList' | 'strikethrough' | 'strikethrough_bold' | 'strikethrough_italic' | 'strikethrough_italic_bold' | 'underline';
+type MarkdownCriteria = Readonly<{
+    export?: (node: LexicalNode, traverseChildren: (elementNode: ElementNode) => string) => null | string;
+    exportFormat?: TextFormatType;
+    exportTag?: string;
+    exportTagClose?: string;
+    markdownFormatKind: MarkdownFormatKind | null | undefined;
+    regEx: RegExp;
+    regExForAutoFormatting: RegExp;
+    requiresParagraphStart: boolean | null | undefined;
+}>;
+type MarkdownCriteriaArray = Array<MarkdownCriteria>;
+export declare function getAllMarkdownCriteriaForParagraphs(): MarkdownCriteriaArray;
+export declare function getAllMarkdownCriteriaForTextNodes(): MarkdownCriteriaArray;
+export declare function indexBy<T>(list: Array<T>, callback: (arg0: T) => string | undefined): Readonly<Record<string, Array<T>>>;
+export declare function transformersByType(transformers: Array<Transformer>): Readonly<{
+    element: Array<ElementTransformer>;
+    multilineElement: Array<MultilineElementTransformer>;
+    textFormat: Array<TextFormatTransformer>;
+    textMatch: Array<TextMatchTransformer>;
+}>;
+export declare const PUNCTUATION_OR_SPACE: RegExp;
+export declare function isEmptyParagraph(node: LexicalNode): boolean;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/packages/@lexical/markdown/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/packages/@lexical/markdown/utils.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AAMH,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,cAAc,EACpB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EACV,kBAAkB,EAClB,2BAA2B,EAC3B,qBAAqB,EACrB,oBAAoB,EACpB,WAAW,EACZ,MAAM,2BAA2B,CAAA;AAElC,KAAK,kBAAkB,GACnB,MAAM,GACN,MAAM,GACN,gBAAgB,GAChB,QAAQ,GACR,aAAa,GACb,MAAM,GACN,kBAAkB,GAClB,qBAAqB,GACrB,oBAAoB,GACpB,aAAa,GACb,aAAa,GACb,aAAa,GACb,aAAa,GACb,aAAa,GACb,aAAa,GACb,sBAAsB,GACtB,wBAAwB,GACxB,eAAe,GACf,oBAAoB,GACpB,sBAAsB,GACtB,2BAA2B,GAC3B,WAAW,CAAA;AAEf,KAAK,gBAAgB,GAAG,QAAQ,CAAC;IAC/B,MAAM,CAAC,EAAE,CACP,IAAI,EAAE,WAAW,EACjB,gBAAgB,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,MAAM,KACnD,IAAI,GAAG,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,cAAc,CAAA;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,kBAAkB,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,CAAA;IACzD,KAAK,EAAE,MAAM,CAAA;IACb,sBAAsB,EAAE,MAAM,CAAA;IAC9B,sBAAsB,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,CAAA;CACnD,CAAC,CAAA;AAEF,KAAK,qBAAqB,GAAG,KAAK,CAAC,gBAAgB,CAAC,CAAA;AA+OpD,wBAAgB,mCAAmC,IAAI,qBAAqB,CAE3E;AAED,wBAAgB,kCAAkC,IAAI,qBAAqB,CAE1E;AAwDD,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,SAAS,GACxC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAkBpC;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,KAAK,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC;IAC7E,OAAO,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAA;IAClC,gBAAgB,EAAE,KAAK,CAAC,2BAA2B,CAAC,CAAA;IACpD,UAAU,EAAE,KAAK,CAAC,qBAAqB,CAAC,CAAA;IACxC,SAAS,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAA;CACvC,CAAC,CASD;AAED,eAAO,MAAM,oBAAoB,QAAqB,CAAA;AAItD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAY3D"}

package/dist/packages/@lexical/markdown/utils.js

@@ -0,0 +1,267 @@
+/* eslint-disable regexp/no-obscure-range */ /* eslint-disable regexp/no-empty-group */ /* eslint-disable regexp/no-empty-capturing-group */ /* eslint-disable regexp/optimal-quantifier-concatenation */ /* eslint-disable regexp/no-misleading-capturing-group */ /* eslint-disable regexp/no-contradiction-with-assertion */ /* eslint-disable regexp/no-super-linear-backtracking */ /**
+                                                                                                                                                                                                                                                                                                                                                                                         * Copyright (c) Meta Platforms, Inc. and affiliates.
+                                                                                                                                                                                                                                                                                                                                                                                         *
+                                                                                                                                                                                                                                                                                                                                                                                         * This source code is licensed under the MIT license found in the
+                                                                                                                                                                                                                                                                                                                                                                                         * LICENSE file in the root directory of this source tree.
+                                                                                                                                                                                                                                                                                                                                                                                         *
+                                                                                                                                                                                                                                                                                                                                                                                         */import { $isListItemNode, $isListNode } from '@lexical/list';
+import { $isHeadingNode, $isQuoteNode } from '@lexical/rich-text';
+import { $isParagraphNode, $isTextNode } from 'lexical';
+const autoFormatBase = {
+  markdownFormatKind: null,
+  regEx: /(?:)/,
+  regExForAutoFormatting: /(?:)/,
+  requiresParagraphStart: false
+};
+const paragraphStartBase = {
+  ...autoFormatBase,
+  requiresParagraphStart: true
+};
+const markdownHeader1 = {
+  ...paragraphStartBase,
+  export: createHeadingExport(1),
+  markdownFormatKind: 'paragraphH1',
+  regEx: /^# /,
+  regExForAutoFormatting: /^# /
+};
+const markdownHeader2 = {
+  ...paragraphStartBase,
+  export: createHeadingExport(2),
+  markdownFormatKind: 'paragraphH2',
+  regEx: /^## /,
+  regExForAutoFormatting: /^## /
+};
+const markdownHeader3 = {
+  ...paragraphStartBase,
+  export: createHeadingExport(3),
+  markdownFormatKind: 'paragraphH3',
+  regEx: /^### /,
+  regExForAutoFormatting: /^### /
+};
+const markdownHeader4 = {
+  ...paragraphStartBase,
+  export: createHeadingExport(4),
+  markdownFormatKind: 'paragraphH4',
+  regEx: /^#### /,
+  regExForAutoFormatting: /^#### /
+};
+const markdownHeader5 = {
+  ...paragraphStartBase,
+  export: createHeadingExport(5),
+  markdownFormatKind: 'paragraphH5',
+  regEx: /^##### /,
+  regExForAutoFormatting: /^##### /
+};
+const markdownHeader6 = {
+  ...paragraphStartBase,
+  export: createHeadingExport(6),
+  markdownFormatKind: 'paragraphH6',
+  regEx: /^###### /,
+  regExForAutoFormatting: /^###### /
+};
+const markdownBlockQuote = {
+  ...paragraphStartBase,
+  export: blockQuoteExport,
+  markdownFormatKind: 'paragraphBlockQuote',
+  regEx: /^> /,
+  regExForAutoFormatting: /^> /
+};
+const markdownUnorderedListDash = {
+  ...paragraphStartBase,
+  export: listExport,
+  markdownFormatKind: 'paragraphUnorderedList',
+  regEx: /^(\s{0,10})- /,
+  regExForAutoFormatting: /^(\s{0,10})- /
+};
+const markdownUnorderedListAsterisk = {
+  ...paragraphStartBase,
+  export: listExport,
+  markdownFormatKind: 'paragraphUnorderedList',
+  regEx: /^(\s{0,10})\* /,
+  regExForAutoFormatting: /^(\s{0,10})\* /
+};
+const markdownOrderedList = {
+  ...paragraphStartBase,
+  export: listExport,
+  markdownFormatKind: 'paragraphOrderedList',
+  regEx: /^(\s{0,10})(\d+)\.\s/,
+  regExForAutoFormatting: /^(\s{0,10})(\d+)\.\s/
+};
+const markdownHorizontalRule = {
+  ...paragraphStartBase,
+  markdownFormatKind: 'horizontalRule',
+  regEx: /^\*\*\*$/,
+  regExForAutoFormatting: /^\*\*\* /
+};
+const markdownHorizontalRuleUsingDashes = {
+  ...paragraphStartBase,
+  markdownFormatKind: 'horizontalRule',
+  regEx: /^---$/,
+  regExForAutoFormatting: /^--- /
+};
+const markdownInlineCode = {
+  ...autoFormatBase,
+  exportFormat: 'code',
+  exportTag: '`',
+  markdownFormatKind: 'code',
+  regEx: /(`)(\s*)([^`]*)(\s*)(`)()/,
+  regExForAutoFormatting: /(`)(\s*\b)([^`]*)(\b\s*)(`)(\s)$/
+};
+const markdownBold = {
+  ...autoFormatBase,
+  exportFormat: 'bold',
+  exportTag: '**',
+  markdownFormatKind: 'bold',
+  regEx: /(\*\*)(\s*)([^*]*)(\s*)(\*\*)()/,
+  regExForAutoFormatting: /(\*\*)(\s*\b)([^*]*)(\b\s*)(\*\*)(\s)$/
+};
+const markdownItalic = {
+  ...autoFormatBase,
+  exportFormat: 'italic',
+  exportTag: '*',
+  markdownFormatKind: 'italic',
+  regEx: /(\*)(\s*)([^*]*)(\s*)(\*)()/,
+  regExForAutoFormatting: /(\*)(\s*\b)([^*]*)(\b\s*)(\*)(\s)$/
+};
+const markdownBold2 = {
+  ...autoFormatBase,
+  exportFormat: 'bold',
+  exportTag: '_',
+  markdownFormatKind: 'bold',
+  regEx: /(__)(\s*)([^_]*)(\s*)(__)()/,
+  regExForAutoFormatting: /(__)(\s*)([^_]*)(\s*)(__)(\s)$/
+};
+const markdownItalic2 = {
+  ...autoFormatBase,
+  exportFormat: 'italic',
+  exportTag: '_',
+  markdownFormatKind: 'italic',
+  regEx: /(_)()([^_]*)()(_)()/,
+  regExForAutoFormatting: /(_)()([^_]*)()(_)(\s)$/
+};
+const fakeMarkdownUnderline = {
+  ...autoFormatBase,
+  exportFormat: 'underline',
+  exportTag: '<u>',
+  exportTagClose: '</u>',
+  markdownFormatKind: 'underline',
+  regEx: /(<u>)(\s*)([^<]*)(\s*)(<\/u>)()/,
+  regExForAutoFormatting: /(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)(\s)$/
+};
+const markdownStrikethrough = {
+  ...autoFormatBase,
+  exportFormat: 'strikethrough',
+  exportTag: '~~',
+  markdownFormatKind: 'strikethrough',
+  regEx: /(~~)(\s*)([^~]*)(\s*)(~~)()/,
+  regExForAutoFormatting: /(~~)(\s*\b)([^~]*)(\b\s*)(~~)(\s)$/
+};
+const markdownStrikethroughItalicBold = {
+  ...autoFormatBase,
+  markdownFormatKind: 'strikethrough_italic_bold',
+  regEx: /(~~_\*\*)(\s*\b)([^*_~]+)(\b\s*)(\*\*_~~)()/,
+  regExForAutoFormatting: /(~~_\*\*)(\s*\b)([^*_~]+)(\b\s*)(\*\*_~~)(\s)$/
+};
+const markdownItalicbold = {
+  ...autoFormatBase,
+  markdownFormatKind: 'italic_bold',
+  regEx: /(_\*\*)(\s*\b)([^*_]+)(\b\s*)(\*\*_)/,
+  regExForAutoFormatting: /(_\*\*)(\s*\b)([^*_]+)(\b\s*)(\*\*_)(\s)$/
+};
+const markdownStrikethroughItalic = {
+  ...autoFormatBase,
+  markdownFormatKind: 'strikethrough_italic',
+  regEx: /(~~_)(\s*)([^_~]+)(\s*)(_~~)/,
+  regExForAutoFormatting: /(~~_)(\s*)([^_~]+)(\s*)(_~~)(\s)$/
+};
+const markdownStrikethroughBold = {
+  ...autoFormatBase,
+  markdownFormatKind: 'strikethrough_bold',
+  regEx: /(~~\*\*)(\s*\b)([^*~]+)(\b\s*)(\*\*~~)/,
+  regExForAutoFormatting: /(~~\*\*)(\s*\b)([^*~]+)(\b\s*)(\*\*~~)(\s)$/
+};
+const markdownLink = {
+  ...autoFormatBase,
+  markdownFormatKind: 'link',
+  regEx: /(\[)([^\]]*)(\]\()([^)]*)(\)*)()/,
+  regExForAutoFormatting: /(\[)([^\]]*)(\]\()([^)]*)(\)*)(\s)$/
+};
+const allMarkdownCriteriaForTextNodes = [
+// Place the combination formats ahead of the individual formats.
+// Combos
+markdownStrikethroughItalicBold, markdownItalicbold, markdownStrikethroughItalic, markdownStrikethroughBold, markdownInlineCode, markdownBold, markdownItalic, markdownBold2, markdownItalic2, fakeMarkdownUnderline, markdownStrikethrough, markdownLink];
+const allMarkdownCriteriaForParagraphs = [markdownHeader1, markdownHeader2, markdownHeader3, markdownHeader4, markdownHeader5, markdownHeader6, markdownBlockQuote, markdownUnorderedListDash, markdownUnorderedListAsterisk, markdownOrderedList, markdownHorizontalRule, markdownHorizontalRuleUsingDashes];
+export function getAllMarkdownCriteriaForParagraphs() {
+  return allMarkdownCriteriaForParagraphs;
+}
+export function getAllMarkdownCriteriaForTextNodes() {
+  return allMarkdownCriteriaForTextNodes;
+}
+function createHeadingExport(level) {
+  return (node, exportChildren) => {
+    return $isHeadingNode(node) && node.getTag() === 'h' + level ? '#'.repeat(level) + ' ' + exportChildren(node) : null;
+  };
+}
+function listExport(node, exportChildren) {
+  return $isListNode(node) ? processNestedLists(node, exportChildren, 0) : null;
+}
+// TODO: should be param
+const LIST_INDENT_SIZE = 4;
+function processNestedLists(listNode, exportChildren, depth) {
+  const output = [];
+  const children = listNode.getChildren();
+  let index = 0;
+  for (const listItemNode of children) {
+    if ($isListItemNode(listItemNode)) {
+      if (listItemNode.getChildrenSize() === 1) {
+        const firstChild = listItemNode.getFirstChild();
+        if ($isListNode(firstChild)) {
+          output.push(processNestedLists(firstChild, exportChildren, depth + 1));
+          continue;
+        }
+      }
+      const indent = ' '.repeat(depth * LIST_INDENT_SIZE);
+      const prefix = listNode.getListType() === 'bullet' ? '- ' : `${listNode.getStart() + index}. `;
+      output.push(indent + prefix + exportChildren(listItemNode));
+      index++;
+    }
+  }
+  return output.join('\n');
+}
+function blockQuoteExport(node, exportChildren) {
+  return $isQuoteNode(node) ? '> ' + exportChildren(node) : null;
+}
+export function indexBy(list, callback) {
+  const index = {};
+  for (const item of list) {
+    const key = callback(item);
+    if (!key) {
+      continue;
+    }
+    if (index[key]) {
+      index[key].push(item);
+    } else {
+      index[key] = [item];
+    }
+  }
+  return index;
+}
+export function transformersByType(transformers) {
+  const byType = indexBy(transformers, t => t.type);
+  return {
+    element: byType.element || [],
+    multilineElement: byType['multiline-element'] || [],
+    textFormat: byType['text-format'] || [],
+    textMatch: byType['text-match'] || []
+  };
+}
+export const PUNCTUATION_OR_SPACE = /[!-/:-@[-`{-~\s]/;
+const MARKDOWN_EMPTY_LINE_REG_EXP = /^\s{0,3}$/;
+export function isEmptyParagraph(node) {
+  if (!$isParagraphNode(node)) {
+    return false;
+  }
+  const firstChild = node.getFirstChild();
+  return firstChild == null || node.getChildrenSize() === 1 && $isTextNode(firstChild) && MARKDOWN_EMPTY_LINE_REG_EXP.test(firstChild.getTextContent());
+}
+//# sourceMappingURL=utils.js.map

package/dist/packages/@lexical/markdown/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["$isListItemNode","$isListNode","$isHeadingNode","$isQuoteNode","$isParagraphNode","$isTextNode","autoFormatBase","markdownFormatKind","regEx","regExForAutoFormatting","requiresParagraphStart","paragraphStartBase","markdownHeader1","export","createHeadingExport","markdownHeader2","markdownHeader3","markdownHeader4","markdownHeader5","markdownHeader6","markdownBlockQuote","blockQuoteExport","markdownUnorderedListDash","listExport","markdownUnorderedListAsterisk","markdownOrderedList","markdownHorizontalRule","markdownHorizontalRuleUsingDashes","markdownInlineCode","exportFormat","exportTag","markdownBold","markdownItalic","markdownBold2","markdownItalic2","fakeMarkdownUnderline","exportTagClose","markdownStrikethrough","markdownStrikethroughItalicBold","markdownItalicbold","markdownStrikethroughItalic","markdownStrikethroughBold","markdownLink","allMarkdownCriteriaForTextNodes","allMarkdownCriteriaForParagraphs","getAllMarkdownCriteriaForParagraphs","getAllMarkdownCriteriaForTextNodes","level","node","exportChildren","getTag","repeat","processNestedLists","LIST_INDENT_SIZE","listNode","depth","output","children","getChildren","index","listItemNode","getChildrenSize","firstChild","getFirstChild","push","indent","prefix","getListType","getStart","join","indexBy","list","callback","item","key","transformersByType","transformers","byType","t","type","element","multilineElement","textFormat","textMatch","PUNCTUATION_OR_SPACE","MARKDOWN_EMPTY_LINE_REG_EXP","isEmptyParagraph","test","getTextContent"],"sources":["../../../../src/packages/@lexical/markdown/utils.ts"],"sourcesContent":["/* eslint-disable regexp/no-obscure-range */\n/* eslint-disable regexp/no-empty-group */\n/* eslint-disable regexp/no-empty-capturing-group */\n/* eslint-disable regexp/optimal-quantifier-concatenation */\n/* eslint-disable regexp/no-misleading-capturing-group */\n/* eslint-disable regexp/no-contradiction-with-assertion */\n/* eslint-disable regexp/no-super-linear-backtracking */\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { ListNode } from '@lexical/list'\n\nimport { $isListItemNode, $isListNode } from '@lexical/list'\nimport { $isHeadingNode, $isQuoteNode } from '@lexical/rich-text'\nimport {\n  $isParagraphNode,\n  $isTextNode,\n  type ElementNode,\n  type LexicalNode,\n  type TextFormatType,\n} from 'lexical'\n\nimport type {\n  ElementTransformer,\n  MultilineElementTransformer,\n  TextFormatTransformer,\n  TextMatchTransformer,\n  Transformer,\n} from './MarkdownTransformers.js'\n\ntype MarkdownFormatKind =\n  | 'bold'\n  | 'code'\n  | 'horizontalRule'\n  | 'italic'\n  | 'italic_bold'\n  | 'link'\n  | 'noTransformation'\n  | 'paragraphBlockQuote'\n  | 'paragraphCodeBlock'\n  | 'paragraphH1'\n  | 'paragraphH2'\n  | 'paragraphH3'\n  | 'paragraphH4'\n  | 'paragraphH5'\n  | 'paragraphH6'\n  | 'paragraphOrderedList'\n  | 'paragraphUnorderedList'\n  | 'strikethrough'\n  | 'strikethrough_bold'\n  | 'strikethrough_italic'\n  | 'strikethrough_italic_bold'\n  | 'underline'\n\ntype MarkdownCriteria = Readonly<{\n  export?: (\n    node: LexicalNode,\n    traverseChildren: (elementNode: ElementNode) => string,\n  ) => null | string\n  exportFormat?: TextFormatType\n  exportTag?: string\n  exportTagClose?: string\n  markdownFormatKind: MarkdownFormatKind | null | undefined\n  regEx: RegExp\n  regExForAutoFormatting: RegExp\n  requiresParagraphStart: boolean | null | undefined\n}>\n\ntype MarkdownCriteriaArray = Array<MarkdownCriteria>\n\nconst autoFormatBase: MarkdownCriteria = {\n  markdownFormatKind: null,\n  regEx: /(?:)/,\n  regExForAutoFormatting: /(?:)/,\n  requiresParagraphStart: false,\n}\n\nconst paragraphStartBase: MarkdownCriteria = {\n  ...autoFormatBase,\n  requiresParagraphStart: true,\n}\n\nconst markdownHeader1: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(1),\n  markdownFormatKind: 'paragraphH1',\n  regEx: /^# /,\n  regExForAutoFormatting: /^# /,\n}\n\nconst markdownHeader2: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(2),\n  markdownFormatKind: 'paragraphH2',\n  regEx: /^## /,\n  regExForAutoFormatting: /^## /,\n}\n\nconst markdownHeader3: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(3),\n  markdownFormatKind: 'paragraphH3',\n  regEx: /^### /,\n  regExForAutoFormatting: /^### /,\n}\n\nconst markdownHeader4: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(4),\n  markdownFormatKind: 'paragraphH4',\n  regEx: /^#### /,\n  regExForAutoFormatting: /^#### /,\n}\n\nconst markdownHeader5: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(5),\n  markdownFormatKind: 'paragraphH5',\n  regEx: /^##### /,\n  regExForAutoFormatting: /^##### /,\n}\n\nconst markdownHeader6: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: createHeadingExport(6),\n  markdownFormatKind: 'paragraphH6',\n  regEx: /^###### /,\n  regExForAutoFormatting: /^###### /,\n}\n\nconst markdownBlockQuote: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: blockQuoteExport,\n  markdownFormatKind: 'paragraphBlockQuote',\n  regEx: /^> /,\n  regExForAutoFormatting: /^> /,\n}\n\nconst markdownUnorderedListDash: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: listExport,\n  markdownFormatKind: 'paragraphUnorderedList',\n  regEx: /^(\\s{0,10})- /,\n  regExForAutoFormatting: /^(\\s{0,10})- /,\n}\n\nconst markdownUnorderedListAsterisk: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: listExport,\n  markdownFormatKind: 'paragraphUnorderedList',\n  regEx: /^(\\s{0,10})\\* /,\n  regExForAutoFormatting: /^(\\s{0,10})\\* /,\n}\n\nconst markdownOrderedList: MarkdownCriteria = {\n  ...paragraphStartBase,\n  export: listExport,\n  markdownFormatKind: 'paragraphOrderedList',\n  regEx: /^(\\s{0,10})(\\d+)\\.\\s/,\n  regExForAutoFormatting: /^(\\s{0,10})(\\d+)\\.\\s/,\n}\n\nconst markdownHorizontalRule: MarkdownCriteria = {\n  ...paragraphStartBase,\n  markdownFormatKind: 'horizontalRule',\n  regEx: /^\\*\\*\\*$/,\n  regExForAutoFormatting: /^\\*\\*\\* /,\n}\n\nconst markdownHorizontalRuleUsingDashes: MarkdownCriteria = {\n  ...paragraphStartBase,\n  markdownFormatKind: 'horizontalRule',\n  regEx: /^---$/,\n  regExForAutoFormatting: /^--- /,\n}\n\nconst markdownInlineCode: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'code',\n  exportTag: '`',\n  markdownFormatKind: 'code',\n  regEx: /(`)(\\s*)([^`]*)(\\s*)(`)()/,\n  regExForAutoFormatting: /(`)(\\s*\\b)([^`]*)(\\b\\s*)(`)(\\s)$/,\n}\n\nconst markdownBold: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'bold',\n  exportTag: '**',\n  markdownFormatKind: 'bold',\n  regEx: /(\\*\\*)(\\s*)([^*]*)(\\s*)(\\*\\*)()/,\n  regExForAutoFormatting: /(\\*\\*)(\\s*\\b)([^*]*)(\\b\\s*)(\\*\\*)(\\s)$/,\n}\n\nconst markdownItalic: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'italic',\n  exportTag: '*',\n  markdownFormatKind: 'italic',\n  regEx: /(\\*)(\\s*)([^*]*)(\\s*)(\\*)()/,\n  regExForAutoFormatting: /(\\*)(\\s*\\b)([^*]*)(\\b\\s*)(\\*)(\\s)$/,\n}\n\nconst markdownBold2: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'bold',\n  exportTag: '_',\n  markdownFormatKind: 'bold',\n  regEx: /(__)(\\s*)([^_]*)(\\s*)(__)()/,\n  regExForAutoFormatting: /(__)(\\s*)([^_]*)(\\s*)(__)(\\s)$/,\n}\n\nconst markdownItalic2: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'italic',\n  exportTag: '_',\n  markdownFormatKind: 'italic',\n  regEx: /(_)()([^_]*)()(_)()/,\n  regExForAutoFormatting: /(_)()([^_]*)()(_)(\\s)$/, // Maintain 7 groups.\n}\n\nconst fakeMarkdownUnderline: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'underline',\n  exportTag: '<u>',\n  exportTagClose: '</u>',\n  markdownFormatKind: 'underline',\n  regEx: /(<u>)(\\s*)([^<]*)(\\s*)(<\\/u>)()/,\n  regExForAutoFormatting: /(<u>)(\\s*\\b)([^<]*)(\\b\\s*)(<\\/u>)(\\s)$/,\n}\n\nconst markdownStrikethrough: MarkdownCriteria = {\n  ...autoFormatBase,\n  exportFormat: 'strikethrough',\n  exportTag: '~~',\n  markdownFormatKind: 'strikethrough',\n  regEx: /(~~)(\\s*)([^~]*)(\\s*)(~~)()/,\n  regExForAutoFormatting: /(~~)(\\s*\\b)([^~]*)(\\b\\s*)(~~)(\\s)$/,\n}\n\nconst markdownStrikethroughItalicBold: MarkdownCriteria = {\n  ...autoFormatBase,\n  markdownFormatKind: 'strikethrough_italic_bold',\n  regEx: /(~~_\\*\\*)(\\s*\\b)([^*_~]+)(\\b\\s*)(\\*\\*_~~)()/,\n  regExForAutoFormatting: /(~~_\\*\\*)(\\s*\\b)([^*_~]+)(\\b\\s*)(\\*\\*_~~)(\\s)$/,\n}\n\nconst markdownItalicbold: MarkdownCriteria = {\n  ...autoFormatBase,\n  markdownFormatKind: 'italic_bold',\n  regEx: /(_\\*\\*)(\\s*\\b)([^*_]+)(\\b\\s*)(\\*\\*_)/,\n  regExForAutoFormatting: /(_\\*\\*)(\\s*\\b)([^*_]+)(\\b\\s*)(\\*\\*_)(\\s)$/,\n}\n\nconst markdownStrikethroughItalic: MarkdownCriteria = {\n  ...autoFormatBase,\n  markdownFormatKind: 'strikethrough_italic',\n  regEx: /(~~_)(\\s*)([^_~]+)(\\s*)(_~~)/,\n  regExForAutoFormatting: /(~~_)(\\s*)([^_~]+)(\\s*)(_~~)(\\s)$/,\n}\n\nconst markdownStrikethroughBold: MarkdownCriteria = {\n  ...autoFormatBase,\n  markdownFormatKind: 'strikethrough_bold',\n  regEx: /(~~\\*\\*)(\\s*\\b)([^*~]+)(\\b\\s*)(\\*\\*~~)/,\n  regExForAutoFormatting: /(~~\\*\\*)(\\s*\\b)([^*~]+)(\\b\\s*)(\\*\\*~~)(\\s)$/,\n}\n\nconst markdownLink: MarkdownCriteria = {\n  ...autoFormatBase,\n  markdownFormatKind: 'link',\n  regEx: /(\\[)([^\\]]*)(\\]\\()([^)]*)(\\)*)()/,\n  regExForAutoFormatting: /(\\[)([^\\]]*)(\\]\\()([^)]*)(\\)*)(\\s)$/,\n}\n\nconst allMarkdownCriteriaForTextNodes: MarkdownCriteriaArray = [\n  // Place the combination formats ahead of the individual formats.\n  // Combos\n  markdownStrikethroughItalicBold,\n  markdownItalicbold,\n  markdownStrikethroughItalic,\n  markdownStrikethroughBold, // Individuals\n  markdownInlineCode,\n  markdownBold,\n  markdownItalic, // Must appear after markdownBold\n  markdownBold2,\n  markdownItalic2, // Must appear after markdownBold2.\n  fakeMarkdownUnderline,\n  markdownStrikethrough,\n  markdownLink,\n]\n\nconst allMarkdownCriteriaForParagraphs: MarkdownCriteriaArray = [\n  markdownHeader1,\n  markdownHeader2,\n  markdownHeader3,\n  markdownHeader4,\n  markdownHeader5,\n  markdownHeader6,\n  markdownBlockQuote,\n  markdownUnorderedListDash,\n  markdownUnorderedListAsterisk,\n  markdownOrderedList,\n  markdownHorizontalRule,\n  markdownHorizontalRuleUsingDashes,\n]\n\nexport function getAllMarkdownCriteriaForParagraphs(): MarkdownCriteriaArray {\n  return allMarkdownCriteriaForParagraphs\n}\n\nexport function getAllMarkdownCriteriaForTextNodes(): MarkdownCriteriaArray {\n  return allMarkdownCriteriaForTextNodes\n}\n\ntype Block = (\n  node: LexicalNode,\n  exportChildren: (elementNode: ElementNode) => string,\n) => null | string\n\nfunction createHeadingExport(level: number): Block {\n  return (node, exportChildren) => {\n    return $isHeadingNode(node) && node.getTag() === 'h' + level\n      ? '#'.repeat(level) + ' ' + exportChildren(node)\n      : null\n  }\n}\n\nfunction listExport(node: LexicalNode, exportChildren: (_node: ElementNode) => string) {\n  return $isListNode(node) ? processNestedLists(node, exportChildren, 0) : null\n}\n\n// TODO: should be param\nconst LIST_INDENT_SIZE = 4\n\nfunction processNestedLists(\n  listNode: ListNode,\n  exportChildren: (node: ElementNode) => string,\n  depth: number,\n): string {\n  const output: string[] = []\n  const children = listNode.getChildren()\n  let index = 0\n\n  for (const listItemNode of children) {\n    if ($isListItemNode(listItemNode)) {\n      if (listItemNode.getChildrenSize() === 1) {\n        const firstChild = listItemNode.getFirstChild()\n\n        if ($isListNode(firstChild)) {\n          output.push(processNestedLists(firstChild, exportChildren, depth + 1))\n          continue\n        }\n      }\n\n      const indent = ' '.repeat(depth * LIST_INDENT_SIZE)\n      const prefix = listNode.getListType() === 'bullet' ? '- ' : `${listNode.getStart() + index}. `\n      output.push(indent + prefix + exportChildren(listItemNode))\n      index++\n    }\n  }\n\n  return output.join('\\n')\n}\n\nfunction blockQuoteExport(node: LexicalNode, exportChildren: (_node: ElementNode) => string) {\n  return $isQuoteNode(node) ? '> ' + exportChildren(node) : null\n}\n\nexport function indexBy<T>(\n  list: Array<T>,\n  callback: (arg0: T) => string | undefined,\n): Readonly<Record<string, Array<T>>> {\n  const index: Record<string, Array<T>> = {}\n\n  for (const item of list) {\n    const key = callback(item)\n\n    if (!key) {\n      continue\n    }\n\n    if (index[key]) {\n      index[key].push(item)\n    } else {\n      index[key] = [item]\n    }\n  }\n\n  return index\n}\n\nexport function transformersByType(transformers: Array<Transformer>): Readonly<{\n  element: Array<ElementTransformer>\n  multilineElement: Array<MultilineElementTransformer>\n  textFormat: Array<TextFormatTransformer>\n  textMatch: Array<TextMatchTransformer>\n}> {\n  const byType = indexBy(transformers, (t) => t.type)\n\n  return {\n    element: (byType.element || []) as Array<ElementTransformer>,\n    multilineElement: (byType['multiline-element'] || []) as Array<MultilineElementTransformer>,\n    textFormat: (byType['text-format'] || []) as Array<TextFormatTransformer>,\n    textMatch: (byType['text-match'] || []) as Array<TextMatchTransformer>,\n  }\n}\n\nexport const PUNCTUATION_OR_SPACE = /[!-/:-@[-`{-~\\s]/\n\nconst MARKDOWN_EMPTY_LINE_REG_EXP = /^\\s{0,3}$/\n\nexport function isEmptyParagraph(node: LexicalNode): boolean {\n  if (!$isParagraphNode(node)) {\n    return false\n  }\n\n  const firstChild = node.getFirstChild()\n  return (\n    firstChild == null ||\n    (node.getChildrenSize() === 1 &&\n      $isTextNode(firstChild) &&\n      MARKDOWN_EMPTY_LINE_REG_EXP.test(firstChild.getTextContent()))\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/populateGraphQL/defaultValue.d.ts

@@ -0,0 +1,3 @@
+import type { SerializedEditorState } from 'lexical';
+export declare const defaultRichTextValue: SerializedEditorState;
+//# sourceMappingURL=defaultValue.d.ts.map

package/dist/populateGraphQL/defaultValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultValue.d.ts","sourceRoot":"","sources":["../../src/populateGraphQL/defaultValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAA+C,MAAM,SAAS,CAAA;AAEjG,eAAO,MAAM,oBAAoB,EAAE,qBA8BlC,CAAA"}