@antdv-next/x-markdown 0.0.2 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Antdv Next
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -45,6 +45,8 @@ pnpm add @antdv-next/x-markdown
 
 ```vue
 <script setup>
+import "@antdv-next/x-markdown/themes/index.css";
+import "@antdv-next/x-markdown/themes/light.css";
 import { XMarkdown } from "@antdv-next/x-markdown";
 
 const content = `
@@ -67,6 +69,8 @@ const content = `
 
 ```vue
 <script setup>
+import "@antdv-next/x-markdown/themes/index.css";
+import "@antdv-next/x-markdown/themes/light.css";
 import { ref } from "vue";
 import { XMarkdown } from "@antdv-next/x-markdown";
 
@@ -88,6 +92,15 @@ function onChunk(chunk) {
 </template>
 ```
 
+## Styles
+
+Breaking change: `@antdv-next/x-markdown` no longer imports styles automatically. Import the base styles manually, plus one optional theme stylesheet:
+
+```ts
+import "@antdv-next/x-markdown/themes/index.css";
+import "@antdv-next/x-markdown/themes/light.css";
+```
+
 ## API
 
 ### Props
@@ -132,10 +145,11 @@ function onChunk(chunk) {
 
 ## Themes
 
-Import theme styles and set the theme class on the root:
+Import base styles, theme styles, and set the theme class on the root:
 
 ```vue
 <script setup>
+import "@antdv-next/x-markdown/themes/index.css";
 import "@antdv-next/x-markdown/themes/light.css";
 </script>
 

package/dist/XMarkdown/components/AnimationText.js

@@ -0,0 +1,5 @@
+import AnimationText_vue_vue_type_script_setup_true_lang_default from "./AnimationText.vue_vue_type_script_setup_true_lang.js";
+//#region src/XMarkdown/components/AnimationText.vue
+var AnimationText_default = AnimationText_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { AnimationText_default as default };

package/dist/XMarkdown/components/AnimationText.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,42 @@
+import { Fragment, computed, createElementBlock, defineComponent, normalizeStyle, openBlock, ref, renderList, toDisplayString, watch } from "vue";
+//#region src/XMarkdown/components/AnimationText.vue?vue&type=script&setup=true&lang.ts
+var AnimationText_vue_vue_type_script_setup_true_lang_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
+export { AnimationText_vue_vue_type_script_setup_true_lang_default as default };

package/dist/XMarkdown/components/DebugPanel.js

@@ -0,0 +1,5 @@
+import DebugPanel_vue_vue_type_script_setup_true_lang_default from "./DebugPanel.vue_vue_type_script_setup_true_lang.js";
+//#region src/XMarkdown/components/DebugPanel.vue
+var DebugPanel_default = DebugPanel_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { DebugPanel_default as default };

package/dist/XMarkdown/components/DebugPanel.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,128 @@
+import { createElementBlock, createElementVNode, defineComponent, normalizeClass, normalizeStyle, onMounted, onUnmounted, openBlock, ref, toDisplayString } from "vue";
+//#region src/XMarkdown/components/DebugPanel.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_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, [
+				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
+export { DebugPanel_vue_vue_type_script_setup_true_lang_default as default };

package/dist/XMarkdown/components/TailIndicator.js

@@ -0,0 +1,5 @@
+import TailIndicator_vue_vue_type_script_setup_true_lang_default from "./TailIndicator.vue_vue_type_script_setup_true_lang.js";
+//#region src/XMarkdown/components/TailIndicator.vue
+var TailIndicator_default = TailIndicator_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { TailIndicator_default as default };

package/dist/XMarkdown/components/TailIndicator.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,14 @@
+import { createElementBlock, defineComponent, openBlock, toDisplayString } from "vue";
+//#region src/XMarkdown/components/TailIndicator.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "xmd-tail" };
+var TailIndicator_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "TailIndicator",
+	props: { content: { default: "▋" } },
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", _hoisted_1, toDisplayString(__props.content), 1);
+		};
+	}
+});
+//#endregion
+export { TailIndicator_vue_vue_type_script_setup_true_lang_default as default };

package/dist/XMarkdown/components/index.js

@@ -0,0 +1,4 @@
+import AnimationText_default from "./AnimationText.js";
+import DebugPanel_default from "./DebugPanel.js";
+import TailIndicator_default from "./TailIndicator.js";
+export { AnimationText_default as AnimationText, DebugPanel_default as DebugPanel, TailIndicator_default as TailIndicator };

package/dist/XMarkdown/composables/index.d.ts

@@ -0,0 +1,4 @@
+export { useStreaming } from './useStreaming';
+export { useParser } from './useParser';
+export { useRenderer } from './useRenderer';
+export { useTail } from './useTail';

package/dist/XMarkdown/composables/index.js

@@ -0,0 +1,5 @@
+import { useStreaming } from "./useStreaming.js";
+import { useParser } from "./useParser.js";
+import { useRenderer } from "./useRenderer.js";
+import { useTail } from "./useTail.js";
+export { useParser, useRenderer, useStreaming, useTail };

package/dist/XMarkdown/composables/useParser.js

@@ -0,0 +1,24 @@
+import { Parser } from "../core/Parser.js";
+import { shallowRef } from "vue";
+//#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
+export { useParser };

package/dist/XMarkdown/composables/useRenderer.js

@@ -0,0 +1,24 @@
+import { VueRenderer } from "../core/VueRenderer.js";
+import { shallowRef } from "vue";
+//#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
+export { useRenderer };

package/dist/XMarkdown/composables/useStreaming.js

@@ -0,0 +1,215 @@
+import { StreamCacheTokenType } from "../interface.js";
+import { ref, watch } from "vue";
+//#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
+export { useStreaming };

package/dist/XMarkdown/composables/useTail.js

@@ -0,0 +1,25 @@
+import { computed } from "vue";
+//#region src/XMarkdown/composables/useTail.ts
+var DEFAULT_TAIL_CONTENT = "▋";
+function useTail(streaming) {
+	const tailContent = computed(() => {
+		const tail = streaming.value?.tail;
+		if (!tail) return null;
+		if (typeof tail === "boolean") return DEFAULT_TAIL_CONTENT;
+		return tail.content || DEFAULT_TAIL_CONTENT;
+	});
+	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
+export { useTail };