@payloadcms/richtext-lexical 3.68.0-internal-debug.56c9b68 → 3.68.0-internal-debug.2eb12b9

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

@@ -1 +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":[]}
+{"version":3,"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"],"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"],"mappings":"AAAA,SAASA,WAAW,QAAuB,UAAS;AAEpD;;;;;;CAMC,GAID,SACEC,kCAAkC,EAClCC,2BAA2B,QACtB,mCAAkC;AACzC,SACEC,iCAAiC,EACjCC,+BAA+B,QAC1B,kCAAiC;AAExC;;;;;CAKC,GACD,OAAO,SAASC,uBACdC,QAAkB,EAClBC,2BAAwD,EACxDC,qBAAkD;IAElD,IAAIC,kBAAkBR,mCAAmCK,UAAUC;IAEnE,IAAIG,iBAAiBP,kCAAkCG,UAAUE;IAEjE,IAAIC,mBAAmBC,gBAAgB;QACrC,iCAAiC;QACjC,IACED,gBAAgBE,UAAU,IAAID,eAAeC,UAAU,IACvDF,gBAAgBG,QAAQ,IAAIF,eAAeE,QAAQ,EACnD;YACA,iGAAiG;YACjGF,iBAAiB;QACnB,OAAO;YACL,iGAAiG;YACjGD,kBAAkB;QACpB;IACF;IAEA,IAAIA,iBAAiB;QACnB,MAAMI,SAASX,4BACbI,UACAG,gBAAgBE,UAAU,EAC1BF,gBAAgBG,QAAQ,EACxBH,gBAAgBK,WAAW,EAC3BL,gBAAgBM,KAAK;QAGvB,IAAIF,OAAOG,SAAS,IAAIhB,YAAYa,OAAOG,SAAS,KAAK,CAACH,OAAOG,SAAS,CAACC,SAAS,CAAC,SAAS;YAC5FZ,uBAAuBQ,OAAOG,SAAS,EAAET,6BAA6BC;QACxE;QACA,IACEK,OAAOK,UAAU,IACjBlB,YAAYa,OAAOK,UAAU,KAC7B,CAACL,OAAOK,UAAU,CAACD,SAAS,CAAC,SAC7B;YACAZ,uBAAuBQ,OAAOK,UAAU,EAAEX,6BAA6BC;QACzE;QACA,IACEK,OAAOM,eAAe,IACtBnB,YAAYa,OAAOM,eAAe,KAClC,CAACN,OAAOM,eAAe,CAACF,SAAS,CAAC,SAClC;YACAZ,uBACEQ,OAAOM,eAAe,EACtBZ,6BACAC;QAEJ;IACF,OAAO,IAAIE,gBAAgB;QACzB,MAAMG,SAAST,gCACbE,UACAI,eAAeC,UAAU,EACzBD,eAAeE,QAAQ,EACvBF,eAAeI,WAAW,EAC1BJ,eAAeK,KAAK;QAEtB,IAAI,CAACF,QAAQ;YACX;QACF;QAEA,IAAIA,OAAOG,SAAS,IAAIhB,YAAYa,OAAOG,SAAS,KAAK,CAACH,OAAOG,SAAS,CAACC,SAAS,CAAC,SAAS;YAC5FZ,uBAAuBQ,OAAOG,SAAS,EAAET,6BAA6BC;QACxE;QACA,IACEK,OAAOK,UAAU,IACjBlB,YAAYa,OAAOK,UAAU,KAC7B,CAACL,OAAOK,UAAU,CAACD,SAAS,CAAC,SAC7B;YACAZ,uBAAuBQ,OAAOK,UAAU,EAAEX,6BAA6BC;QACzE;QACA,IACEK,OAAOM,eAAe,IACtBnB,YAAYa,OAAOM,eAAe,KAClC,CAACN,OAAOM,eAAe,CAACF,SAAS,CAAC,SAClC;YACAZ,uBACEQ,OAAOM,eAAe,EACtBZ,6BACAC;QAEJ;IACF;IACA,2BAA2B;IAC3B,MAAMY,cAAcd,SAASe,cAAc;IAC3C,MAAMC,cAAcF,YAAYG,OAAO,CAAC,eAAe;IACvDjB,SAASkB,cAAc,CAACF;AAC1B"}

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

