@antdv-next/x-markdown 0.0.2 → 0.1.0

package/dist/index.js

@@ -1,1138 +1,13 @@
-import "./index.css";
-import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, h, normalizeClass, normalizeStyle, onMounted, onUnmounted, openBlock, ref, renderList, shallowRef, toDisplayString, unref, watch } from "vue";
-import { Marked } from "marked";
-import DOMPurify from "dompurify";
-//#region src/XMarkdown/components/DebugPanel.vue?vue&type=script&setup=true&lang.ts
-var _hoisted_1$1 = { class: "xmd-debug-content" };
-var _hoisted_2 = { class: "xmd-debug-stat" };
-var _hoisted_3 = { class: "xmd-debug-stat" };
-var _hoisted_4 = {
-	class: "xmd-debug-chart",
-	viewBox: "0 0 200 60"
-};
-var _hoisted_5 = ["d"];
-var maxSnapshots = 60;
-var DebugPanel_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
-	__name: "DebugPanel",
-	props: { className: {} },
-	setup(__props) {
-		const isDragging = ref(false);
-		const position = ref({
-			x: 20,
-			y: 20
-		});
-		const dragOffset = ref({
-			x: 0,
-			y: 0
-		});
-		const fps = ref(0);
-		const memory = ref(0);
-		const snapshots = ref([]);
-		let animationFrameId = null;
-		let lastFrameTime = 0;
-		let frameCount = 0;
-		function startMonitoring() {
-			lastFrameTime = performance.now();
-			frameCount = 0;
-			function monitor() {
-				frameCount++;
-				const now = performance.now();
-				const elapsed = now - lastFrameTime;
-				if (elapsed >= 1e3) {
-					fps.value = Math.round(frameCount * 1e3 / elapsed);
-					frameCount = 0;
-					lastFrameTime = now;
-					if ("memory" in performance) {
-						const memInfo = performance.memory;
-						memory.value = memInfo ? Math.round(memInfo.usedJSHeapSize / 1024 / 1024) : 0;
-					}
-					snapshots.value.push({
-						fps: fps.value,
-						memory: memory.value,
-						timestamp: Date.now()
-					});
-					if (snapshots.value.length > maxSnapshots) snapshots.value.shift();
-				}
-				animationFrameId = requestAnimationFrame(monitor);
-			}
-			animationFrameId = requestAnimationFrame(monitor);
-		}
-		function stopMonitoring() {
-			if (animationFrameId !== null) {
-				cancelAnimationFrame(animationFrameId);
-				animationFrameId = null;
-			}
-		}
-		function handleMouseDown(e) {
-			isDragging.value = true;
-			dragOffset.value = {
-				x: e.clientX - position.value.x,
-				y: e.clientY - position.value.y
-			};
-		}
-		function handleMouseMove(e) {
-			if (!isDragging.value) return;
-			position.value = {
-				x: e.clientX - dragOffset.value.x,
-				y: e.clientY - dragOffset.value.y
-			};
-		}
-		function handleMouseUp() {
-			isDragging.value = false;
-		}
-		function getFpsColor(fpsValue) {
-			if (fpsValue >= 55) return "#52c41a";
-			if (fpsValue >= 40) return "#faad14";
-			return "#ff4d4f";
-		}
-		function getChartPath() {
-			if (snapshots.value.length < 2) return "";
-			const width = 200;
-			const height = 60;
-			const maxFps = 60;
-			return `M ${snapshots.value.map((s, i) => {
-				return `${i / (maxSnapshots - 1) * width},${height - s.fps / maxFps * height}`;
-			}).join(" L ")}`;
-		}
-		onMounted(() => {
-			startMonitoring();
-			document.addEventListener("mousemove", handleMouseMove);
-			document.addEventListener("mouseup", handleMouseUp);
-		});
-		onUnmounted(() => {
-			stopMonitoring();
-			document.removeEventListener("mousemove", handleMouseMove);
-			document.removeEventListener("mouseup", handleMouseUp);
-		});
-		return (_ctx, _cache) => {
-			return openBlock(), createElementBlock("div", {
-				class: normalizeClass(["xmd-debug-panel", __props.className]),
-				style: normalizeStyle({
-					left: `${position.value.x}px`,
-					top: `${position.value.y}px`
-				})
-			}, [createElementVNode("div", {
-				class: "xmd-debug-header",
-				onMousedown: handleMouseDown
-			}, [..._cache[0] || (_cache[0] = [createElementVNode("span", null, "Debug Panel", -1)])], 32), createElementVNode("div", _hoisted_1$1, [
-				createElementVNode("div", _hoisted_2, [_cache[1] || (_cache[1] = createElementVNode("span", { class: "xmd-debug-label" }, "FPS:", -1)), createElementVNode("span", { style: normalizeStyle({ color: getFpsColor(fps.value) }) }, toDisplayString(fps.value), 5)]),
-				createElementVNode("div", _hoisted_3, [_cache[2] || (_cache[2] = createElementVNode("span", { class: "xmd-debug-label" }, "Memory:", -1)), createElementVNode("span", null, toDisplayString(memory.value) + " MB", 1)]),
-				(openBlock(), createElementBlock("svg", _hoisted_4, [createElementVNode("path", {
-					d: getChartPath(),
-					fill: "none",
-					stroke: "#1890ff",
-					"stroke-width": "2"
-				}, null, 8, _hoisted_5)]))
-			])], 6);
-		};
-	}
-});
-//#endregion
-//#region \0plugin-vue:export-helper
-var _plugin_vue_export_helper_default = (sfc, props) => {
-	const target = sfc.__vccOpts || sfc;
-	for (const [key, val] of props) target[key] = val;
-	return target;
-};
-//#endregion
-//#region src/XMarkdown/components/DebugPanel.vue
-var DebugPanel_default = /* @__PURE__ */ _plugin_vue_export_helper_default(DebugPanel_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-d6923a13"]]);
-//#endregion
-//#region src/XMarkdown/components/TailIndicator.vue?vue&type=script&setup=true&lang.ts
-var _hoisted_1 = { class: "xmd-tail" };
-//#endregion
-//#region src/XMarkdown/components/TailIndicator.vue
-var TailIndicator_default = /* @__PURE__ */ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
-	__name: "TailIndicator",
-	props: { content: { default: "▋" } },
-	setup(__props) {
-		return (_ctx, _cache) => {
-			return openBlock(), createElementBlock("span", _hoisted_1, toDisplayString(__props.content), 1);
-		};
-	}
-}), [["__scopeId", "data-v-802ace82"]]);
-//#endregion
-//#region src/XMarkdown/interface.ts
-var StreamCacheTokenType = /* @__PURE__ */ function(StreamCacheTokenType) {
-	StreamCacheTokenType["Text"] = "text";
-	StreamCacheTokenType["Link"] = "link";
-	StreamCacheTokenType["Image"] = "image";
-	StreamCacheTokenType["Html"] = "html";
-	StreamCacheTokenType["Emphasis"] = "emphasis";
-	StreamCacheTokenType["List"] = "list";
-	StreamCacheTokenType["Table"] = "table";
-	StreamCacheTokenType["InlineCode"] = "inline-code";
-	return StreamCacheTokenType;
-}({});
-//#endregion
-//#region src/XMarkdown/composables/useStreaming.ts
-var STREAM_INCOMPLETE_REGEX = {
-	image: [/^!\[[^\]\r\n]{0,1000}$/, /^!\[[^\r\n]{0,1000}\]\(*[^)\r\n]{0,1000}$/],
-	link: [/^\[[^\]\r\n]{0,1000}$/, /^\[[^\r\n]{0,1000}\]\(*[^)\r\n]{0,1000}$/],
-	html: [/^<\/$/, /^<\/?[a-zA-Z][a-zA-Z0-9-]{0,100}[^>\r\n]{0,1000}$/],
-	commonEmphasis: [/^(\*{1,3}|_{1,3})(?!\s)(?!.*\1$)[^\r\n]{0,1000}$/],
-	list: [/^[-+*]\s{0,3}$/, /^[-+*]\s{1,3}(\*{1,3}|_{1,3})(?!\s)(?!.*\1$)[^\r\n]{0,1000}$/],
-	"inline-code": [/^`[^`\r\n]{0,300}$/]
-};
-var isTableInComplete = (markdown) => {
-	if (markdown.includes("\n\n")) return false;
-	const lines = markdown.split("\n");
-	if (lines.length <= 1) return true;
-	const [header, separator] = lines;
-	const trimmedHeader = header.trim();
-	if (!/^\|.*\|$/.test(trimmedHeader)) return false;
-	const columns = separator.trim().split("|").map((col) => col.trim()).filter(Boolean);
-	const separatorRegex = /^:?-+:?$/;
-	return columns.every((col, index) => index === columns.length - 1 ? col === ":" || separatorRegex.test(col) : separatorRegex.test(col));
-};
-var tokenRecognizerMap = {
-	[StreamCacheTokenType.Link]: {
-		tokenType: StreamCacheTokenType.Link,
-		isStartOfToken: (markdown) => markdown.startsWith("["),
-		isStreamingValid: (markdown) => STREAM_INCOMPLETE_REGEX.link.some((re) => re.test(markdown))
-	},
-	[StreamCacheTokenType.Image]: {
-		tokenType: StreamCacheTokenType.Image,
-		isStartOfToken: (markdown) => markdown.startsWith("!"),
-		isStreamingValid: (markdown) => STREAM_INCOMPLETE_REGEX.image.some((re) => re.test(markdown))
-	},
-	[StreamCacheTokenType.Html]: {
-		tokenType: StreamCacheTokenType.Html,
-		isStartOfToken: (markdown) => markdown.startsWith("<"),
-		isStreamingValid: (markdown) => STREAM_INCOMPLETE_REGEX.html.some((re) => re.test(markdown))
-	},
-	[StreamCacheTokenType.Emphasis]: {
-		tokenType: StreamCacheTokenType.Emphasis,
-		isStartOfToken: (markdown) => markdown.startsWith("*") || markdown.startsWith("_"),
-		isStreamingValid: (markdown) => STREAM_INCOMPLETE_REGEX.commonEmphasis.some((re) => re.test(markdown))
-	},
-	[StreamCacheTokenType.List]: {
-		tokenType: StreamCacheTokenType.List,
-		isStartOfToken: (markdown) => /^[-+*]/.test(markdown),
-		isStreamingValid: (markdown) => STREAM_INCOMPLETE_REGEX.list.some((re) => re.test(markdown)),
-		getCommitPrefix: (pending) => {
-			const listPrefix = pending.match(/^([-+*]\s{0,3})/)?.[1];
-			const rest = listPrefix ? pending.slice(listPrefix.length) : "";
-			return listPrefix && rest.startsWith("`") ? listPrefix : null;
-		}
-	},
-	[StreamCacheTokenType.Table]: {
-		tokenType: StreamCacheTokenType.Table,
-		isStartOfToken: (markdown) => markdown.startsWith("|"),
-		isStreamingValid: isTableInComplete
-	},
-	[StreamCacheTokenType.InlineCode]: {
-		tokenType: StreamCacheTokenType.InlineCode,
-		isStartOfToken: (markdown) => markdown.startsWith("`"),
-		isStreamingValid: (markdown) => STREAM_INCOMPLETE_REGEX["inline-code"].some((re) => re.test(markdown))
-	}
-};
-var recognize = (cache, tokenType) => {
-	const recognizer = tokenRecognizerMap[tokenType];
-	if (!recognizer) return;
-	const { token, pending } = cache;
-	if (token === StreamCacheTokenType.Text && recognizer.isStartOfToken(pending)) {
-		cache.token = tokenType;
-		return;
-	}
-	if (token === tokenType && !recognizer.isStreamingValid(pending)) {
-		const prefix = recognizer.getCommitPrefix?.(pending);
-		if (prefix) {
-			cache.completeMarkdown += prefix;
-			cache.pending = pending.slice(prefix.length);
-			cache.token = StreamCacheTokenType.Text;
-			return;
-		}
-		commitCache(cache);
-	}
-};
-var recognizeHandlers = Object.values(tokenRecognizerMap).filter((recognizer) => Boolean(recognizer));
-var getInitialCache = () => ({
-	pending: "",
-	token: StreamCacheTokenType.Text,
-	processedLength: 0,
-	completeMarkdown: ""
-});
-var commitCache = (cache) => {
-	if (cache.pending) {
-		cache.completeMarkdown += cache.pending;
-		cache.pending = "";
-	}
-	cache.token = StreamCacheTokenType.Text;
-};
-var isInCodeBlock = (text, isFinalChunk = false) => {
-	const lines = text.split("\n");
-	let inFenced = false;
-	let fenceChar = "";
-	let fenceLen = 0;
-	for (let i = 0; i < lines.length; i++) {
-		const rawLine = lines[i];
-		const match = (rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine).match(/^(`{3,}|~{3,})(.*)$/);
-		if (!match) continue;
-		const fence = match[1];
-		const after = match[2];
-		const char = fence[0];
-		const len = fence.length;
-		if (!inFenced) {
-			inFenced = true;
-			fenceChar = char;
-			fenceLen = len;
-			continue;
-		}
-		if (char === fenceChar && len >= fenceLen && /^\s*$/.test(after) && (isFinalChunk || i < lines.length - 1)) {
-			inFenced = false;
-			fenceChar = "";
-			fenceLen = 0;
-		}
-	}
-	return inFenced;
-};
-var sanitizeForURIComponent = (input) => {
-	let result = "";
-	for (let i = 0; i < input.length; i++) {
-		const charCode = input.charCodeAt(i);
-		if (charCode >= 55296 && charCode <= 56319) {
-			if (i + 1 < input.length && input.charCodeAt(i + 1) >= 56320 && input.charCodeAt(i + 1) <= 57343) {
-				result += input[i] + input[i + 1];
-				i++;
-			}
-		} else if (charCode < 56320 || charCode > 57343) result += input[i];
-	}
-	return result;
-};
-var safeEncodeURIComponent = (str) => {
-	try {
-		return encodeURIComponent(str);
-	} catch (error) {
-		if (error instanceof URIError) return encodeURIComponent(sanitizeForURIComponent(str));
-		return "";
-	}
-};
-function useStreaming(content, streaming, components) {
-	const streamCache = ref(getInitialCache());
-	const processedContent = ref("");
-	function handleIncompleteMarkdown(cache, opts) {
-		const { token, pending } = cache;
-		if (token === StreamCacheTokenType.Text) return void 0;
-		if (token === StreamCacheTokenType.Image && pending === "!") return;
-		if (token === StreamCacheTokenType.Table && pending.split("\n").length > 2) return pending;
-		const componentName = opts?.incompleteMarkdownComponentMap?.[token] ?? `incomplete-${token}`;
-		if (!components?.value?.[componentName]) return;
-		return `<${componentName} data-raw="${safeEncodeURIComponent(pending)}" />`;
-	}
-	function processStreaming(text, opts) {
-		if (!text) {
-			processedContent.value = "";
-			streamCache.value = getInitialCache();
-			return;
-		}
-		const expectedPrefix = streamCache.value.completeMarkdown + streamCache.value.pending;
-		if (!text.startsWith(expectedPrefix)) streamCache.value = getInitialCache();
-		const cache = streamCache.value;
-		const chunk = text.slice(cache.processedLength);
-		if (!chunk) {
-			const incompletePlaceholder = handleIncompleteMarkdown(cache, opts);
-			processedContent.value = cache.completeMarkdown + (incompletePlaceholder || "");
-			return;
-		}
-		cache.processedLength += chunk.length;
-		for (const char of chunk) {
-			cache.pending += char;
-			if (isInCodeBlock(cache.completeMarkdown + cache.pending)) {
-				commitCache(cache);
-				continue;
-			}
-			if (cache.token === StreamCacheTokenType.Text) for (const handler of recognizeHandlers) recognize(cache, handler.tokenType);
-			else {
-				const currentHandler = recognizeHandlers.find((handler) => handler.tokenType === cache.token);
-				if (currentHandler) recognize(cache, currentHandler.tokenType);
-				if (cache.token === StreamCacheTokenType.Text) for (const handler of recognizeHandlers) recognize(cache, handler.tokenType);
-			}
-			if (cache.token === StreamCacheTokenType.Text) commitCache(cache);
-		}
-		const incompletePlaceholder = handleIncompleteMarkdown(cache, opts);
-		processedContent.value = cache.completeMarkdown + (incompletePlaceholder || "");
-	}
-	function reset() {
-		streamCache.value = getInitialCache();
-		processedContent.value = "";
-	}
-	watch([content, () => streaming.value?.hasNextChunk], ([newContent, hasNextChunk]) => {
-		const opts = streaming.value;
-		if (!Boolean(hasNextChunk)) {
-			processedContent.value = newContent;
-			streamCache.value = {
-				pending: "",
-				token: StreamCacheTokenType.Text,
-				processedLength: newContent.length,
-				completeMarkdown: newContent
-			};
-			return;
-		}
-		processStreaming(newContent, opts);
-	}, { immediate: true });
-	return {
-		processedContent,
-		reset
-	};
-}
-//#endregion
-//#region src/XMarkdown/composables/useTail.ts
-var DEFAULT_TAIL_CONTENT$1 = "▋";
-function useTail(streaming) {
-	const tailContent = computed(() => {
-		const tail = streaming.value?.tail;
-		if (!tail) return null;
-		if (typeof tail === "boolean") return DEFAULT_TAIL_CONTENT$1;
-		return tail.content || DEFAULT_TAIL_CONTENT$1;
-	});
-	return {
-		tailContent,
-		tailComponent: computed(() => {
-			const tail = streaming.value?.tail;
-			if (!tail) return null;
-			if (typeof tail === "boolean") return null;
-			return tail.component || null;
-		}),
-		showTail: computed(() => {
-			return streaming.value?.hasNextChunk && tailContent.value !== null;
-		})
-	};
-}
-//#endregion
-//#region src/XMarkdown/core/Parser.ts
-var escapeReplacements = {
-	"&": "&amp;",
-	"<": "&lt;",
-	">": "&gt;",
-	"\"": "&quot;",
-	"'": "&#39;"
-};
-function escapeHtml(html) {
-	if (/[&<>"']/.test(html)) return html.replace(/[&<>"']/g, (ch) => escapeReplacements[ch] || ch);
-	return html;
-}
-var Parser = class Parser {
-	static COMPLETE_FENCED_CODE = /^ {0,3}(`{3,}|~{3,})([\s\S]*?)\n {0,3}\1[ \n\t]*$/;
-	options;
-	markdownInstance;
-	injectTail = false;
-	codeBlockStates = [];
-	codeBlockStateIndex = 0;
-	constructor(options = {}) {
-		this.options = {
-			openLinksInNewTab: options.openLinksInNewTab ?? true,
-			paragraphTag: options.paragraphTag ?? "p",
-			injectTail: options.injectTail ?? false,
-			protectCustomTags: options.protectCustomTags ?? true,
-			escapeRawHtml: options.escapeRawHtml ?? false,
-			config: {
-				gfm: true,
-				...options.config
-			},
-			components: options.components ?? {},
-			streamStatus: options.streamStatus ?? "done",
-			codeBlockStatus: options.codeBlockStatus ?? {}
-		};
-		this.markdownInstance = new Marked(this.options.config);
-		this.configureRenderers();
-	}
-	updateMarkedConfig(config) {
-		this.options.config = {
-			...this.options.config,
-			...config
-		};
-		this.markdownInstance = new Marked(this.options.config);
-		this.configureRenderers();
-	}
-	configureRenderers() {
-		this.markdownInstance.use({ renderer: {
-			html: (html) => {
-				if (this.options.escapeRawHtml) return escapeHtml(html);
-				return html;
-			},
-			link: (href, title, text) => {
-				return `<a href="${href}"${title ? ` title="${title}"` : ""}${this.options.openLinksInNewTab ? ` target="_blank" rel="noopener noreferrer"` : ""}>${text}</a>`;
-			},
-			paragraph: (text) => {
-				if (this.options.paragraphTag === "p") return `<p>${text}</p>`;
-				return `<${this.options.paragraphTag}>${text}</${this.options.paragraphTag}>`;
-			},
-			code: (code, infostring, escaped) => {
-				const lang = infostring || "";
-				return `<pre><code class="language-${lang}"${lang ? ` data-lang="${lang}"` : ""} data-block="true"${` data-state="${this.consumeCodeBlockState(lang)}"`}>${escaped ? code : escapeHtml(code)}</code></pre>`;
-			}
-		} });
-	}
-	prepareCodeBlockStates(markdown) {
-		this.codeBlockStates = [];
-		this.codeBlockStateIndex = 0;
-		const tokens = this.markdownInstance.lexer(markdown);
-		const walkTokens = (nodes) => {
-			for (const node of nodes) {
-				if (!node || typeof node !== "object") continue;
-				const token = node;
-				if (token.type === "code") {
-					const lang = typeof token.lang === "string" ? token.lang : "";
-					const codeBlockStyle = typeof token.codeBlockStyle === "string" ? token.codeBlockStyle : "";
-					const raw = typeof token.raw === "string" ? token.raw : "";
-					const inferredState = codeBlockStyle === "indented" || Parser.COMPLETE_FENCED_CODE.test(raw) ? "done" : "loading";
-					this.codeBlockStates.push(this.options.codeBlockStatus[lang] ?? inferredState);
-				}
-				const childTokens = token.tokens;
-				if (Array.isArray(childTokens)) walkTokens(childTokens);
-				const items = token.items;
-				if (Array.isArray(items)) for (const item of items) {
-					if (!item || typeof item !== "object") continue;
-					const itemTokens = item.tokens;
-					if (Array.isArray(itemTokens)) walkTokens(itemTokens);
-				}
-			}
-		};
-		walkTokens(tokens);
-	}
-	consumeCodeBlockState(lang) {
-		const nextState = this.codeBlockStates[this.codeBlockStateIndex];
-		this.codeBlockStateIndex += 1;
-		return nextState ?? this.getCodeBlockState(lang);
-	}
-	getCodeBlockState(lang) {
-		return this.options.codeBlockStatus[lang] ?? this.options.streamStatus;
-	}
-	parse(markdown, parseOptions) {
-		this.injectTail = parseOptions?.injectTail ?? false;
-		let processed = markdown;
-		if (this.options.protectCustomTags) processed = this.protectCustomTags(processed);
-		if (this.options.escapeRawHtml) processed = this.escapeRawHtml(processed);
-		this.prepareCodeBlockStates(processed);
-		const html = this.markedParse(processed);
-		if (this.injectTail) return this.injectTailMarker(html);
-		return html;
-	}
-	markedParse(markdown) {
-		return this.markdownInstance.parse(markdown);
-	}
-	protectCustomTags(markdown) {
-		const customTagPattern = /<[A-Z][a-zA-Z0-9]*[^>]*>[\s\S]*?<\/[A-Z][a-zA-Z0-9]*>/g;
-		let result = markdown;
-		let placeholderIndex = 0;
-		result = result.replace(customTagPattern, () => {
-			const placeholder = `__CUSTOM_TAG_${placeholderIndex}__`;
-			placeholderIndex++;
-			return placeholder;
-		});
-		return result;
-	}
-	escapeRawHtml(markdown) {
-		return markdown.replace(/<[^>]+>/g, (match) => {
-			return escapeHtml(match);
-		});
-	}
-	injectTailMarker(html) {
-		if (html.includes("<xmd-tail></xmd-tail>")) return html;
-		const container = document.createElement("div");
-		container.innerHTML = html;
-		const findLastMeaningfulNode = (root) => {
-			const children = Array.from(root.childNodes);
-			for (let i = children.length - 1; i >= 0; i--) {
-				const node = children[i];
-				if (node.nodeType === Node.TEXT_NODE) {
-					if ((node.textContent || "").trim()) return node;
-					continue;
-				}
-				if (node.nodeType !== Node.ELEMENT_NODE) continue;
-				const nested = findLastMeaningfulNode(node);
-				if (nested) return nested;
-				return node;
-			}
-			return null;
-		};
-		const lastMeaningfulNode = findLastMeaningfulNode(container);
-		if (!lastMeaningfulNode || lastMeaningfulNode.nodeType !== Node.TEXT_NODE) return html;
-		const marker = document.createElement("xmd-tail");
-		lastMeaningfulNode.parentNode?.insertBefore(marker, lastMeaningfulNode.nextSibling);
-		return container.innerHTML;
-	}
-	setOptions(options) {
-		const { config, ...rest } = options;
-		Object.assign(this.options, rest);
-		if (config) this.updateMarkedConfig(config);
-	}
-};
-//#endregion
-//#region src/XMarkdown/components/AnimationText.vue
-var AnimationText_default = /* @__PURE__ */ defineComponent({
-	__name: "AnimationText",
-	props: {
-		text: {},
-		fadeDuration: { default: 200 },
-		easing: { default: "ease-in-out" }
-	},
-	setup(__props) {
-		const props = __props;
-		const chunks = ref([]);
-		const previousText = ref("");
-		function updateChunks(nextText) {
-			if (nextText === previousText.value) return;
-			if (!Boolean(previousText.value && nextText.startsWith(previousText.value))) {
-				chunks.value = [nextText];
-				previousText.value = nextText;
-				return;
-			}
-			const delta = nextText.slice(previousText.value.length);
-			if (!delta) return;
-			chunks.value = [...chunks.value, delta];
-			previousText.value = nextText;
-		}
-		watch(() => props.text, updateChunks, { immediate: true });
-		const animationStyle = computed(() => ({
-			animation: `x-markdown-fade-in ${props.fadeDuration}ms ${props.easing} forwards`,
-			color: "inherit"
-		}));
-		return (_ctx, _cache) => {
-			return openBlock(true), createElementBlock(Fragment, null, renderList(chunks.value, (chunk, index) => {
-				return openBlock(), createElementBlock("span", {
-					key: `animation-text-${index}`,
-					style: normalizeStyle(animationStyle.value)
-				}, toDisplayString(chunk), 5);
-			}), 128);
-		};
-	}
-});
-//#endregion
-//#region src/XMarkdown/core/detectUnclosedComponentTags.ts
-var WHITESPACE_REGEX = /\s/;
-var TAG_NAME_CHAR_REGEX = /[a-zA-Z0-9-]/;
-var VOID_ELEMENTS = new Set([
-	"area",
-	"base",
-	"br",
-	"col",
-	"embed",
-	"hr",
-	"img",
-	"input",
-	"link",
-	"meta",
-	"param",
-	"source",
-	"track",
-	"wbr"
-]);
-var COMMENT_START = "<!--";
-var COMMENT_END = "-->";
-var CDATA_START = "<![CDATA[";
-var CDATA_END = "]]>";
-var getTagInstanceId = (tagName, instance) => `${tagName}-${instance}`;
-var skipComment = (html, pos) => {
-	if (!html.startsWith(COMMENT_START, pos)) return pos;
-	const endPos = html.indexOf(COMMENT_END, pos + 4);
-	return endPos === -1 ? html.length : endPos + 3;
-};
-var skipCDATA = (html, pos) => {
-	if (!html.startsWith(CDATA_START, pos)) return pos;
-	const endPos = html.indexOf(CDATA_END, pos + 9);
-	return endPos === -1 ? html.length : endPos + 3;
-};
-var parseClosingTag = (html, pos) => {
-	if (html[pos + 1] !== "/") return null;
-	let scanPos = pos + 2;
-	let tagName = "";
-	while (scanPos < html.length && WHITESPACE_REGEX.test(html[scanPos])) scanPos++;
-	while (scanPos < html.length && TAG_NAME_CHAR_REGEX.test(html[scanPos])) {
-		tagName += html[scanPos];
-		scanPos++;
-	}
-	while (scanPos < html.length && WHITESPACE_REGEX.test(html[scanPos])) scanPos++;
-	if (!tagName || html[scanPos] !== ">") return null;
-	return {
-		tagName: tagName.toLowerCase(),
-		endPos: scanPos + 1
-	};
-};
-var parseOpeningTag = (html, pos) => {
-	let scanPos = pos + 1;
-	let tagName = "";
-	while (scanPos < html.length && TAG_NAME_CHAR_REGEX.test(html[scanPos])) {
-		tagName += html[scanPos];
-		scanPos++;
-	}
-	if (!tagName) return null;
-	let foundEnd = false;
-	let isSelfClosing = false;
-	while (scanPos < html.length) {
-		if (html[scanPos] === ">") {
-			foundEnd = true;
-			isSelfClosing = html[scanPos - 1] === "/";
-			break;
-		}
-		if (html[scanPos] === "\"" || html[scanPos] === "'") {
-			const quoteChar = html[scanPos];
-			scanPos++;
-			while (scanPos < html.length) {
-				if (html[scanPos] === "\\" && scanPos + 1 < html.length) {
-					scanPos += 2;
-					continue;
-				}
-				if (html[scanPos] === quoteChar) {
-					scanPos++;
-					break;
-				}
-				scanPos++;
-			}
-			continue;
-		}
-		scanPos++;
-	}
-	return {
-		tagName: tagName.toLowerCase(),
-		endPos: foundEnd ? scanPos + 1 : html.length,
-		foundEnd,
-		isSelfClosing
-	};
-};
-function detectUnclosedComponentTags(html, componentNames) {
-	const trackedTags = new Set(Array.from(componentNames, (tagName) => tagName.toLowerCase()));
-	if (trackedTags.size === 0 || html.length === 0) return /* @__PURE__ */ new Set();
-	const unclosedTags = /* @__PURE__ */ new Set();
-	const tagCounts = {};
-	const openTagIndexes = {};
-	let pos = 0;
-	while (pos < html.length) {
-		const afterComment = skipComment(html, pos);
-		if (afterComment !== pos) {
-			pos = afterComment;
-			continue;
-		}
-		const afterCDATA = skipCDATA(html, pos);
-		if (afterCDATA !== pos) {
-			pos = afterCDATA;
-			continue;
-		}
-		if (html[pos] !== "<") {
-			pos++;
-			continue;
-		}
-		const closingTag = parseClosingTag(html, pos);
-		if (closingTag) {
-			const pendingIndexes = openTagIndexes[closingTag.tagName];
-			if (trackedTags.has(closingTag.tagName) && pendingIndexes?.length) pendingIndexes.pop();
-			pos = closingTag.endPos;
-			continue;
-		}
-		const openingTag = parseOpeningTag(html, pos);
-		if (!openingTag || !trackedTags.has(openingTag.tagName)) {
-			pos++;
-			continue;
-		}
-		tagCounts[openingTag.tagName] = (tagCounts[openingTag.tagName] ?? 0) + 1;
-		const instance = tagCounts[openingTag.tagName];
-		if (!openingTag.foundEnd) unclosedTags.add(getTagInstanceId(openingTag.tagName, instance));
-		else if (!openingTag.isSelfClosing && !VOID_ELEMENTS.has(openingTag.tagName)) {
-			openTagIndexes[openingTag.tagName] ??= [];
-			openTagIndexes[openingTag.tagName].push(instance);
-		}
-		pos = openingTag.endPos;
-	}
-	for (const [tagName, pendingIndexes] of Object.entries(openTagIndexes)) pendingIndexes.forEach((instance) => {
-		unclosedTags.add(getTagInstanceId(tagName, instance));
-	});
-	return unclosedTags;
-}
-//#endregion
-//#region src/XMarkdown/core/VueRenderer.ts
-var DEFAULT_ANIMATION_DURATION = 200;
-var NON_WHITESPACE_REGEX = /[^\r\n\s]+/;
-var MATHML_TAGS = [
-	"math",
-	"maction",
-	"maligngroup",
-	"malignmark",
-	"menclose",
-	"merror",
-	"mfenced",
-	"mfrac",
-	"mglyph",
-	"mi",
-	"mlabeledtr",
-	"mlongdiv",
-	"mmultiscripts",
-	"mn",
-	"mo",
-	"mover",
-	"mpadded",
-	"mphantom",
-	"mprescripts",
-	"mroot",
-	"mrow",
-	"ms",
-	"mscarries",
-	"mscarry",
-	"msgroup",
-	"msline",
-	"mspace",
-	"msqrt",
-	"msrow",
-	"mstack",
-	"mstyle",
-	"msub",
-	"msup",
-	"msubsup",
-	"mtable",
-	"mtd",
-	"mtext",
-	"mtr",
-	"munder",
-	"munderover",
-	"semantics",
-	"annotation",
-	"annotation-xml"
-];
-var VueRenderer = class {
-	options;
-	constructor(options = {}) {
-		this.options = {
-			components: options.components ?? {},
-			enableAnimation: options.enableAnimation ?? true,
-			animationConfig: {
-				fadeDuration: options.animationConfig?.fadeDuration ?? DEFAULT_ANIMATION_DURATION,
-				easing: options.animationConfig?.easing ?? "ease-in-out"
-			}
-		};
-	}
-	render(html) {
-		const unclosedTags = detectUnclosedComponentTags(html, Object.keys(this.options.components));
-		const sanitized = this.sanitize(html);
-		const nodes = this.parseToVNodes(sanitized, unclosedTags);
-		if (nodes.length === 0) return h("span", "");
-		if (nodes.length === 1) return nodes[0];
-		return h(Fragment, nodes);
-	}
-	sanitize(html) {
-		const allowedTags = [...new Set([
-			...Object.keys(this.options.components),
-			"p",
-			"br",
-			"span",
-			"div",
-			"a",
-			"img",
-			"ul",
-			"ol",
-			"li",
-			"h1",
-			"h2",
-			"h3",
-			"h4",
-			"h5",
-			"h6",
-			"blockquote",
-			"pre",
-			"code",
-			"em",
-			"strong",
-			"del",
-			"ins",
-			"table",
-			"thead",
-			"tbody",
-			"tr",
-			"th",
-			"td",
-			"hr",
-			"xmd-tail",
-			...MATHML_TAGS
-		])];
-		return DOMPurify.sanitize(html, {
-			ALLOWED_TAGS: allowedTags,
-			ALLOWED_ATTR: [
-				"class",
-				"style",
-				"aria-hidden",
-				"aria-label",
-				"role",
-				"xmlns",
-				"encoding",
-				"href",
-				"src",
-				"title",
-				"alt",
-				"target",
-				"rel",
-				"data-lang",
-				"data-block",
-				"data-state",
-				"data-raw",
-				"data-icon",
-				"data-description",
-				"icon",
-				"description"
-			]
-		});
-	}
-	parseToVNodes(html, unclosedTags) {
-		const template = `<div>${html}</div>`;
-		const container = document.createElement("div");
-		container.innerHTML = template;
-		const cidRef = { tagIndexes: {} };
-		const nodes = [];
-		Array.from(container.childNodes).forEach((node) => {
-			const vnode = this.convertNode(node, unclosedTags, cidRef);
-			if (vnode) nodes.push(vnode);
-		});
-		return nodes;
-	}
-	convertNode(domNode, unclosedTags, cidRef) {
-		if (domNode.nodeType === Node.TEXT_NODE) {
-			const text = domNode.textContent || "";
-			const parentTagName = domNode.parentNode instanceof Element ? domNode.parentNode.tagName.toLowerCase() : "";
-			const isParentCustomComponent = Boolean(parentTagName && this.options.components[parentTagName]);
-			if (this.options.enableAnimation && NON_WHITESPACE_REGEX.test(text) && !isParentCustomComponent) return this.wrapWithAnimation(text);
-			return createTextVNode(text);
-		}
-		if (domNode.nodeType !== Node.ELEMENT_NODE) return null;
-		const element = domNode;
-		const tagName = element.tagName.toLowerCase();
-		const customComponent = this.options.components[tagName];
-		if (customComponent) {
-			const componentProps = this.extractComponentProps(element, tagName, unclosedTags, cidRef);
-			const children = [];
-			Array.from(element.childNodes).forEach((child) => {
-				const childVNode = this.convertNode(child, unclosedTags, cidRef);
-				if (childVNode) children.push(childVNode);
-			});
-			if (children.length === 0) return h(customComponent, componentProps);
-			return h(customComponent, componentProps, { default: () => children });
-		}
-		if (tagName === "xmd-tail") return h("span", { class: "xmd-tail" }, "▋");
-		return this.convertNativeElement(element, tagName, unclosedTags, cidRef);
-	}
-	convertNativeElement(element, tagName, unclosedTags, cidRef) {
-		const children = [];
-		const props = {};
-		Array.from(element.attributes).forEach((attr) => {
-			props[attr.name] = attr.value;
-		});
-		Array.from(element.childNodes).forEach((child) => {
-			const childVNode = this.convertNode(child, unclosedTags, cidRef);
-			if (childVNode) children.push(childVNode);
-		});
-		return h(tagName, props, children);
-	}
-	extractComponentProps(element, tagName, unclosedTags, cidRef) {
-		const props = {};
-		cidRef.tagIndexes[tagName] = (cidRef.tagIndexes[tagName] ?? 0) + 1;
-		const instanceId = getTagInstanceId(tagName, cidRef.tagIndexes[tagName]);
-		props.streamStatus = unclosedTags.has(instanceId) ? "loading" : "done";
-		Array.from(element.attributes).forEach((attr) => {
-			props[attr.name] = attr.value;
-		});
-		if (tagName === "code") {
-			props.block = element.getAttribute("data-block") === "true";
-			props.streamStatus = element.getAttribute("data-state") === "loading" ? "loading" : "done";
-			const langFromData = element.getAttribute("data-lang") || "";
-			const className = element.getAttribute("class") || "";
-			const langFromClass = className.match(/(?:^|\s)language-([^\s]+)/)?.[1] ?? className.match(/(?:^|\s)lang-([^\s]+)/)?.[1] ?? "";
-			const lang = langFromData || langFromClass;
-			if (lang) props.lang = lang;
-		}
-		return props;
-	}
-	wrapWithAnimation(text) {
-		return h(AnimationText_default, {
-			text,
-			fadeDuration: this.options.animationConfig.fadeDuration,
-			easing: this.options.animationConfig.easing
-		});
-	}
-	setOptions(options) {
-		if (options.components) this.options.components = {
-			...this.options.components,
-			...options.components
-		};
-		if (options.enableAnimation !== void 0) this.options.enableAnimation = options.enableAnimation;
-		if (options.animationConfig) this.options.animationConfig = {
-			...this.options.animationConfig,
-			...options.animationConfig
-		};
-	}
-};
-//#endregion
-//#region src/XMarkdown/index.vue
-var XMarkdown_default = /* @__PURE__ */ defineComponent({
-	__name: "index",
-	props: {
-		content: { default: "" },
-		components: { default: () => ({}) },
-		streaming: { default: void 0 },
-		config: { default: () => ({ gfm: true }) },
-		debug: {
-			type: Boolean,
-			default: false
-		},
-		protectCustomTagNewlines: {
-			type: Boolean,
-			default: true
-		},
-		escapeRawHtml: {
-			type: Boolean,
-			default: false
-		},
-		className: {},
-		style: {},
-		openLinksInNewTab: {
-			type: Boolean,
-			default: true
-		},
-		paragraphTag: { default: "p" }
-	},
-	setup(__props) {
-		const props = __props;
-		const contentRef = computed(() => props.content || "");
-		const streamingRef = computed(() => props.streaming);
-		const { processedContent } = useStreaming(contentRef, streamingRef, computed(() => props.components));
-		const { tailContent, tailComponent, showTail } = useTail(streamingRef);
-		const mergedComponents = computed(() => {
-			const baseComponents = { ...props.components };
-			if (!showTail.value || !tailContent.value) return baseComponents;
-			const resolvedTailComponent = tailComponent.value || TailIndicator_default;
-			const content = tailContent.value;
-			const TailBridge = defineComponent({
-				name: "XmdTailBridge",
-				setup() {
-					return () => h(resolvedTailComponent, { content });
-				}
-			});
-			return {
-				...baseComponents,
-				"xmd-tail": TailBridge
-			};
-		});
-		const VNodeRenderer = defineComponent({
-			name: "XmdVNodeRenderer",
-			props: { node: {
-				type: Object,
-				required: true
-			} },
-			setup(props) {
-				return () => props.node;
-			}
-		});
-		const parser = shallowRef(new Parser({
-			openLinksInNewTab: props.openLinksInNewTab,
-			paragraphTag: props.paragraphTag,
-			protectCustomTags: props.protectCustomTagNewlines,
-			escapeRawHtml: props.escapeRawHtml,
-			config: props.config,
-			components: props.components
-		}));
-		const renderer = shallowRef(new VueRenderer({
-			components: mergedComponents.value,
-			enableAnimation: props.streaming?.enableAnimation ?? true,
-			animationConfig: props.streaming?.animationConfig
-		}));
-		const optionsVersion = ref(0);
-		const bumpOptionsVersion = () => {
-			optionsVersion.value += 1;
-		};
-		const htmlOutput = computed(() => {
-			optionsVersion.value;
-			return parser.value.parse(processedContent.value, { injectTail: showTail.value });
-		});
-		const vNode = computed(() => {
-			optionsVersion.value;
-			return renderer.value.render(htmlOutput.value);
-		});
-		watch(() => [
-			props.openLinksInNewTab,
-			props.paragraphTag,
-			props.protectCustomTagNewlines,
-			props.escapeRawHtml
-		], () => {
-			parser.value.setOptions({
-				openLinksInNewTab: props.openLinksInNewTab,
-				paragraphTag: props.paragraphTag,
-				protectCustomTags: props.protectCustomTagNewlines,
-				escapeRawHtml: props.escapeRawHtml
-			});
-			bumpOptionsVersion();
-		});
-		watch(() => props.config, (newConfig) => {
-			parser.value.setOptions({ config: newConfig });
-			bumpOptionsVersion();
-		}, { deep: true });
-		watch(() => props.components, (newComponents) => {
-			parser.value.setOptions({ components: newComponents });
-			bumpOptionsVersion();
-		}, { deep: true });
-		watch(mergedComponents, (newComponents) => {
-			renderer.value.setOptions({ components: newComponents });
-			bumpOptionsVersion();
-		}, { deep: true });
-		watch(() => props.streaming, (newStreaming) => {
-			renderer.value.setOptions({
-				enableAnimation: newStreaming?.enableAnimation ?? true,
-				animationConfig: newStreaming?.animationConfig
-			});
-			bumpOptionsVersion();
-		}, { deep: true });
-		return (_ctx, _cache) => {
-			return openBlock(), createElementBlock("div", {
-				class: normalizeClass(["x-markdown", __props.className]),
-				style: normalizeStyle(__props.style)
-			}, [createVNode(unref(VNodeRenderer), { node: vNode.value }, null, 8, ["node"]), __props.debug ? (openBlock(), createBlock(DebugPanel_default, { key: 0 })) : createCommentVNode("", true)], 6);
-		};
-	}
-});
-//#endregion
-//#region src/XMarkdown/composables/useParser.ts
-function useParser(initialOptions) {
-	const parser = shallowRef(null);
-	function createParser(options) {
-		return new Parser(options);
-	}
-	function parse(markdown, options) {
-		if (!parser.value) parser.value = createParser(options || initialOptions);
-		if (options) parser.value.setOptions(options);
-		return parser.value.parse(markdown);
-	}
-	function resetParser(options) {
-		parser.value = createParser(options);
-	}
-	return {
-		parser,
-		parse,
-		resetParser
-	};
-}
-//#endregion
-//#region src/XMarkdown/composables/useRenderer.ts
-function useRenderer(initialOptions) {
-	const renderer = shallowRef(null);
-	function createRenderer(options) {
-		return new VueRenderer(options);
-	}
-	function render(html, options) {
-		if (!renderer.value) renderer.value = createRenderer(options || initialOptions);
-		if (options) renderer.value.setOptions(options);
-		return renderer.value.render(html);
-	}
-	function resetRenderer(options) {
-		renderer.value = createRenderer(options);
-	}
-	return {
-		renderer,
-		render,
-		resetRenderer
-	};
-}
-//#endregion
-//#region src/XMarkdown/utils/tail.ts
-var DEFAULT_TAIL_CONTENT = "▋";
-function resolveTailContent(tail) {
-	if (!tail) return null;
-	if (tail === true) return DEFAULT_TAIL_CONTENT;
-	return tail.content || DEFAULT_TAIL_CONTENT;
-}
-//#endregion
+import AnimationText_default from "./XMarkdown/components/AnimationText.js";
+import DebugPanel_default from "./XMarkdown/components/DebugPanel.js";
+import TailIndicator_default from "./XMarkdown/components/TailIndicator.js";
+import { useStreaming } from "./XMarkdown/composables/useStreaming.js";
+import { Parser } from "./XMarkdown/core/Parser.js";
+import { useParser } from "./XMarkdown/composables/useParser.js";
+import { detectUnclosedComponentTags } from "./XMarkdown/core/detectUnclosedComponentTags.js";
+import { VueRenderer } from "./XMarkdown/core/VueRenderer.js";
+import { useRenderer } from "./XMarkdown/composables/useRenderer.js";
+import { useTail } from "./XMarkdown/composables/useTail.js";
+import XMarkdown_default from "./XMarkdown/index2.js";
+import { resolveTailContent } from "./XMarkdown/utils/tail.js";
 export { AnimationText_default as AnimationText, DebugPanel_default as DebugPanel, Parser, TailIndicator_default as TailIndicator, VueRenderer, XMarkdown_default as XMarkdown, detectUnclosedComponentTags, resolveTailContent, useParser, useRenderer, useStreaming, useTail };