@payloadcms/richtext-lexical 3.71.0-internal-debug.80dab4c → 3.71.0-internal.27e1e08

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

@@ -1 +1 @@
-{"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"}
+{"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.js

@@ -4,55 +4,36 @@
  * 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,"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"}
+{"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.js

@@ -1,299 +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';
+                                                                                                                                                                                                                                                                                                                                                                                         * 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,
-    // 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
-];
+// 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;
+  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 indent = ' '.repeat(depth * LIST_INDENT_SIZE);
-            const prefix = listNode.getListType() === 'bullet' ? '- ' : `${listNode.getStart() + index}. `;
-            output.push(indent + prefix + exportChildren(listItemNode));
-            index++;
+  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');
+  }
+  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;
     }
-    return index;
+    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'] || []
-    };
+  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