@antdv-next/x-markdown 0.1.4 → 0.3.0

package/dist/XMarkdown/core/detectUnclosedComponentTags.js

@@ -36,7 +36,6 @@ 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++;
@@ -56,6 +55,7 @@ var parseOpeningTag = (html, pos) => {
 		scanPos++;
 	}
 	if (!tagName) return null;
+	if (scanPos < html.length && html[scanPos] !== ">" && html[scanPos] !== "/" && !WHITESPACE_REGEX.test(html[scanPos])) return null;
 	let foundEnd = false;
 	let isSelfClosing = false;
 	while (scanPos < html.length) {
@@ -68,10 +68,6 @@ var parseOpeningTag = (html, pos) => {
 			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;
@@ -137,5 +133,243 @@ function detectUnclosedComponentTags(html, componentNames) {
 	});
 	return unclosedTags;
 }
+/**
+* Line-level fenced-code tracking with the same rules as feedFenceState in
+* useStreaming: a fence is a run of >= 3 backticks or tildes indented by up
+* to three spaces, and a closing run needs the same character, at least the
+* opening run's length and a whitespace-only tail. Tags inside fenced code
+* are code, not HTML — without this, a JSX snippet or `#include <vector>`
+* would look like an open container and veto every later split.
+*/
+var classifyRawScanLine = (line, fence) => {
+	let pos = 0;
+	let indent = 0;
+	while (indent < 3 && line[pos] === " ") {
+		indent += 1;
+		pos += 1;
+	}
+	const marker = line[pos];
+	let runLen = 0;
+	if (marker === "`" || marker === "~") while (line[pos + runLen] === marker) runLen += 1;
+	if (runLen < 3) return;
+	if (!fence.inFence) {
+		if (marker === "`" && line.slice(pos + runLen).includes("`")) return;
+		fence.inFence = true;
+		fence.fenceChar = marker;
+		fence.fenceLen = runLen;
+		return;
+	}
+	if (marker === fence.fenceChar && runLen >= fence.fenceLen && line.slice(pos + runLen).trim() === "") {
+		fence.inFence = false;
+		fence.fenceChar = "";
+		fence.fenceLen = 0;
+	}
+};
+/**
+* Tag names whose line-leading `<name` (or, for the type-6 names, `</name`)
+* starts an HTML block that *interrupts a paragraph*: CommonMark's type-6 list.
+* Derived by asking marked rather than from memory — `span`, `em`, `a`, `svg`,
+* `math` and the other inline names are deliberately absent, because a line
+* starting with one of those is paragraph text that a code span may cross.
+*/
+var PARAGRAPH_INTERRUPTING_TAGS = new Set("address article aside base basefont blockquote body caption center col colgroup dd details dialog dir div dl dt fieldset figcaption figure footer form frame frameset h1 h2 h3 h4 h5 h6 head header hr html iframe legend li link main menu menuitem nav noframes ol optgroup option p param search section summary table tbody td tfoot th thead title tr track ul".split(" "));
+/** Type-1 tags interrupt as openers only; their closing tags start nothing. */
+var BLOCK_OPENER_TAGS = /* @__PURE__ */ new Set([
+	"pre",
+	"script",
+	"style",
+	"textarea"
+]);
+/**
+* Whether a `<` at `pos` begins an HTML block that interrupts the paragraph a
+* code span lives in — in which case the span cannot cross it and the tag must
+* be left visible to the tag scan.
+*/
+var startsParagraphInterruptingBlock = (text, pos) => {
+	let cursor = pos + 1;
+	const closing = text[cursor] === "/";
+	if (closing) cursor += 1;
+	let tagName = "";
+	while (cursor < text.length && TAG_NAME_CHAR_REGEX.test(text[cursor])) {
+		tagName += text[cursor];
+		cursor += 1;
+	}
+	tagName = tagName.toLowerCase();
+	if (BLOCK_OPENER_TAGS.has(tagName)) return !closing;
+	return PARAGRAPH_INTERRUPTING_TAGS.has(tagName);
+};
+/**
+* Index of the next run of exactly `len` backticks before the paragraph ends,
+* or -1 when there is none. CommonMark: a code span ends at the next run of
+* the *same* length, may contain line endings, and does not cross a blank
+* line; a run with no such closer is literal text, not a span.
+*
+* The lookahead also stops where the paragraph does: a blank line, or a line
+* that starts an HTML block (`<div>`, `</pre>`, …) — the paragraph cannot
+* continue past either, so a tag on that line is real HTML and must not be
+* swallowed by a pairing.
+*/
+var findClosingBacktickRun = (text, from, len) => {
+	let pos = from;
+	while (pos < text.length) {
+		const char = text[pos];
+		if (char === "\n") {
+			let ahead = pos + 1;
+			while (text[ahead] === " " || text[ahead] === "	") ahead += 1;
+			if (text[ahead] === "\n" || ahead >= text.length) return -1;
+			if (text[ahead] === "<" && startsParagraphInterruptingBlock(text, ahead)) return -1;
+			pos += 1;
+			continue;
+		}
+		if (char !== "`") {
+			pos += 1;
+			continue;
+		}
+		let run = 1;
+		while (text[pos + run] === "`") run += 1;
+		if (run === len) return pos;
+		pos += run;
+	}
+	return -1;
+};
+/**
+* Columns of whitespace between the start of `pos`'s line and `pos`, or -1 when
+* a non-whitespace character precedes it on the line. A tab advances to the
+* next multiple of four, the way CommonMark counts indentation.
+*/
+var lineIndentColumns = (text, pos) => {
+	let lineStart = pos;
+	while (lineStart > 0 && text[lineStart - 1] !== "\n") lineStart -= 1;
+	let columns = 0;
+	for (let i = lineStart; i < pos; i++) if (text[i] === " ") columns += 1;
+	else if (text[i] === "	") columns += 4 - columns % 4;
+	else return -1;
+	return columns;
+};
+/**
+* End offset of the indented code block whose first line starts at `pos` (a
+* line indented four columns): the start of the first following line that is
+* neither blank nor indented four columns, or the end of the text. Blank lines
+* do not end the block.
+*/
+var skipIndentedCodeBlock = (text, pos) => {
+	let cursor = pos;
+	for (;;) {
+		const newline = text.indexOf("\n", cursor);
+		cursor = newline === -1 ? text.length : newline + 1;
+		if (cursor >= text.length) return cursor;
+		let probe = cursor;
+		let columns = 0;
+		while (probe < text.length && (text[probe] === " " || text[probe] === "	")) {
+			columns += text[probe] === "	" ? 4 - columns % 4 : 1;
+			probe += 1;
+		}
+		if (probe < text.length && text[probe] !== "\n" && columns < 4) return cursor;
+	}
+};
+/**
+* Scan one run of non-fence lines for raw HTML tags, maintaining the stack of
+* open containers across runs. Returns true when the range ends inside an
+* unterminated tag or comment (the browser would swallow whatever follows,
+* so a split there is never safe).
+*/
+var scanRawTagRange = (text, openStack) => {
+	let pos = 0;
+	while (pos < text.length) {
+		const char = text[pos];
+		if (char === "`" || char === "~") {
+			let runLen = 1;
+			while (text[pos + runLen] === char) runLen += 1;
+			if ((runLen >= 3 ? lineIndentColumns(text, pos) : -1) >= 4) {
+				pos = skipIndentedCodeBlock(text, pos);
+				continue;
+			}
+			if (char === "~") {
+				pos += runLen;
+				continue;
+			}
+			const close = findClosingBacktickRun(text, pos + runLen, runLen);
+			pos = close === -1 ? pos + runLen : close + runLen;
+			continue;
+		}
+		if (char !== "<") {
+			pos += 1;
+			continue;
+		}
+		if (text.startsWith(COMMENT_START, pos)) {
+			const end = text.indexOf(COMMENT_END, pos + 4);
+			if (end === -1) return true;
+			pos = end + 3;
+			continue;
+		}
+		if (text.startsWith(CDATA_START, pos)) {
+			const end = text.indexOf(CDATA_END, pos + 9);
+			if (end === -1) return true;
+			pos = end + 3;
+			continue;
+		}
+		const closingTag = parseClosingTag(text, pos);
+		if (closingTag) {
+			for (let i = openStack.length - 1; i >= 0; i--) if (openStack[i] === closingTag.tagName) {
+				openStack.length = i;
+				break;
+			}
+			pos = closingTag.endPos;
+			continue;
+		}
+		const openingTag = parseOpeningTag(text, pos);
+		if (openingTag) {
+			if (!openingTag.foundEnd) return true;
+			if (/[A-Z]/.test(text[pos + 1] ?? "") || !VOID_ELEMENTS.has(openingTag.tagName)) openStack.push(openingTag.tagName);
+			pos = openingTag.endPos;
+			continue;
+		}
+		pos += 1;
+	}
+	return false;
+};
+/**
+* Whether `text` (a section's worth of Markdown source) leaves a raw HTML
+* container open. CommonMark ends an HTML block at a blank line, but the
+* browser keeps nesting into an unclosed `<div>`/`<details>`/`<table>`/…
+* until its closing tag — so a section split placed before the next heading
+* would auto-close the container at the section end and produce a different
+* DOM from the whole-document render. An open `<p>` is the one exception:
+* the HTML parser closes it when a heading starts, so both parses nest the
+* heading identically. (Downstream-only guard; upstream ant-design/x#2061
+* only checks registered custom component tags here.)
+*/
+function hasUnclosedRawTags(text) {
+	const openStack = [];
+	const fence = {
+		inFence: false,
+		fenceChar: "",
+		fenceLen: 0
+	};
+	let rangeStart = 0;
+	let rangeOpen = false;
+	const flushRange = (end) => {
+		if (!rangeOpen) return false;
+		rangeOpen = false;
+		return end > rangeStart ? scanRawTagRange(text.slice(rangeStart, end), openStack) : false;
+	};
+	let lineStart = 0;
+	while (lineStart < text.length) {
+		const newline = text.indexOf("\n", lineStart);
+		const lineEnd = newline === -1 ? text.length : newline;
+		const wasInFence = fence.inFence;
+		classifyRawScanLine(text.slice(lineStart, lineEnd), fence);
+		if (fence.inFence || wasInFence) {
+			if (flushRange(lineStart)) return true;
+		} else if (!rangeOpen) {
+			rangeStart = lineStart;
+			rangeOpen = true;
+		}
+		if (newline === -1) break;
+		lineStart = newline + 1;
+	}
+	if (flushRange(text.length)) return true;
+	return openStack.some((tagName) => tagName !== "p");
+}
 //#endregion
