@mx-space/cli 0.1.0

package/dist/LexicalMarkdown.dev-C8e-eh6y.mjs

@@ -0,0 +1,1207 @@
+import { _ as LinkNode, a as HeadingNode, c as $createListNode, d as ListItemNode, f as ListNode, h as $isLinkNode, i as $isQuoteNode, l as $isListItemNode, m as $isAutoLinkNode, n as $createQuoteNode, o as QuoteNode, p as $createLinkNode, r as $isHeadingNode, s as $createListItemNode, t as $createHeadingNode, u as $isListNode, v as $createCodeNode, x as CodeNode, y as $isCodeNode } from "./LexicalRichText.node-B7k7wlQz.mjs";
+import { An as createState, At as COMMAND_PRIORITY_LOW, Et as COLLABORATION_TAG, Jt as HISTORY_PUSH_TAG, Kt as HISTORIC_TAG, R as $getRoot, V as $getState, Xn as mergeRegister, Y as $isElementNode, _ as $createTextNode, at as $isRootOrShadowRoot, bt as $setState, ct as $isTextNode, et as $isLineBreakNode, f as $createParagraphNode, g as $createTabNode, m as $createRangeSelection, nt as $isParagraphNode, on as KEY_ENTER_COMMAND, q as $isDecoratorNode, rt as $isRangeSelection, t as $addUpdateTag, u as $createLineBreakNode, vt as $setSelection, y as $findMatchingParent, z as $getSelection } from "./Lexical.node-gYNDt_p9.mjs";
+import { r as $findMatchingParent$1 } from "./LexicalUtils.node-CmK462d1.mjs";
+//#region ../../node_modules/.pnpm/@lexical+markdown@0.44.0/node_modules/@lexical/markdown/LexicalMarkdown.dev.mjs
+/**
+* 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.
+*
+*/
+/**
+* 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.
+*
+*/
+function indexBy(list, callback) {
+	const index = {};
+	for (const item of list) {
+		const key = callback(item);
+		if (!key) continue;
+		if (index[key]) index[key].push(item);
+		else index[key] = [item];
+	}
+	return index;
+}
+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 PUNCTUATION_OR_SPACE = /[!-/:-@[-`{-~\s]/;
+const WHITESPACE = /[ \t\n\r\f]/;
+const PUNCTUATION = /[!"#$%&'()*+,\-./:;<=>?@[\]^_`{|}~]/;
+const MARKDOWN_EMPTY_LINE_REG_EXP = /^\s{0,3}$/;
+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());
+}
+function unescapeText(value) {
+	return value.replace(/\\([!-/:-@[-`{-~])/g, "$1").replace(/&#(\d+);/g, (_, codePoint) => String.fromCodePoint(Number(codePoint)));
+}
+/**
+* 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.
+*
+*/
+/**
+* Renders string from markdown. The selection is moved to the start after the operation.
+*/
+function createMarkdownExport(transformers, shouldPreserveNewLines = false) {
+	const byType = transformersByType(transformers);
+	const elementTransformers = [...byType.multilineElement, ...byType.element];
+	const isNewlineDelimited = !shouldPreserveNewLines;
+	const textFormatTransformers = byType.textFormat.filter((transformer) => transformer.format.length === 1).sort((a, b) => {
+		return Number(a.format.includes("code")) - Number(b.format.includes("code"));
+	});
+	return (node) => {
+		const output = [];
+		const children = (node || $getRoot()).getChildren();
+		for (let i = 0; i < children.length; i++) {
+			const child = children[i];
+			const result = exportTopLevelElements(child, elementTransformers, textFormatTransformers, byType.textMatch, shouldPreserveNewLines);
+			if (result != null) output.push(isNewlineDelimited && i > 0 && !isEmptyParagraph(child) && !isEmptyParagraph(children[i - 1]) ? "\n".concat(result) : result);
+		}
+		return output.join("\n");
+	};
+}
+function exportTopLevelElements(node, elementTransformers, textTransformersIndex, textMatchTransformers, shouldPreserveNewLines) {
+	for (const transformer of elementTransformers) {
+		if (!transformer.export) continue;
+		const result = transformer.export(node, (_node) => exportChildren(_node, textTransformersIndex, textMatchTransformers, void 0, void 0, shouldPreserveNewLines));
+		if (result != null) return result;
+	}
+	if ($isElementNode(node)) return exportChildren(node, textTransformersIndex, textMatchTransformers, void 0, void 0, shouldPreserveNewLines);
+	else if ($isDecoratorNode(node)) return node.getTextContent();
+	else return null;
+}
+function exportChildren(node, textTransformersIndex, textMatchTransformers, unclosedTags, unclosableTags, shouldPreserveNewLines = false) {
+	const output = [];
+	const children = node.getChildren();
+	if (!unclosedTags) unclosedTags = [];
+	if (!unclosableTags) unclosableTags = [];
+	mainLoop: for (const child of children) {
+		for (const transformer of textMatchTransformers) {
+			if (!transformer.export) continue;
+			const result = transformer.export(child, (parentNode) => exportChildren(parentNode, textTransformersIndex, textMatchTransformers, unclosedTags, [...unclosableTags, ...unclosedTags], shouldPreserveNewLines), (textNode, textContent) => exportTextFormat(textNode, textContent, textTransformersIndex, unclosedTags, unclosableTags, shouldPreserveNewLines));
+			if (result != null) {
+				output.push(result);
+				continue mainLoop;
+			}
+		}
+		if ($isLineBreakNode(child)) output.push("\n");
+		else if ($isTextNode(child)) output.push(exportTextFormat(child, child.getTextContent(), textTransformersIndex, unclosedTags, unclosableTags, shouldPreserveNewLines));
+		else if ($isElementNode(child)) output.push(exportChildren(child, textTransformersIndex, textMatchTransformers, unclosedTags, unclosableTags, shouldPreserveNewLines));
+		else if ($isDecoratorNode(child)) output.push(child.getTextContent());
+	}
+	return output.join("");
+}
+function exportTextFormat(node, textContent, textTransformers, unclosedTags, unclosableTags, shouldPreserveNewLines = false) {
+	let output = textContent;
+	if (!node.hasFormat("code")) output = shouldPreserveNewLines ? output.replace(/([*_`~])/g, "\\$1") : output.replace(/([*_`~\\])/g, "\\$1");
+	const match = output.match(/^(\s*)(.*?)(\s*)$/s) || [
+		"",
+		"",
+		output,
+		""
+	];
+	const leadingSpace = match[1];
+	const trimmedOutput = match[2];
+	const trailingSpace = match[3];
+	const isWhitespaceOnly = trimmedOutput === "";
+	let openingTags = "";
+	let closingTagsBefore = "";
+	let closingTagsAfter = "";
+	const prevNode = getTextSibling(node, true);
+	const nextNode = getTextSibling(node, false);
+	const applied = /* @__PURE__ */ new Set();
+	for (const transformer of textTransformers) {
+		const format = transformer.format[0];
+		const tag = transformer.tag;
+		if (checkHasFormat(node, format) && !applied.has(format)) {
+			applied.add(format);
+			if (!checkHasFormat(prevNode, format) || !unclosedTags.find((element) => element.tag === tag)) {
+				unclosedTags.push({
+					format,
+					tag
+				});
+				openingTags += tag;
+			}
+		}
+	}
+	for (let i = 0; i < unclosedTags.length; i++) {
+		const nodeHasFormat = hasFormat(node, unclosedTags[i].format);
+		const nextNodeHasFormat = hasFormat(nextNode, unclosedTags[i].format);
+		if (nodeHasFormat && nextNodeHasFormat) continue;
+		const unhandledUnclosedTags = [...unclosedTags];
+		while (unhandledUnclosedTags.length > i) {
+			const unclosedTag = unhandledUnclosedTags.pop();
+			if (unclosableTags && unclosedTag && unclosableTags.find((element) => element.tag === unclosedTag.tag)) continue;
+			if (unclosedTag && typeof unclosedTag.tag === "string") {
+				if (!nodeHasFormat) closingTagsBefore += unclosedTag.tag;
+				else if (!nextNodeHasFormat) closingTagsAfter += unclosedTag.tag;
+			}
+			unclosedTags.pop();
+		}
+		break;
+	}
+	if (isWhitespaceOnly && !node.hasFormat("code")) return closingTagsBefore + output;
+	return closingTagsBefore + leadingSpace + openingTags + trimmedOutput + closingTagsAfter + trailingSpace;
+}
+function getTextSibling(node, backward) {
+	const sibling = backward ? node.getPreviousSibling() : node.getNextSibling();
+	if ($isTextNode(sibling)) return sibling;
+	return null;
+}
+function hasFormat(node, format) {
+	return $isTextNode(node) && node.hasFormat(format);
+}
+function checkHasFormat(n, f) {
+	if (!hasFormat(n, f)) return false;
+	if (f === "code") return true;
+	if (n && /^\s*$/.test(n.getTextContent())) return false;
+	return true;
+}
+/**
+* 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.
+*
+*/
+function findOutermostTextFormatTransformer(textNode, textFormatTransformersIndex) {
+	const textContent = textNode.getTextContent();
+	const codeRegex = textFormatTransformersIndex.fullMatchRegExpByTag["`"];
+	const codeTransformer = textFormatTransformersIndex.transformersByTag["`"];
+	const excludeRanges = [];
+	let codeMatch = null;
+	if (codeRegex && codeTransformer) {
+		const globalRegex = new RegExp(codeRegex.source, "g");
+		const matches = Array.from(textContent.matchAll(globalRegex));
+		for (const match of matches) {
+			const startIndex = match.index + match[1].length;
+			const endIndex = match.index + match[0].length;
+			if (!codeMatch) codeMatch = {
+				content: match[3],
+				endIndex,
+				startIndex,
+				tag: "`"
+			};
+			excludeRanges.push({
+				end: endIndex,
+				start: startIndex
+			});
+		}
+	}
+	const delimiters = scanDelimiters(textContent, textFormatTransformersIndex, excludeRanges);
+	const emphasisMatch = delimiters.length > 0 ? processEmphasis(textContent, delimiters, textFormatTransformersIndex) : null;
+	let resultMatch = null;
+	let resultTransformer = null;
+	if (codeMatch && emphasisMatch) if (emphasisMatch.startIndex <= codeMatch.startIndex && emphasisMatch.endIndex >= codeMatch.endIndex) {
+		resultMatch = emphasisMatch;
+		resultTransformer = textFormatTransformersIndex.transformersByTag[emphasisMatch.tag];
+	} else {
+		resultMatch = codeMatch;
+		resultTransformer = codeTransformer;
+	}
+	else if (codeMatch) {
+		resultMatch = codeMatch;
+		resultTransformer = codeTransformer;
+	} else if (emphasisMatch) {
+		resultMatch = emphasisMatch;
+		resultTransformer = textFormatTransformersIndex.transformersByTag[emphasisMatch.tag];
+	}
+	if (!resultMatch || !resultTransformer) return null;
+	const regexMatch = [
+		textContent.slice(resultMatch.startIndex, resultMatch.endIndex),
+		resultMatch.tag,
+		resultMatch.content
+	];
+	regexMatch.index = resultMatch.startIndex;
+	regexMatch.input = textContent;
+	return {
+		endIndex: resultMatch.endIndex,
+		match: regexMatch,
+		startIndex: resultMatch.startIndex,
+		transformer: resultTransformer
+	};
+}
+function scanDelimiters(text, transformersIndex, excludeRanges = []) {
+	const delimiters = [];
+	const delimiterChars = new Set(Object.keys(transformersIndex.transformersByTag).filter((tag) => tag[0] !== "`").map((tag) => tag[0]));
+	const isEscaped = (index) => {
+		let count = 0;
+		for (let i = index - 1; i >= 0 && text[i] === "\\"; i--) count++;
+		return count % 2 === 1;
+	};
+	const isInExcludedRange = (index) => {
+		return excludeRanges.some((range) => index >= range.start && index < range.end);
+	};
+	let i = 0;
+	while (i < text.length) {
+		const char = text[i];
+		if (!delimiterChars.has(char) || isEscaped(i) || isInExcludedRange(i)) {
+			i++;
+			continue;
+		}
+		let len = 1;
+		while (i + len < text.length && text[i + len] === char) len++;
+		const canOpen = canEmphasis(char, text, i, len, true);
+		const canClose = canEmphasis(char, text, i, len, false);
+		if (canOpen || canClose) delimiters.push({
+			active: true,
+			canClose,
+			canOpen,
+			char,
+			index: i,
+			length: len,
+			originalLength: len
+		});
+		i += len;
+	}
+	return delimiters;
+}
+function processEmphasis(text, delimiters, transformersIndex) {
+	const openersBottom = {};
+	let currentPos = 0;
+	let result = null;
+	while (currentPos < delimiters.length) {
+		const closer = delimiters[currentPos];
+		if (!closer.active || !closer.canClose || closer.length === 0) {
+			currentPos++;
+			continue;
+		}
+		const bottomKey = `${closer.char}${closer.canOpen}`;
+		const bottom = openersBottom[bottomKey] ?? -1;
+		let foundOpener = false;
+		for (let openIdx = currentPos - 1; openIdx > bottom; openIdx--) {
+			const opener = delimiters[openIdx];
+			if (!opener.active || !opener.canOpen || opener.length === 0 || opener.char !== closer.char) continue;
+			if (opener.canClose || closer.canOpen) {
+				if ((opener.originalLength + closer.originalLength) % 3 === 0 && opener.originalLength % 3 !== 0 && closer.originalLength % 3 !== 0) continue;
+			}
+			const maxLen = Math.min(opener.length, closer.length);
+			const matchedTag = Object.keys(transformersIndex.transformersByTag).filter((t) => t[0] === opener.char && t.length <= maxLen).sort((a, b) => b.length - a.length)[0];
+			if (!matchedTag) continue;
+			foundOpener = true;
+			const matchLen = matchedTag.length;
+			const match = {
+				content: text.slice(opener.index + opener.length, closer.index),
+				endIndex: closer.index + matchLen,
+				startIndex: opener.index + (opener.length - matchLen),
+				tag: matchedTag
+			};
+			if (!result || match.startIndex < result.startIndex || match.startIndex === result.startIndex && match.endIndex > result.endIndex) result = match;
+			for (let j = openIdx + 1; j < currentPos; j++) delimiters[j].active = false;
+			opener.length -= matchLen;
+			closer.length -= matchLen;
+			opener.active = opener.length > 0;
+			if (closer.length > 0) closer.index += matchLen;
+			else {
+				closer.active = false;
+				currentPos++;
+			}
+			break;
+		}
+		if (!foundOpener) {
+			openersBottom[bottomKey] = currentPos - 1;
+			if (!closer.canOpen) closer.active = false;
+			currentPos++;
+		}
+	}
+	return result;
+}
+function canEmphasis(char, text, index, length, isOpen) {
+	if (!isFlanking(text, index, length, isOpen)) return false;
+	if (char === "*") return true;
+	if (char === "_") {
+		if (!isFlanking(text, index, length, !isOpen)) return true;
+		const adjacentChar = isOpen ? text[index - 1] : text[index + length];
+		return adjacentChar !== void 0 && PUNCTUATION.test(adjacentChar);
+	}
+	return true;
+}
+function isFlanking(text, index, length, isLeft) {
+	const charBefore = text[index - 1];
+	const charAfter = text[index + length];
+	const [primary, secondary] = isLeft ? [charAfter, charBefore] : [charBefore, charAfter];
+	if (primary === void 0 || WHITESPACE.test(primary)) return false;
+	if (!PUNCTUATION.test(primary)) return true;
+	return secondary === void 0 || WHITESPACE.test(secondary) || PUNCTUATION.test(secondary);
+}
+function importTextFormatTransformer(textNode, startIndex, endIndex, transformer, match) {
+	const textContent = textNode.getTextContent();
+	let transformedNode, nodeAfter, nodeBefore;
+	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
+	};
+}
+/**
+* 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.
+*
+*/
+function findOutermostTextMatchTransformer(textNode_, textMatchTransformers) {
+	const textNode = textNode_;
+	let foundMatchStartIndex = void 0;
+	let foundMatchEndIndex = void 0;
+	let foundMatchTransformer = void 0;
+	let foundMatch = void 0;
+	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 === void 0 || foundMatchEndIndex === void 0 || startIndex < foundMatchStartIndex && (endIndex > foundMatchEndIndex || endIndex <= foundMatchStartIndex)) {
+			foundMatchStartIndex = startIndex;
+			foundMatchEndIndex = endIndex;
+			foundMatchTransformer = transformer;
+			foundMatch = match;
+		}
+	}
+	if (foundMatchStartIndex === void 0 || foundMatchEndIndex === void 0 || foundMatchTransformer === void 0 || foundMatch === void 0) return null;
+	return {
+		endIndex: foundMatchEndIndex,
+		match: foundMatch,
+		startIndex: foundMatchStartIndex,
+		transformer: foundMatchTransformer
+	};
+}
+function importFoundTextMatchTransformer(textNode, startIndex, endIndex, transformer, match) {
+	let transformedNode, nodeAfter, nodeBefore;
+	if (startIndex === 0) [transformedNode, nodeAfter] = textNode.splitText(endIndex);
+	else [nodeBefore, transformedNode, nodeAfter] = textNode.splitText(startIndex, endIndex);
+	if (!transformer.replace) return null;
+	const potentialTransformedNode = transformer.replace(transformedNode, match);
+	return {
+		nodeAfter,
+		nodeBefore,
+		transformedNode: potentialTransformedNode || void 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.
+*
+*/
+/**
+* Returns true if the node can contain transformable markdown.
+* Code nodes cannot contain transformable markdown.
+* For example, `code **bold**` should not be transformed to
+* <code>code <strong>bold</strong></code>.
+*/
+function canContainTransformableMarkdown(node) {
+	return $isTextNode(node) && !node.hasFormat("code");
+}
+/**
+* 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.
+*/
+function importTextTransformers(textNode, textFormatTransformersIndex, textMatchTransformers) {
+	let foundTextFormat = findOutermostTextFormatTransformer(textNode, textFormatTransformersIndex);
+	let foundTextMatch = findOutermostTextMatchTransformer(textNode, textMatchTransformers);
+	if (foundTextFormat && foundTextMatch) if (foundTextFormat.startIndex <= foundTextMatch.startIndex && foundTextFormat.endIndex >= foundTextMatch.endIndex || foundTextMatch.startIndex > foundTextFormat.endIndex) foundTextMatch = null;
+	else foundTextFormat = null;
+	if (foundTextFormat) {
+		const result = importTextFormatTransformer(textNode, foundTextFormat.startIndex, foundTextFormat.endIndex, foundTextFormat.transformer, foundTextFormat.match);
+		if (canContainTransformableMarkdown(result.nodeAfter)) importTextTransformers(result.nodeAfter, textFormatTransformersIndex, textMatchTransformers);
+		if (canContainTransformableMarkdown(result.nodeBefore)) importTextTransformers(result.nodeBefore, textFormatTransformersIndex, textMatchTransformers);
+		if (canContainTransformableMarkdown(result.transformedNode)) importTextTransformers(result.transformedNode, textFormatTransformersIndex, textMatchTransformers);
+	} else if (foundTextMatch) {
+		const result = importFoundTextMatchTransformer(textNode, foundTextMatch.startIndex, foundTextMatch.endIndex, foundTextMatch.transformer, foundTextMatch.match);
+		if (!result) return;
+		if (canContainTransformableMarkdown(result.nodeAfter)) importTextTransformers(result.nodeAfter, textFormatTransformersIndex, textMatchTransformers);
+		if (canContainTransformableMarkdown(result.nodeBefore)) importTextTransformers(result.nodeBefore, textFormatTransformersIndex, textMatchTransformers);
+		if (canContainTransformableMarkdown(result.transformedNode)) importTextTransformers(result.transformedNode, textFormatTransformersIndex, textMatchTransformers);
+	}
+	const unescapedText = unescapeText(textNode.getTextContent());
+	textNode.setTextContent(unescapedText);
+}
+/**
+* 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.
+*
+*/
+/**
+* Renders markdown from a string. The selection is moved to the start after the operation.
+*/
+function createMarkdownImport(transformers, shouldPreserveNewLines = false) {
+	const byType = transformersByType(transformers);
+	const textFormatTransformersIndex = createTextFormatTransformersIndex(byType.textFormat);
+	return (markdownString, node) => {
+		const lines = markdownString.split("\n");
+		const linesLength = lines.length;
+		const root = node || $getRoot();
+		root.clear();
+		for (let i = 0; i < linesLength; i++) {
+			const lineText = lines[i];
+			const [imported, shiftedIndex] = $importMultiline(lines, i, byType.multilineElement, root);
+			if (imported) {
+				i = shiftedIndex;
+				continue;
+			}
+			$importBlocks(lineText, root, byType.element, textFormatTransformersIndex, byType.textMatch, shouldPreserveNewLines);
+		}
+		const children = root.getChildren();
+		for (const child of children) {
+			if (!shouldPreserveNewLines && isEmptyParagraph(child) && root.getChildrenSize() > 1) {
+				child.remove();
+				continue;
+			}
+			if ($isElementNode(child)) for (const textNode of child.getAllTextNodes()) $normalizeMarkdownTextNode(textNode);
+		}
+		if ($getSelection() !== null) root.selectStart();
+	};
+}
+/**
+*
+* @returns first element of the returned tuple is a boolean indicating if a multiline element was imported. The second element is the index of the last line that was processed.
+*/
+function $importMultiline(lines, startLineIndex, multilineElementTransformers, rootNode) {
+	for (const transformer of multilineElementTransformers) {
+		const { handleImportAfterStartMatch, regExpEnd, regExpStart, replace } = transformer;
+		const startMatch = lines[startLineIndex].match(regExpStart);
+		if (!startMatch) continue;
+		if (handleImportAfterStartMatch) {
+			const result = handleImportAfterStartMatch({
+				lines,
+				rootNode,
+				startLineIndex,
+				startMatch,
+				transformer
+			});
+			if (result === null) continue;
+			else if (result) return result;
+		}
+		const regexpEndRegex = typeof regExpEnd === "object" && "regExp" in regExpEnd ? regExpEnd.regExp : regExpEnd;
+		const isEndOptional = regExpEnd && typeof regExpEnd === "object" && "optional" in regExpEnd ? regExpEnd.optional : !regExpEnd;
+		let endLineIndex = startLineIndex;
+		const linesLength = lines.length;
+		while (endLineIndex < linesLength) {
+			const endMatch = regexpEndRegex ? lines[endLineIndex].match(regexpEndRegex) : null;
+			if (!endMatch) {
+				if (!isEndOptional || isEndOptional && endLineIndex < linesLength - 1) {
+					endLineIndex++;
+					continue;
+				}
+			}
+			if (endMatch && startLineIndex === endLineIndex && endMatch.index === startMatch.index) {
+				endLineIndex++;
+				continue;
+			}
+			const linesInBetween = [];
+			if (endMatch && startLineIndex === endLineIndex) linesInBetween.push(lines[startLineIndex].slice(startMatch[0].length, -endMatch[0].length));
+			else for (let i = startLineIndex; i <= endLineIndex; i++) if (i === startLineIndex) {
+				const text = lines[i].slice(startMatch[0].length);
+				linesInBetween.push(text);
+			} else if (i === endLineIndex && endMatch) {
+				const text = lines[i].slice(0, -endMatch[0].length);
+				linesInBetween.push(text);
+			} else linesInBetween.push(lines[i]);
+			if (replace(rootNode, null, startMatch, endMatch, linesInBetween, true) !== false) return [true, endLineIndex];
+			break;
+		}
+	}
+	return [false, startLineIndex];
+}
+function $importBlocks(lineText, rootNode, elementTransformers, textFormatTransformersIndex, textMatchTransformers, shouldPreserveNewLines) {
+	const textNode = $createTextNode(lineText);
+	const elementNode = $createParagraphNode();
+	elementNode.append(textNode);
+	rootNode.append(elementNode);
+	for (const { regExp, replace } of elementTransformers) {
+		const match = lineText.match(regExp);
+		if (match) {
+			textNode.setTextContent(lineText.slice(match[0].length));
+			if (replace(elementNode, [textNode], match, true) !== false) break;
+		}
+	}
+	importTextTransformers(textNode, textFormatTransformersIndex, textMatchTransformers);
+	if (elementNode.isAttached() && lineText.length > 0) {
+		const previousNode = elementNode.getPreviousSibling();
+		if (!shouldPreserveNewLines && ($isParagraphNode(previousNode) || $isQuoteNode(previousNode) || $isListNode(previousNode))) {
+			let targetNode = previousNode;
+			if ($isListNode(previousNode)) {
+				const lastDescendant = previousNode.getLastDescendant();
+				if (lastDescendant == null) targetNode = null;
+				else targetNode = $findMatchingParent$1(lastDescendant, $isListItemNode);
+			}
+			if (targetNode != null && targetNode.getTextContentSize() > 0) {
+				const lastChild = targetNode.getLastChild();
+				if ($isTextNode(lastChild)) {
+					const lastText = lastChild.getTextContent();
+					if (lastText.endsWith("\\")) lastChild.setTextContent(lastText.slice(0, -1));
+					else if (/ {2,}$/.test(lastText)) lastChild.setTextContent(lastText.replace(/ {2,}$/, ""));
+				}
+				targetNode.splice(targetNode.getChildrenSize(), 0, [$createLineBreakNode(), ...elementNode.getChildren()]);
+				elementNode.remove();
+			}
+		}
+	}
+}
+function $normalizeMarkdownTextNode(textNode) {
+	const tabOffsets = /* @__PURE__ */ new Set();
+	const text = textNode.getTextContent();
+	let index = text.indexOf("	");
+	while (index !== -1) {
+		tabOffsets.add(index);
+		tabOffsets.add(index + 1);
+		index = text.indexOf("	", index + 1);
+	}
+	textNode.splitText(...tabOffsets).forEach((node) => {
+		if (node.getTextContent() === "	") node.replace($createTabNode());
+	});
+}
+function createTextFormatTransformersIndex(textTransformers) {
+	const transformersByTag = {};
+	const fullMatchRegExpByTag = {};
+	const openTagsRegExp = [];
+	for (const transformer of textTransformers) {
+		const { tag } = transformer;
+		transformersByTag[tag] = transformer;
+		const tagRegExp = tag.replace(/(\*|\^|\+)/g, "\\$1");
+		openTagsRegExp.push(tagRegExp);
+		if (tag.length === 1) if (tag === "`") fullMatchRegExpByTag[tag] = new RegExp(`(^|[^\\\\\`])(\`)((?:\\\\\`|[^\`])+?)(\`)(?!\`)`);
+		else fullMatchRegExpByTag[tag] = new RegExp(`(^|[^\\\\${tagRegExp}])(${tagRegExp})((\\\\${tagRegExp})?.*?[^${tagRegExp}\\s](\\\\${tagRegExp})?)(${tagRegExp})(?![\\\\${tagRegExp}])`);
+		else fullMatchRegExpByTag[tag] = new RegExp(`(^|[^\\\\])(${tagRegExp})((\\\\${tagRegExp})?.*?[^\\s](\\\\${tagRegExp})?)(${tagRegExp})(?!\\\\)`);
+	}
+	return {
+		fullMatchRegExpByTag,
+		openTagsRegExp: new RegExp(`(${openTagsRegExp.join("|")})`, "g"),
+		transformersByTag
+	};
+}
+/**
+* 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.
+*
+*/
+function formatDevErrorMessage(message) {
+	throw new Error(message);
+}
+/**
+* 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.
+*
+*/
+const ORDERED_LIST_REGEX = /^(\s*)(\d{1,})\.\s/;
+const UNORDERED_LIST_REGEX = /^(\s*)[-*+]\s/;
+const CHECK_LIST_REGEX = /^(\s*)(?:[-*+]\s)?\s?(\[(\s|x)?\])\s/i;
+const HEADING_REGEX = /^(#{1,6})\s/;
+const QUOTE_REGEX = /^>\s/;
+const CODE_START_REGEX = /^([ \t]*`{3,})([\w-]+)?[ \t]?/;
+const CODE_END_REGEX = /^[ \t]*`{3,}$/;
+const CODE_SINGLE_LINE_REGEX = /^[ \t]*```[^`]+(?:(?:`{1,2}|`{4,})[^`]+)*```(?:[^`]|$)/;
+const TABLE_ROW_REG_EXP = /^(?:\|)(.+)(?:\|)\s?$/;
+const TABLE_ROW_DIVIDER_REG_EXP = /^(\| ?:?-*:? ?)+\|\s?$/;
+const TAG_START_REGEX = /^<[a-z_][\w-]*(?:\s[^<>]*)?\/?>/i;
+const TAG_END_REGEX = /^<\/[a-z_][\w-]*\s*>/i;
+const ENDS_WITH = (regex) => new RegExp(`(?:${regex.source})$`, regex.flags);
+const listMarkerState = createState("mdListMarker", {
+	parse: (v) => typeof v === "string" && /^[-*+]$/.test(v) ? v : "-",
+	resetOnCopyNode: true
+});
+const codeFenceState = createState("mdCodeFence", {
+	parse: (val) => {
+		if (typeof val === "string" && /^`{3,}$/.test(val)) return val;
+		return "```";
+	},
+	resetOnCopyNode: true
+});
+const createBlockNode = (createNode) => {
+	return (parentNode, children, match, isImport) => {
+		const node = createNode(match);
+		node.append(...children);
+		parentNode.replace(node);
+		if (!isImport) node.select(0, 0);
+	};
+};
+const LIST_INDENT_SIZE = 4;
+function getIndent(whitespaces) {
+	const tabs = whitespaces.match(/\t/g);
+	const spaces = whitespaces.match(/ /g);
+	let indent = 0;
+	if (tabs) indent += tabs.length;
+	if (spaces) indent += Math.floor(spaces.length / LIST_INDENT_SIZE);
+	return indent;
+}
+const listReplace = (listType) => {
+	return (parentNode, children, match, isImport) => {
+		const previousNode = parentNode.getPreviousSibling();
+		const nextNode = parentNode.getNextSibling();
+		const listItem = $createListItemNode(listType === "check" ? match[3] === "x" : void 0);
+		const firstMatchChar = match[0].trim()[0];
+		const listMarker = (listType === "bullet" || listType === "check") && firstMatchChar === listMarkerState.parse(firstMatchChar) ? firstMatchChar : void 0;
+		if ($isListNode(nextNode) && nextNode.getListType() === listType) {
+			if (listMarker) $setState(nextNode, listMarkerState, listMarker);
+			const firstChild = nextNode.getFirstChild();
+			if (firstChild !== null) firstChild.insertBefore(listItem);
+			else nextNode.append(listItem);
+			parentNode.remove();
+		} else if ($isListNode(previousNode) && previousNode.getListType() === listType) {
+			if (listMarker) $setState(previousNode, listMarkerState, listMarker);
+			previousNode.append(listItem);
+			parentNode.remove();
+		} else {
+			const list = $createListNode(listType, listType === "number" ? Number(match[2]) : void 0);
+			if (listMarker) $setState(list, listMarkerState, listMarker);
+			list.append(listItem);
+			parentNode.replace(list);
+		}
+		listItem.append(...children);
+		if (!isImport) listItem.select(0, 0);
+		const indent = getIndent(match[1]);
+		if (indent) listItem.setIndent(indent);
+	};
+};
+const $listExport = (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($listExport(firstChild, exportChildren, depth + 1));
+				continue;
+			}
+		}
+		const indent = " ".repeat(depth * LIST_INDENT_SIZE);
+		const listType = listNode.getListType();
+		const listMarker = $getState(listNode, listMarkerState);
+		const prefix = listType === "number" ? `${listNode.getStart() + index}. ` : listType === "check" ? `${listMarker} [${listItemNode.getChecked() ? "x" : " "}] ` : listMarker + " ";
+		let childrenText = exportChildren(listItemNode);
+		if (listType !== "number") childrenText = childrenText.replace(/^(\s{0,3}\d+)(\.\s)/, "$1\\$2");
+		output.push(indent + prefix + childrenText);
+		index++;
+	}
+	return output.join("\n");
+};
+const HEADING = {
+	dependencies: [HeadingNode],
+	export: (node, exportChildren) => {
+		if (!$isHeadingNode(node)) return null;
+		const level = Number(node.getTag().slice(1));
+		return "#".repeat(level) + " " + exportChildren(node);
+	},
+	regExp: HEADING_REGEX,
+	replace: createBlockNode((match) => {
+		return $createHeadingNode("h" + match[1].length);
+	}),
+	type: "element"
+};
+const QUOTE = {
+	dependencies: [QuoteNode],
+	export: (node, exportChildren) => {
+		if (!$isQuoteNode(node)) return null;
+		const lines = exportChildren(node).split("\n");
+		const output = [];
+		for (const line of lines) output.push("> " + line);
+		return output.join("\n");
+	},
+	regExp: QUOTE_REGEX,
+	replace: (parentNode, children, _match, isImport) => {
+		if (isImport) {
+			const previousNode = parentNode.getPreviousSibling();
+			if ($isQuoteNode(previousNode)) {
+				previousNode.splice(previousNode.getChildrenSize(), 0, [$createLineBreakNode(), ...children]);
+				parentNode.remove();
+				return;
+			}
+		}
+		const node = $createQuoteNode();
+		node.append(...children);
+		parentNode.replace(node);
+		if (!isImport) node.select(0, 0);
+	},
+	type: "element"
+};
+const CODE = {
+	dependencies: [CodeNode],
+	export: (node) => {
+		if (!$isCodeNode(node)) return null;
+		const textContent = node.getTextContent();
+		let fence = $getState(node, codeFenceState);
+		if (textContent.indexOf(fence) > -1) {
+			const backticks = textContent.match(/`{3,}/g);
+			if (backticks) {
+				const maxLength = Math.max(...backticks.map((b) => b.length));
+				fence = "`".repeat(maxLength + 1);
+			}
+		}
+		return fence + (node.getLanguage() || "") + (textContent ? "\n" + textContent : "") + "\n" + fence;
+	},
+	handleImportAfterStartMatch: ({ lines, rootNode, startLineIndex, startMatch }) => {
+		const fence = startMatch[1];
+		const fenceLength = fence.trim().length;
+		const currentLine = lines[startLineIndex];
+		const afterFenceIndex = startMatch.index + fence.length;
+		const afterFence = currentLine.slice(afterFenceIndex);
+		const singleLineEndRegex = new RegExp(`\`{${fenceLength},}$`);
+		if (singleLineEndRegex.test(afterFence)) {
+			const endMatch = afterFence.match(singleLineEndRegex);
+			const content = afterFence.slice(0, afterFence.lastIndexOf(endMatch[0]));
+			const fakeStartMatch = [...startMatch];
+			fakeStartMatch[2] = "";
+			CODE.replace(rootNode, null, fakeStartMatch, endMatch, [content], true);
+			return [true, startLineIndex];
+		}
+		const multilineEndRegex = new RegExp(`^[ \\t]*\`{${fenceLength},}$`);
+		for (let i = startLineIndex + 1; i < lines.length; i++) {
+			const line = lines[i];
+			if (multilineEndRegex.test(line)) {
+				const endMatch = line.match(multilineEndRegex);
+				const linesInBetween = lines.slice(startLineIndex + 1, i);
+				const afterFullMatch = currentLine.slice(startMatch[0].length);
+				if (afterFullMatch.length > 0) linesInBetween.unshift(afterFullMatch);
+				CODE.replace(rootNode, null, startMatch, endMatch, linesInBetween, true);
+				return [true, i];
+			}
+		}
+		const linesInBetween = lines.slice(startLineIndex + 1);
+		const afterFullMatch = currentLine.slice(startMatch[0].length);
+		if (afterFullMatch.length > 0) linesInBetween.unshift(afterFullMatch);
+		CODE.replace(rootNode, null, startMatch, null, linesInBetween, true);
+		return [true, lines.length - 1];
+	},
+	regExpEnd: {
+		optional: true,
+		regExp: CODE_END_REGEX
+	},
+	regExpStart: CODE_START_REGEX,
+	replace: (rootNode, children, startMatch, endMatch, linesInBetween, isImport) => {
+		let codeBlockNode;
+		let code;
+		const fence = startMatch[1] ? startMatch[1].trim() : "```";
+		const language = startMatch[2] || void 0;
+		if (!children && linesInBetween) {
+			if (linesInBetween.length === 1) if (endMatch) {
+				codeBlockNode = $createCodeNode(language);
+				code = linesInBetween[0];
+			} else {
+				codeBlockNode = $createCodeNode(language);
+				code = linesInBetween[0].startsWith(" ") ? linesInBetween[0].slice(1) : linesInBetween[0];
+			}
+			else {
+				codeBlockNode = $createCodeNode(language);
+				if (linesInBetween.length > 0) {
+					if (linesInBetween[0].trim().length === 0) linesInBetween.shift();
+					else if (linesInBetween[0].startsWith(" ")) linesInBetween[0] = linesInBetween[0].slice(1);
+				}
+				while (linesInBetween.length > 0 && !linesInBetween[linesInBetween.length - 1].length) linesInBetween.pop();
+				code = linesInBetween.join("\n");
+			}
+			$setState(codeBlockNode, codeFenceState, fence);
+			const textNode = $createTextNode(code);
+			codeBlockNode.append(textNode);
+			rootNode.append(codeBlockNode);
+		} else if (children) createBlockNode((match) => {
+			return $createCodeNode(match ? match[2] : void 0);
+		})(rootNode, children, startMatch, isImport);
+	},
+	type: "multiline-element"
+};
+const UNORDERED_LIST = {
+	dependencies: [ListNode, ListItemNode],
+	export: (node, exportChildren) => {
+		return $isListNode(node) ? $listExport(node, exportChildren, 0) : null;
+	},
+	regExp: UNORDERED_LIST_REGEX,
+	replace: listReplace("bullet"),
+	type: "element"
+};
+const CHECK_LIST = {
+	dependencies: [ListNode, ListItemNode],
+	export: (node, exportChildren) => {
+		return $isListNode(node) ? $listExport(node, exportChildren, 0) : null;
+	},
+	regExp: CHECK_LIST_REGEX,
+	replace: listReplace("check"),
+	type: "element"
+};
+const ORDERED_LIST = {
+	dependencies: [ListNode, ListItemNode],
+	export: (node, exportChildren) => {
+		return $isListNode(node) ? $listExport(node, exportChildren, 0) : null;
+	},
+	regExp: ORDERED_LIST_REGEX,
+	replace: listReplace("number"),
+	type: "element"
+};
+const INLINE_CODE = {
+	format: ["code"],
+	tag: "`",
+	type: "text-format"
+};
+const HIGHLIGHT = {
+	format: ["highlight"],
+	tag: "==",
+	type: "text-format"
+};
+const BOLD_ITALIC_STAR = {
+	format: ["bold", "italic"],
+	tag: "***",
+	type: "text-format"
+};
+const BOLD_ITALIC_UNDERSCORE = {
+	format: ["bold", "italic"],
+	intraword: false,
+	tag: "___",
+	type: "text-format"
+};
+const BOLD_STAR = {
+	format: ["bold"],
+	tag: "**",
+	type: "text-format"
+};
+const BOLD_UNDERSCORE = {
+	format: ["bold"],
+	intraword: false,
+	tag: "__",
+	type: "text-format"
+};
+const STRIKETHROUGH = {
+	format: ["strikethrough"],
+	tag: "~~",
+	type: "text-format"
+};
+const ITALIC_STAR = {
+	format: ["italic"],
+	tag: "*",
+	type: "text-format"
+};
+const ITALIC_UNDERSCORE = {
+	format: ["italic"],
+	intraword: false,
+	tag: "_",
+	type: "text-format"
+};
+const LINK = {
+	dependencies: [LinkNode],
+	export: (node, exportChildren, exportFormat) => {
+		if (!$isLinkNode(node) || $isAutoLinkNode(node)) return null;
+		const textContent = exportChildren(node);
+		let title = node.getTitle();
+		if (title != null) title = title.replace(/([\\"])/g, "\\$1");
+		return title ? `[${textContent}](${node.getURL()} "${title}")` : `[${textContent}](${node.getURL()})`;
+	},
+	importRegExp: /(?:\[(.+?)\])(?:\((?:([^()\s]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?)\))/,
+	regExp: /(?:\[([^[\]]*(?:\[[^[\]]*\][^[\]]*)*)\])(?:\((?:([^()\s]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?)\))$/,
+	replace: (textNode, match) => {
+		if ($findMatchingParent(textNode, $isLinkNode)) return;
+		const [, linkText, rawLinkUrl, rawLinkTitle] = match;
+		const linkNode = $createLinkNode(rawLinkUrl != null ? unescapeText(rawLinkUrl) : void 0, { title: rawLinkTitle != null ? unescapeText(rawLinkTitle) : void 0 });
+		const openBracketAmount = linkText.split("[").length - 1;
+		const closeBracketAmount = linkText.split("]").length - 1;
+		let parsedLinkText = linkText;
+		let outsideLinkText = "";
+		if (openBracketAmount < closeBracketAmount) return;
+		else if (openBracketAmount > closeBracketAmount) {
+			const linkTextParts = linkText.split("[");
+			outsideLinkText = "[" + linkTextParts[0];
+			parsedLinkText = linkTextParts.slice(1).join("[");
+		}
+		const linkTextNode = $createTextNode(parsedLinkText);
+		linkTextNode.setFormat(textNode.getFormat());
+		linkNode.append(linkTextNode);
+		textNode.replace(linkNode);
+		if (outsideLinkText) linkNode.insertBefore($createTextNode(outsideLinkText));
+		return linkTextNode;
+	},
+	trigger: ")",
+	type: "text-match"
+};
+const ELEMENT_TRANSFORMERS = [
+	HEADING,
+	QUOTE,
+	UNORDERED_LIST,
+	ORDERED_LIST
+];
+const MULTILINE_ELEMENT_TRANSFORMERS = [CODE];
+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 = [LINK];
+const TRANSFORMERS = [
+	...ELEMENT_TRANSFORMERS,
+	...MULTILINE_ELEMENT_TRANSFORMERS,
+	...TEXT_FORMAT_TRANSFORMERS,
+	...TEXT_MATCH_TRANSFORMERS
+];
+function normalizeMarkdown(input, shouldMergeAdjacentLines = false) {
+	const lines = input.split("\n");
+	let inCodeBlock = false;
+	const sanitizedLines = [];
+	for (let i = 0; i < lines.length; i++) {
+		const rawLine = lines[i];
+		const line = rawLine.trimEnd();
+		const lastLine = sanitizedLines[sanitizedLines.length - 1];
+		if (CODE_SINGLE_LINE_REGEX.test(line)) {
+			sanitizedLines.push(line);
+			continue;
+		}
+		if (CODE_START_REGEX.test(line) || CODE_END_REGEX.test(line)) {
+			inCodeBlock = !inCodeBlock;
+			sanitizedLines.push(line);
+			continue;
+		}
+		if (inCodeBlock) {
+			sanitizedLines.push(rawLine);
+			continue;
+		}
+		if (line === "" || lastLine === "" || !lastLine || HEADING_REGEX.test(lastLine) || HEADING_REGEX.test(line) || QUOTE_REGEX.test(line) || ORDERED_LIST_REGEX.test(line) || UNORDERED_LIST_REGEX.test(line) || CHECK_LIST_REGEX.test(line) || TABLE_ROW_REG_EXP.test(line) || TABLE_ROW_DIVIDER_REG_EXP.test(line) || !shouldMergeAdjacentLines || TAG_START_REGEX.test(line) || TAG_END_REGEX.test(line) || ENDS_WITH(TAG_END_REGEX).test(lastLine) || ENDS_WITH(TAG_START_REGEX).test(lastLine) || CODE_END_REGEX.test(lastLine)) sanitizedLines.push(!shouldMergeAdjacentLines && line !== "" ? rawLine : line);
+		else sanitizedLines[sanitizedLines.length - 1] = lastLine + " " + line.trimStart();
+	}
+	return sanitizedLines.join("\n");
+}
+function runElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers) {
+	if (!$isRootOrShadowRoot(parentNode.getParent()) || parentNode.getFirstChild() !== anchorNode) return false;
+	const textContent = anchorNode.getTextContent();
+	if (textContent[anchorOffset - 1] !== " ") return false;
+	for (const { regExp, replace } of elementTransformers) {
+		const match = textContent.match(regExp);
+		if (match && match[0].length === (match[0].endsWith(" ") ? anchorOffset : anchorOffset - 1)) {
+			const nextSiblings = anchorNode.getNextSiblings();
+			const [leadingNode, remainderNode] = anchorNode.splitText(anchorOffset);
+			if (replace(parentNode, remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings, match, false) !== false) {
+				leadingNode.remove();
+				return true;
+			}
+		}
+	}
+	return false;
+}
+function runMultilineElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers, triggerOnEnter) {
+	if (!$isRootOrShadowRoot(parentNode.getParent()) || parentNode.getFirstChild() !== anchorNode) return false;
+	const textContent = anchorNode.getTextContent();
+	if (!triggerOnEnter) {
+		if (textContent[anchorOffset - 1] !== " ") return false;
+	}
+	for (const { regExpStart, replace, regExpEnd } of elementTransformers) {
+		if (regExpEnd && !("optional" in regExpEnd) || regExpEnd && "optional" in regExpEnd && !regExpEnd.optional) continue;
+		const match = textContent.match(regExpStart);
+		if (match) {
+			const matchLength = triggerOnEnter || match[0].endsWith(" ") ? anchorOffset : anchorOffset - 1;
+			if (match[0].length !== matchLength) continue;
+			const nextSiblings = anchorNode.getNextSiblings();
+			const [leadingNode, remainderNode] = anchorNode.splitText(anchorOffset);
+			if (replace(parentNode, remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings, match, null, null, false) !== false) {
+				leadingNode.remove();
+				return true;
+			}
+		}
+	}
+	return false;
+}
+function runTextMatchTransformers(anchorNode, anchorOffset, transformersByTrigger) {
+	let textContent = anchorNode.getTextContent();
+	const transformers = transformersByTrigger[textContent[anchorOffset - 1]];
+	if (transformers == null) return false;
+	if (anchorOffset < textContent.length) textContent = textContent.slice(0, anchorOffset);
+	for (const transformer of transformers) {
+		if (!transformer.replace || !transformer.regExp) continue;
+		const match = textContent.match(transformer.regExp);
+		if (match === null) continue;
+		const startIndex = match.index || 0;
+		const endIndex = startIndex + match[0].length;
+		let replaceNode;
+		if (startIndex === 0) [replaceNode] = anchorNode.splitText(endIndex);
+		else [, replaceNode] = anchorNode.splitText(startIndex, endIndex);
+		replaceNode.selectNext(0, 0);
+		transformer.replace(replaceNode, match);
+		return true;
+	}
+	return false;
+}
+function $runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransformers) {
+	const textContent = anchorNode.getTextContent();
+	const closeTagEndIndex = anchorOffset - 1;
+	const closeChar = textContent[closeTagEndIndex];
+	const matchers = textFormatTransformers[closeChar];
+	if (!matchers) return false;
+	for (const matcher of matchers) {
+		const { tag } = matcher;
+		const tagLength = tag.length;
+		const closeTagStartIndex = closeTagEndIndex - tagLength + 1;
+		if (tagLength > 1) {
+			if (!isEqualSubString(textContent, closeTagStartIndex, tag, 0, tagLength)) continue;
+		}
+		if (textContent[closeTagStartIndex - 1] === " ") continue;
+		const afterCloseTagChar = textContent[closeTagEndIndex + 1];
+		if (matcher.intraword === false && afterCloseTagChar && !PUNCTUATION_OR_SPACE.test(afterCloseTagChar)) continue;
+		const closeNode = anchorNode;
+		let openNode = closeNode;
+		let openTagStartIndex = getOpenTagStartIndex(textContent, closeTagStartIndex, tag);
+		let sibling = openNode;
+		while (openTagStartIndex < 0 && (sibling = sibling.getPreviousSibling())) {
+			if ($isLineBreakNode(sibling)) break;
+			if ($isTextNode(sibling)) {
+				if (sibling.hasFormat("code")) continue;
+				const siblingTextContent = sibling.getTextContent();
+				openNode = sibling;
+				openTagStartIndex = getOpenTagStartIndex(siblingTextContent, siblingTextContent.length, tag);
+			}
+		}
+		if (openTagStartIndex < 0) continue;
+		if (openNode === closeNode && openTagStartIndex + tagLength === closeTagStartIndex) continue;
+		const prevOpenNodeText = openNode.getTextContent();
+		if (openTagStartIndex > 0 && prevOpenNodeText[openTagStartIndex - 1] === closeChar) continue;
+		const beforeOpenTagChar = prevOpenNodeText[openTagStartIndex - 1];
+		if (matcher.intraword === false && beforeOpenTagChar && !PUNCTUATION_OR_SPACE.test(beforeOpenTagChar)) continue;
+		if (!matcher.format.includes("code") && $isInsideUnclosedCodeSpan(openNode, openTagStartIndex)) continue;
+		const prevCloseNodeText = closeNode.getTextContent();
+		const closeNodeText = prevCloseNodeText.slice(0, closeTagStartIndex) + prevCloseNodeText.slice(closeTagEndIndex + 1);
+		closeNode.setTextContent(closeNodeText);
+		const openNodeText = openNode === closeNode ? closeNodeText : prevOpenNodeText;
+		openNode.setTextContent(openNodeText.slice(0, openTagStartIndex) + openNodeText.slice(openTagStartIndex + tagLength));
+		const selection = $getSelection();
+		const nextSelection = $createRangeSelection();
+		$setSelection(nextSelection);
+		const newOffset = closeTagEndIndex - tagLength * (openNode === closeNode ? 2 : 1) + 1;
+		nextSelection.anchor.set(openNode.__key, openTagStartIndex, "text");
+		nextSelection.focus.set(closeNode.__key, newOffset, "text");
+		for (const format of matcher.format) if (!nextSelection.hasFormat(format)) nextSelection.formatText(format);
+		nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type);
+		for (const format of matcher.format) if (nextSelection.hasFormat(format)) nextSelection.toggleFormat(format);
+		if ($isRangeSelection(selection)) nextSelection.format = selection.format;
+		return true;
+	}
+	return false;
+}
+function $isInsideUnclosedCodeSpan(node, offset) {
+	let backtickCount = 0;
+	const text = node.getTextContent();
+	for (let i = 0; i < offset; i++) if (text[i] === "`") backtickCount++;
+	return backtickCount % 2 !== 0;
+}
+function getOpenTagStartIndex(string, maxIndex, tag) {
+	const tagLength = tag.length;
+	for (let i = maxIndex; i >= tagLength; i--) {
+		const startIndex = i - tagLength;
+		if (isEqualSubString(string, startIndex, tag, 0, tagLength) && string[startIndex + tagLength] !== " ") return startIndex;
+	}
+	return -1;
+}
+function isEqualSubString(stringA, aStart, stringB, bStart, length) {
+	for (let i = 0; i < length; i++) if (stringA[aStart + i] !== stringB[bStart + i]) return false;
+	return true;
+}
+function registerMarkdownShortcuts(editor, transformers = TRANSFORMERS) {
+	const byType = transformersByType(transformers);
+	const textFormatTransformersByTrigger = indexBy(byType.textFormat, ({ tag }) => tag[tag.length - 1]);
+	const textMatchTransformersByTrigger = indexBy(byType.textMatch, ({ trigger }) => trigger);
+	for (const transformer of transformers) {
+		const type = transformer.type;
+		if (type === "element" || type === "text-match" || type === "multiline-element") {
+			const dependencies = transformer.dependencies;
+			for (const node of dependencies) if (!editor.hasNode(node)) formatDevErrorMessage(`MarkdownShortcuts: missing dependency ${node.getType()} for transformer. Ensure node dependency is included in editor initial config.`);
+		}
+	}
+	const $transform = (parentNode, anchorNode, anchorOffset) => {
+		if (runElementTransformers(parentNode, anchorNode, anchorOffset, byType.element)) return true;
+		if (runMultilineElementTransformers(parentNode, anchorNode, anchorOffset, byType.multilineElement)) return true;
+		if (runTextMatchTransformers(anchorNode, anchorOffset, textMatchTransformersByTrigger)) return true;
+		if ($runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransformersByTrigger)) return true;
+		return false;
+	};
+	return mergeRegister(editor.registerUpdateListener(({ tags, dirtyLeaves, editorState, prevEditorState }) => {
+		if (tags.has(COLLABORATION_TAG) || tags.has(HISTORIC_TAG)) return;
+		if (editor.isComposing()) return;
+		const selection = editorState.read($getSelection);
+		const prevSelection = prevEditorState.read($getSelection);
+		if (!$isRangeSelection(prevSelection) || !$isRangeSelection(selection) || !selection.isCollapsed() || selection.is(prevSelection)) return;
+		const anchorKey = selection.anchor.key;
+		const anchorOffset = selection.anchor.offset;
+		const anchorNode = editorState._nodeMap.get(anchorKey);
+		if (!$isTextNode(anchorNode) || !dirtyLeaves.has(anchorKey) || anchorOffset !== 1 && anchorOffset > prevSelection.anchor.offset + 1) return;
+		editor.update(() => {
+			if (!canContainTransformableMarkdown(anchorNode)) return;
+			const parentNode = anchorNode.getParent();
+			if (parentNode === null || $isCodeNode(parentNode)) return;
+			if ($transform(parentNode, anchorNode, selection.anchor.offset)) $addUpdateTag(HISTORY_PUSH_TAG);
+		});
+	}), editor.registerCommand(KEY_ENTER_COMMAND, (event) => {
+		if (event !== null && event.shiftKey) return false;
+		const selection = $getSelection();
+		if (!$isRangeSelection(selection) || !selection.isCollapsed()) return false;
+		const anchorOffset = selection.anchor.offset;
+		const anchorNode = selection.anchor.getNode();
+		if (!$isTextNode(anchorNode) || !canContainTransformableMarkdown(anchorNode)) return false;
+		const parentNode = anchorNode.getParent();
+		if (parentNode === null || $isCodeNode(parentNode)) return false;
+		if (anchorOffset !== anchorNode.getTextContent().length) return false;
+		if (runMultilineElementTransformers(parentNode, anchorNode, anchorOffset, byType.multilineElement, true)) {
+			if (event !== null) event.preventDefault();
+			return true;
+		}
+		return false;
+	}, COMMAND_PRIORITY_LOW));
+}
+/**
+* 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.
+*
+*/
+/**
+* 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 = false) {
+	const sanitizedMarkdown = shouldPreserveNewLines ? markdown : normalizeMarkdown(markdown, shouldMergeAdjacentLines);
+	return createMarkdownImport(transformers, shouldPreserveNewLines)(sanitizedMarkdown, node);
+}
+/**
+* Renders string from markdown. The selection is moved to the start after the operation.
+*/
+function $convertToMarkdownString(transformers = TRANSFORMERS, node, shouldPreserveNewLines = false) {
+	return createMarkdownExport(transformers, shouldPreserveNewLines)(node);
+}
+//#endregion
+export { $convertFromMarkdownString, $convertToMarkdownString, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, CHECK_LIST, CODE, ELEMENT_TRANSFORMERS, HEADING, HIGHLIGHT, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, LINK, MULTILINE_ELEMENT_TRANSFORMERS, ORDERED_LIST, QUOTE, STRIKETHROUGH, TEXT_FORMAT_TRANSFORMERS, TEXT_MATCH_TRANSFORMERS, TRANSFORMERS, UNORDERED_LIST, registerMarkdownShortcuts };
+
+//# sourceMappingURL=LexicalMarkdown.dev-C8e-eh6y.mjs.map