@@ -4,36 +4,55 @@
  * 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 { 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 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_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];
+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);
+ */ 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);
+ */ 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 };
+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

@@ -1 +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":[]}
+{"version":3,"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"],"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"],"mappings":"AAAA;;;;;;CAMC,GAYD,SAASA,oBAAoB,QAAQ,sBAAqB;AAC1D,SAASC,oBAAoB,QAAQ,sBAAqB;AAC1D,SAASC,yBAAyB,QAAQ,yBAAwB;AAClE,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,4BAA2B;AAElC,MAAMC,uBAAkD;IACtDV;IACAO;IACAE;IACAH;CACD;AAED,MAAMK,iCAAqE,EAAE;AAE7E,6CAA6C;AAC7C,EAAE;AACF,mEAAmE;AACnE,mEAAmE;AACnE,MAAMC,2BAAyD;IAC7DV;IACAP;IACAC;IACAC;IACAC;IACAG;IACAE;IACAC;IACAI;CACD;AAED,MAAMK,0BAAuD,EAAE;AAE/D,MAAMC,eAAmC;OACpCJ;OACAC;OACAC;OACAC;CACJ;AAED;;;;;CAKC,GACD,SAASE,2BACPC,QAAgB,EAChBC,eAAmCH,YAAY,EAC/CI,IAAkB,EAClBC,yBAAyB,KAAK,EAC9BC,2BAA2B,IAAI;IAE/B,MAAMC,oBAAoBF,yBACtBH,WACAX,kBAAkBW,UAAUI;IAChC,MAAME,iBAAiB7B,qBAAqBwB,cAAcE;IAC1D,OAAOG,eAAeD,mBAAmBH;AAC3C;AAEA;;CAEC,GACD,SAASK,yBACPN,eAAmCH,YAAY,EAC/CI,IAAkB,EAClBC,yBAAkC,KAAK;IAEvC,MAAMK,iBAAiBhC,qBAAqByB,cAAcE;IAC1D,OAAOK,eAAeN;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,KACf"}

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