-export { detectUnclosedComponentTags, getTagInstanceId };
+export { detectUnclosedComponentTags, getTagInstanceId, hasUnclosedRawTags };

package/dist/XMarkdown/core/index.js

@@ -1,4 +1,4 @@
-import { Parser } from "./Parser.js";
 import { detectUnclosedComponentTags } from "./detectUnclosedComponentTags.js";
+import { Parser } from "./Parser.js";
 import { VueRenderer } from "./VueRenderer.js";
 export { Parser, VueRenderer, detectUnclosedComponentTags };

package/dist/XMarkdown/index.d.ts

@@ -1,14 +1,18 @@
 export { default as XMarkdown } from './index.vue';
 export type { XMarkdownProps } from './interface';
-export type { StreamingOption } from './interface';
+export type { StreamingOption, TypewriterOption } from './interface';
+export type { AnimationConfig, TypewriterConfig } from './interface';
+export type { StreamCacheTokenType } from './interface';
 export type { MarkedConfig } from './interface';
 export type { ComponentProps } from './interface';
 export { Parser } from './core/Parser';
 export { VueRenderer } from './core/VueRenderer';
 export { detectUnclosedComponentTags } from './core/detectUnclosedComponentTags';
-export { useStreaming } from './composables/useStreaming';
+export { useStreaming, useStreamingCore } from './composables/useStreaming';
+export { useTypewriter } from './composables/useTypewriter';
 export { useParser } from './composables/useParser';
 export { useRenderer } from './composables/useRenderer';
 export { useTail } from './composables/useTail';
 export { AnimationText, DebugPanel, TailIndicator } from './components';
