@payloadcms/richtext-lexical 3.91.0-internal.c1569dc → 4.0.0-beta.1

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

@@ -1,91 +0,0 @@
-/**
- * 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 { PUNCTUATION_OR_SPACE } from './utils.js';
-export function findOutermostTextFormatTransformer(textNode, textFormatTransformersIndex) {
-  const textContent = textNode.getTextContent();
-  const match = findOutermostMatch(textContent, textFormatTransformersIndex);
-  if (!match) {
-    return null;
-  }
-  const textFormatMatchStart = match.index || 0;
-  const textFormatMatchEnd = textFormatMatchStart + match[0].length;
-  // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
-  const transformer = textFormatTransformersIndex.transformersByTag[match[1]];
-  return {
-    endIndex: textFormatMatchEnd,
-    match,
-    startIndex: textFormatMatchStart,
-    transformer
-  };
-}
-// Finds first "<tag>content<tag>" match that is not nested into another tag
-function findOutermostMatch(textContent, textTransformersIndex) {
-  const openTagsMatch = textContent.match(textTransformersIndex.openTagsRegExp);
-  if (openTagsMatch == null) {
-    return null;
-  }
-  for (const match of openTagsMatch) {
-    // Open tags reg exp might capture leading space so removing it
-    // before using match to find transformer
-    const tag = match.replace(/^\s/, '');
-    const fullMatchRegExp = textTransformersIndex.fullMatchRegExpByTag[tag];
-    if (fullMatchRegExp == null) {
-      continue;
-    }
-    const fullMatch = textContent.match(fullMatchRegExp);
-    const transformer = textTransformersIndex.transformersByTag[tag];
-    if (fullMatch != null && transformer != null) {
-      if (transformer.intraword !== false) {
-        return fullMatch;
-      }
-      // For non-intraword transformers checking if it's within a word
-      // or surrounded with space/punctuation/newline
-      const {
-        index = 0
-      } = fullMatch;
-      const beforeChar = textContent[index - 1];
-      const afterChar = textContent[index + fullMatch[0].length];
-      if ((!beforeChar || PUNCTUATION_OR_SPACE.test(beforeChar)) && (!afterChar || PUNCTUATION_OR_SPACE.test(afterChar))) {
-        return fullMatch;
-      }
-    }
-  }
-  return null;
-}
-export function importTextFormatTransformer(textNode, startIndex, endIndex, transformer, match) {
-  const textContent = textNode.getTextContent();
-  // No text matches - we can safely process the text format match
-  let nodeAfter;
-  let nodeBefore;
-  let transformedNode;
-  // If matching full content there's no need to run splitText and can reuse existing textNode
-  // to update its content and apply format. E.g. for **_Hello_** string after applying bold
-  // format (**) it will reuse the same text node to apply italic (_)
-  if (match[0] === textContent) {
-    transformedNode = textNode;
-  } else {
-    if (startIndex === 0) {
-      [transformedNode, nodeAfter] = textNode.splitText(endIndex);
-    } else {
-      [nodeBefore, transformedNode, nodeAfter] = textNode.splitText(startIndex, endIndex);
-    }
-  }
-  transformedNode.setTextContent(match[2]);
-  if (transformer) {
-    for (const format of transformer.format) {
-      if (!transformedNode.hasFormat(format)) {
-        transformedNode.toggleFormat(format);
-      }
-    }
-  }
-  return {
-    nodeAfter,
-    nodeBefore,
-    transformedNode
-  };
-}
-//# sourceMappingURL=importTextFormatTransformer.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"importTextFormatTransformer.js","names":["PUNCTUATION_OR_SPACE","findOutermostTextFormatTransformer","textNode","textFormatTransformersIndex","textContent","getTextContent","match","findOutermostMatch","textFormatMatchStart","index","textFormatMatchEnd","length","transformer","transformersByTag","endIndex","startIndex","textTransformersIndex","openTagsMatch","openTagsRegExp","tag","replace","fullMatchRegExp","fullMatchRegExpByTag","fullMatch","intraword","beforeChar","afterChar","test","importTextFormatTransformer","nodeAfter","nodeBefore","transformedNode","splitText","setTextContent","format","hasFormat","toggleFormat"],"sources":["../../../../src/packages/@lexical/markdown/importTextFormatTransformer.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 { TextNode } from 'lexical'\n\nimport type { TextFormatTransformersIndex } from './MarkdownImport.js'\nimport type { TextFormatTransformer } from './MarkdownTransformers.js'\n\nimport { PUNCTUATION_OR_SPACE } from './utils.js'\n\nexport function findOutermostTextFormatTransformer(\n  textNode: TextNode,\n  textFormatTransformersIndex: TextFormatTransformersIndex,\n): {\n  endIndex: number\n  match: RegExpMatchArray\n  startIndex: number\n  transformer: TextFormatTransformer\n} | null {\n  const textContent = textNode.getTextContent()\n  const match = findOutermostMatch(textContent, textFormatTransformersIndex)\n\n  if (!match) {\n    return null\n  }\n\n  const textFormatMatchStart: number = match.index || 0\n  const textFormatMatchEnd = textFormatMatchStart + match[0].length\n\n  // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n  const transformer: TextFormatTransformer = textFormatTransformersIndex.transformersByTag[match[1]]\n\n  return {\n    endIndex: textFormatMatchEnd,\n    match,\n    startIndex: textFormatMatchStart,\n    transformer,\n  }\n}\n\n// Finds first \"<tag>content<tag>\" match that is not nested into another tag\nfunction findOutermostMatch(\n  textContent: string,\n  textTransformersIndex: TextFormatTransformersIndex,\n): null | RegExpMatchArray {\n  const openTagsMatch = textContent.match(textTransformersIndex.openTagsRegExp)\n\n  if (openTagsMatch == null) {\n    return null\n  }\n\n  for (const match of openTagsMatch) {\n    // Open tags reg exp might capture leading space so removing it\n    // before using match to find transformer\n    const tag = match.replace(/^\\s/, '')\n    const fullMatchRegExp = textTransformersIndex.fullMatchRegExpByTag[tag]\n    if (fullMatchRegExp == null) {\n      continue\n    }\n\n    const fullMatch = textContent.match(fullMatchRegExp)\n    const transformer = textTransformersIndex.transformersByTag[tag]\n    if (fullMatch != null && transformer != null) {\n      if (transformer.intraword !== false) {\n        return fullMatch\n      }\n\n      // For non-intraword transformers checking if it's within a word\n      // or surrounded with space/punctuation/newline\n      const { index = 0 } = fullMatch\n      const beforeChar = textContent[index - 1]\n      const afterChar = textContent[index + fullMatch[0].length]\n\n      if (\n        (!beforeChar || PUNCTUATION_OR_SPACE.test(beforeChar)) &&\n        (!afterChar || PUNCTUATION_OR_SPACE.test(afterChar))\n      ) {\n        return fullMatch\n      }\n    }\n  }\n\n  return null\n}\n\nexport function importTextFormatTransformer(\n  textNode: TextNode,\n  startIndex: number,\n  endIndex: number,\n  transformer: TextFormatTransformer,\n  match: RegExpMatchArray,\n): {\n  nodeAfter: TextNode | undefined // If split\n  nodeBefore: TextNode | undefined // If split\n  transformedNode: TextNode\n} {\n  const textContent = textNode.getTextContent()\n\n  // No text matches - we can safely process the text format match\n  let nodeAfter: TextNode | undefined\n  let nodeBefore: TextNode | undefined\n  let transformedNode: TextNode\n\n  // If matching full content there's no need to run splitText and can reuse existing textNode\n  // to update its content and apply format. E.g. for **_Hello_** string after applying bold\n  // format (**) it will reuse the same text node to apply italic (_)\n  if (match[0] === textContent) {\n    transformedNode = textNode\n  } else {\n    if (startIndex === 0) {\n      ;[transformedNode, nodeAfter] = textNode.splitText(endIndex) as [\n        TextNode,\n        TextNode | undefined,\n      ]\n    } else {\n      ;[nodeBefore, transformedNode, nodeAfter] = textNode.splitText(startIndex, endIndex) as [\n        TextNode,\n        TextNode,\n        TextNode | undefined,\n      ]\n    }\n  }\n\n  transformedNode.setTextContent(match[2]!)\n  if (transformer) {\n    for (const format of transformer.format) {\n      if (!transformedNode.hasFormat(format)) {\n        transformedNode.toggleFormat(format)\n      }\n    }\n  }\n\n  return {\n    nodeAfter,\n    nodeBefore,\n    transformedNode,\n  }\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -1,21 +0,0 @@
-import { type TextNode } from 'lexical';
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-import type { TextMatchTransformer } from './MarkdownTransformers.js';
-export declare function findOutermostTextMatchTransformer(textNode_: TextNode, textMatchTransformers: Array<TextMatchTransformer>): {
-    endIndex: number;
-    match: RegExpMatchArray;
-    startIndex: number;
-    transformer: TextMatchTransformer;
-} | null;
-export declare function importFoundTextMatchTransformer(textNode: TextNode, startIndex: number, endIndex: number, transformer: TextMatchTransformer, match: RegExpMatchArray): {
-    nodeAfter: TextNode | undefined;
-    nodeBefore: TextNode | undefined;
-    transformedNode?: TextNode;
-} | null;
-//# sourceMappingURL=importTextMatchTransformer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"importTextMatchTransformer.d.ts","sourceRoot":"","sources":["../../../../src/packages/@lexical/markdown/importTextMatchTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEvC;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAErE,wBAAgB,iCAAiC,CAC/C,SAAS,EAAE,QAAQ,EACnB,qBAAqB,EAAE,KAAK,CAAC,oBAAoB,CAAC,GACjD;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,gBAAgB,CAAA;IACvB,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,oBAAoB,CAAA;CAClC,GAAG,IAAI,CAsDP;AAED,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,oBAAoB,EACjC,KAAK,EAAE,gBAAgB,GACtB;IACD,SAAS,EAAE,QAAQ,GAAG,SAAS,CAAA;IAC/B,UAAU,EAAE,QAAQ,GAAG,SAAS,CAAA;IAChC,eAAe,CAAC,EAAE,QAAQ,CAAA;CAC3B,GAAG,IAAI,CAqBP"}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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