@@ -1,267 +1,299 @@
 /* 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';
+ * 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
+    markdownFormatKind: null,
+    regEx: /(?:)/,
+    regExForAutoFormatting: /(?:)/,
+    requiresParagraphStart: false
 };
 const paragraphStartBase = {
-  ...autoFormatBase,
-  requiresParagraphStart: true
+    ...autoFormatBase,
+    requiresParagraphStart: true
 };
 const markdownHeader1 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(1),
-  markdownFormatKind: 'paragraphH1',
-  regEx: /^# /,
-  regExForAutoFormatting: /^# /
+    ...paragraphStartBase,
+    export: createHeadingExport(1),
+    markdownFormatKind: 'paragraphH1',
+    regEx: /^# /,
+    regExForAutoFormatting: /^# /
 };
 const markdownHeader2 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(2),
-  markdownFormatKind: 'paragraphH2',
-  regEx: /^## /,
-  regExForAutoFormatting: /^## /
+    ...paragraphStartBase,
+    export: createHeadingExport(2),
+    markdownFormatKind: 'paragraphH2',
+    regEx: /^## /,
+    regExForAutoFormatting: /^## /
 };
 const markdownHeader3 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(3),
-  markdownFormatKind: 'paragraphH3',
-  regEx: /^### /,
-  regExForAutoFormatting: /^### /
+    ...paragraphStartBase,
+    export: createHeadingExport(3),
+    markdownFormatKind: 'paragraphH3',
+    regEx: /^### /,
+    regExForAutoFormatting: /^### /
 };
 const markdownHeader4 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(4),
-  markdownFormatKind: 'paragraphH4',
-  regEx: /^#### /,
-  regExForAutoFormatting: /^#### /
+    ...paragraphStartBase,
+    export: createHeadingExport(4),
+    markdownFormatKind: 'paragraphH4',
+    regEx: /^#### /,
+    regExForAutoFormatting: /^#### /
 };
 const markdownHeader5 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(5),
-  markdownFormatKind: 'paragraphH5',
-  regEx: /^##### /,
-  regExForAutoFormatting: /^##### /
+    ...paragraphStartBase,
+    export: createHeadingExport(5),
+    markdownFormatKind: 'paragraphH5',
+    regEx: /^##### /,
+    regExForAutoFormatting: /^##### /
 };
 const markdownHeader6 = {
-  ...paragraphStartBase,
-  export: createHeadingExport(6),
-  markdownFormatKind: 'paragraphH6',
-  regEx: /^###### /,
-  regExForAutoFormatting: /^###### /
+    ...paragraphStartBase,
+    export: createHeadingExport(6),
+    markdownFormatKind: 'paragraphH6',
+    regEx: /^###### /,
+    regExForAutoFormatting: /^###### /
 };
 const markdownBlockQuote = {
-  ...paragraphStartBase,
-  export: blockQuoteExport,
-  markdownFormatKind: 'paragraphBlockQuote',
-  regEx: /^> /,
-  regExForAutoFormatting: /^> /
+    ...paragraphStartBase,
+    export: blockQuoteExport,
+    markdownFormatKind: 'paragraphBlockQuote',
+    regEx: /^> /,
+    regExForAutoFormatting: /^> /
 };
 const markdownUnorderedListDash = {
-  ...paragraphStartBase,
-  export: listExport,
-  markdownFormatKind: 'paragraphUnorderedList',
-  regEx: /^(\s{0,10})- /,
-  regExForAutoFormatting: /^(\s{0,10})- /
+    ...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})\* /
+    ...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/
+    ...paragraphStartBase,
+    export: listExport,
+    markdownFormatKind: 'paragraphOrderedList',
+    regEx: /^(\s{0,10})(\d+)\.\s/,
+    regExForAutoFormatting: /^(\s{0,10})(\d+)\.\s/
 };
 const markdownHorizontalRule = {
-  ...paragraphStartBase,
-  markdownFormatKind: 'horizontalRule',
-  regEx: /^\*\*\*$/,
-  regExForAutoFormatting: /^\*\*\* /
+    ...paragraphStartBase,
+    markdownFormatKind: 'horizontalRule',
+    regEx: /^\*\*\*$/,
+    regExForAutoFormatting: /^\*\*\* /
 };
 const markdownHorizontalRuleUsingDashes = {
-  ...paragraphStartBase,
-  markdownFormatKind: 'horizontalRule',
-  regEx: /^---$/,
-  regExForAutoFormatting: /^--- /
+    ...paragraphStartBase,
+    markdownFormatKind: 'horizontalRule',
+    regEx: /^---$/,
+    regExForAutoFormatting: /^--- /
 };
 const markdownInlineCode = {
-  ...autoFormatBase,
-  exportFormat: 'code',
-  exportTag: '`',
-  markdownFormatKind: 'code',
-  regEx: /(`)(\s*)([^`]*)(\s*)(`)()/,
-  regExForAutoFormatting: /(`)(\s*\b)([^`]*)(\b\s*)(`)(\s)$/
+    ...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)$/
+    ...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)$/
+    ...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)$/
+    ...autoFormatBase,
+    exportFormat: 'bold',
+    exportTag: '_',
+    markdownFormatKind: 'bold',
+    regEx: /(__)(\s*)([^_]*)(\s*)(__)()/,
+    regExForAutoFormatting: /(__)(\s*)([^_]*)(\s*)(__)(\s)$/
 };
 const markdownItalic2 = {
-  ...autoFormatBase,
-  exportFormat: 'italic',
-  exportTag: '_',
-  markdownFormatKind: 'italic',
-  regEx: /(_)()([^_]*)()(_)()/,
-  regExForAutoFormatting: /(_)()([^_]*)()(_)(\s)$/
+    ...autoFormatBase,
+    exportFormat: 'italic',
+    exportTag: '_',
+    markdownFormatKind: 'italic',
+    regEx: /(_)()([^_]*)()(_)()/,
+    regExForAutoFormatting: /(_)()([^_]*)()(_)(\s)$/
 };
+// Maintain 7 groups.
 const fakeMarkdownUnderline = {
-  ...autoFormatBase,
-  exportFormat: 'underline',
-  exportTag: '<u>',
-  exportTagClose: '</u>',
-  markdownFormatKind: 'underline',
-  regEx: /(<u>)(\s*)([^<]*)(\s*)(<\/u>)()/,
-  regExForAutoFormatting: /(<u>)(\s*\b)([^<]*)(\b\s*)(<\/u>)(\s)$/
+    ...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)$/
+    ...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)$/
+    ...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)$/
+    ...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)$/
+    ...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)$/
+    ...autoFormatBase,
+    markdownFormatKind: 'strikethrough_bold',
+    regEx: /(~~\*\*)(\s*\b)([^*~]+)(\b\s*)(\*\*~~)/,
+    regExForAutoFormatting: /(~~\*\*)(\s*\b)([^*~]+)(\b\s*)(\*\*~~)(\s)$/
 };
 const markdownLink = {
-  ...autoFormatBase,
-  markdownFormatKind: 'link',
-  regEx: /(\[)([^\]]*)(\]\()([^)]*)(\)*)()/,
-  regExForAutoFormatting: /(\[)([^\]]*)(\]\()([^)]*)(\)*)(\s)$/
+    ...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];
+    // Place the combination formats ahead of the individual formats.
+    // Combos
+    markdownStrikethroughItalicBold,
+    markdownItalicbold,
+    markdownStrikethroughItalic,
+    markdownStrikethroughBold,
+    // Individuals
+    markdownInlineCode,
+    markdownBold,
+    markdownItalic,
+    // Must appear after markdownBold
+    markdownBold2,
+    markdownItalic2,
+    // Must appear after markdownBold2.
+    fakeMarkdownUnderline,
+    markdownStrikethrough,
+    markdownLink
+];
+const allMarkdownCriteriaForParagraphs = [
+    markdownHeader1,
+    markdownHeader2,
+    markdownHeader3,
+    markdownHeader4,
+    markdownHeader5,
+    markdownHeader6,
+    markdownBlockQuote,
+    markdownUnorderedListDash,
+    markdownUnorderedListAsterisk,
+    markdownOrderedList,
+    markdownHorizontalRule,
+    markdownHorizontalRuleUsingDashes
+];
 export function getAllMarkdownCriteriaForParagraphs() {
-  return allMarkdownCriteriaForParagraphs;
+    return allMarkdownCriteriaForParagraphs;
 }
 export function getAllMarkdownCriteriaForTextNodes() {
-  return allMarkdownCriteriaForTextNodes;
+    return allMarkdownCriteriaForTextNodes;
 }
 function createHeadingExport(level) {
-  return (node, exportChildren) => {
-    return $isHeadingNode(node) && node.getTag() === 'h' + level ? '#'.repeat(level) + ' ' + exportChildren(node) : null;
-  };
+    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;
+    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 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++;
         }
-      }
-      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');
+    return output.join('\n');
 }
 function blockQuoteExport(node, exportChildren) {
-  return $isQuoteNode(node) ? '> ' + exportChildren(node) : null;
+    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];
+    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;
+    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'] || []
-  };
+    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());
+    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