+export { resolveStreaming } from './utils/streaming';
 export { resolveTailContent } from './utils/tail';

package/dist/XMarkdown/index.js

@@ -1,13 +1,15 @@
 import AnimationText_default from "./components/AnimationText.js";
 import DebugPanel_default from "./components/DebugPanel2.js";
 import TailIndicator_default from "./components/TailIndicator.js";
-import { useStreaming } from "./composables/useStreaming.js";
+import { detectUnclosedComponentTags } from "./core/detectUnclosedComponentTags.js";
+import { resolveStreaming } from "./utils/streaming.js";
+import { useStreaming, useStreamingCore } from "./composables/useStreaming.js";
+import useTypewriter from "./composables/useTypewriter.js";
 import { Parser } from "./core/Parser.js";
 import { useParser } from "./composables/useParser.js";
-import { detectUnclosedComponentTags } from "./core/detectUnclosedComponentTags.js";
 import { VueRenderer } from "./core/VueRenderer.js";
 import { useRenderer } from "./composables/useRenderer.js";
 import { useTail } from "./composables/useTail.js";
 import XMarkdown_default from "./index2.js";
 import { resolveTailContent } from "./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 };
+export { AnimationText_default as AnimationText, DebugPanel_default as DebugPanel, Parser, TailIndicator_default as TailIndicator, VueRenderer, XMarkdown_default as XMarkdown, detectUnclosedComponentTags, resolveStreaming, resolveTailContent, useParser, useRenderer, useStreaming, useStreamingCore, useTail, useTypewriter };

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

@@ -2,12 +2,12 @@ import { Component } from 'vue';
 import { XMarkdownProps } from './interface';
 declare const __VLS_export: import('vue').DefineComponent<XMarkdownProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<XMarkdownProps> & Readonly<{}>, {
     content: string;
+    streaming: boolean | import('./interface').StreamingOption;
     openLinksInNewTab: boolean;
     paragraphTag: string;
     escapeRawHtml: boolean;
     config: import('./interface').MarkedConfig;
     components: Record<string, Component>;
-    streaming: import('./interface').StreamingOption;
     debug: boolean;
     protectCustomTagNewlines: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/XMarkdown/index.vue_vue_type_script_setup_true_lang.js

@@ -1,10 +1,13 @@
 import DebugPanel_default from "./components/DebugPanel2.js";
 import TailIndicator_default from "./components/TailIndicator.js";
-import { useStreaming } from "./composables/useStreaming.js";
+import { resolveStreaming } from "./utils/streaming.js";
+import { useStreamingCore } from "./composables/useStreaming.js";
+import useTypewriter from "./composables/useTypewriter.js";
 import { Parser } from "./core/Parser.js";
 import { VueRenderer } from "./core/VueRenderer.js";
 import { useTail } from "./composables/useTail.js";
-import { computed, createBlock, createCommentVNode, createElementBlock, createVNode, defineComponent, h, normalizeClass, normalizeStyle, openBlock, ref, shallowRef, unref, watch } from "vue";
+import Section_default from "./components/Section.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, defineComponent, h, normalizeClass, normalizeStyle, openBlock, ref, renderList, shallowRef, unref, watch } from "vue";
 //#region src/XMarkdown/index.vue?vue&type=script&setup=true&lang.ts
 var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
 	__name: "index",
@@ -12,7 +15,10 @@ var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComp
 		content: { default: "" },
 		components: { default: () => ({}) },
 		componentsProps: {},
-		streaming: { default: void 0 },
+		streaming: {
+			type: [Boolean, Object],
+			default: void 0
+		},
 		config: { default: () => ({ gfm: true }) },
 		debug: {
 			type: Boolean,
@@ -36,21 +42,29 @@ var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComp
 	},
 	setup(__props) {
 		const props = __props;
+		const streamingResolved = computed(() => resolveStreaming(props.streaming));
 		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 componentsRef = computed(() => props.components);
+		const pacedContent = useTypewriter(contentRef, computed(() => streamingResolved.value?.typewriter), computed(() => !!streamingResolved.value?.hasNextChunk));
+		const parser = shallowRef(new Parser({
+			openLinksInNewTab: props.openLinksInNewTab,
+			paragraphTag: props.paragraphTag,
+			protectCustomTags: props.protectCustomTagNewlines,
+			escapeRawHtml: props.escapeRawHtml,
+			config: props.config,
+			components: props.components
+		}));
+		const { output: processedContent, sections } = useStreamingCore(pacedContent, streamingResolved, componentsRef, (markdown) => parser.value.lex(markdown));
+		const { tailContent, tailComponent, showTail } = useTail(streamingResolved);
+		const TailBridge = defineComponent({
+			name: "XmdTailBridge",
+			setup() {
+				return () => h(tailComponent.value || TailIndicator_default, { content: tailContent.value });
+			}
+		});
 		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
@@ -66,19 +80,11 @@ var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComp
 				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,
 			componentsProps: props.componentsProps,
-			enableAnimation: props.streaming?.enableAnimation ?? true,
-			animationConfig: props.streaming?.animationConfig
+			enableAnimation: streamingResolved.value?.enableAnimation ?? true,
+			animationConfig: streamingResolved.value?.animationConfig
 		}));
 		const optionsVersion = ref(0);
 		const bumpOptionsVersion = () => {
@@ -86,6 +92,7 @@ var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComp
 		};
 		const htmlOutput = computed(() => {
 			optionsVersion.value;
+			if (sections.value) return "";
 			return parser.value.parse(processedContent.value, { injectTail: showTail.value });
 		});
 		const vNode = computed(() => {
@@ -122,18 +129,45 @@ var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComp
 			renderer.value.setOptions({ componentsProps: newComponentsProps });
 			bumpOptionsVersion();
 		}, { deep: true });
-		watch(() => props.streaming, (newStreaming) => {
+		watch([
+			() => streamingResolved.value?.enableAnimation,
+			() => streamingResolved.value?.animationConfig?.fadeDuration,
+			() => streamingResolved.value?.animationConfig?.easing,
+			() => streamingResolved.value?.animationConfig?.splitBy,
+			() => streamingResolved.value?.animationConfig?.delimiters?.join("\0"),
+			() => streamingResolved.value?.animationConfig?.maxSentenceChars
+		], () => {
+			const animationConfig = streamingResolved.value?.animationConfig;
 			renderer.value.setOptions({
-				enableAnimation: newStreaming?.enableAnimation ?? true,
-				animationConfig: newStreaming?.animationConfig
+				enableAnimation: streamingResolved.value?.enableAnimation ?? true,
+				animationConfig: animationConfig ? { ...animationConfig } : void 0
 			});
 			bumpOptionsVersion();
-		}, { deep: true });
+		});
 		return (_ctx, _cache) => {
-			return openBlock(), createElementBlock("div", {
+			return unref(processedContent) ? (openBlock(), createElementBlock("div", {
+				key: 0,
 				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);
+			}, [unref(sections) ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(unref(sections), (section, index) => {
+				return openBlock(), createBlock(Section_default, {
+					key: index,
+					content: section,
+					parser: parser.value,
+					renderer: renderer.value,
+					"inject-tail": !!unref(showTail) && index === unref(sections).length - 1,
+					"options-version": optionsVersion.value
+				}, null, 8, [
+					"content",
+					"parser",
+					"renderer",
+					"inject-tail",
+					"options-version"
+				]);
+			}), 128)) : (openBlock(), createBlock(unref(VNodeRenderer), {
+				key: 1,
+				node: vNode.value
+			}, null, 8, ["node"])), __props.debug ? (openBlock(), createBlock(DebugPanel_default, { key: 2 })) : createCommentVNode("", true)], 6)) : createCommentVNode("", true);
 		};
 	}
 });