@hubstr/kit 0.1.5 → 0.1.6

package/ui/es/Markdown/SyntaxMarkdown/useSmoothStreamContent.mjs

@@ -0,0 +1,310 @@
+import { getNow } from "../../utils/getNow.mjs";
+import { useStreamdownProfiler } from "../streamProfiler/StreamdownProfilerProvider.mjs";
+import { findOpenFenceLanguage } from "./fenceState.mjs";
+import { useCallback, useEffect, useRef, useState } from "react";
+//#region src/Markdown/SyntaxMarkdown/useSmoothStreamContent.ts
+const DEFAULT_BYPASS_LANGUAGES = ["html"];
+const PRESET_CONFIG = {
+	balanced: {
+		activeInputWindowMs: 220,
+		bypassFencedLanguages: DEFAULT_BYPASS_LANGUAGES,
+		defaultCps: 38,
+		emaAlpha: .2,
+		flushCps: 120,
+		largeAppendChars: 120,
+		maxActiveCps: 132,
+		maxCps: 72,
+		maxFlushCps: 280,
+		minCommitIntervalMs: 48,
+		minCps: 18,
+		settleAfterMs: 360,
+		settleDrainMaxMs: 520,
+		settleDrainMinMs: 180,
+		targetBufferMs: 120
+	},
+	realtime: {
+		activeInputWindowMs: 140,
+		bypassFencedLanguages: DEFAULT_BYPASS_LANGUAGES,
+		defaultCps: 50,
+		emaAlpha: .3,
+		flushCps: 170,
+		largeAppendChars: 180,
+		maxActiveCps: 180,
+		maxCps: 96,
+		maxFlushCps: 360,
+		minCommitIntervalMs: 32,
+		minCps: 24,
+		settleAfterMs: 260,
+		settleDrainMaxMs: 360,
+		settleDrainMinMs: 140,
+		targetBufferMs: 40
+	},
+	silky: {
+		activeInputWindowMs: 320,
+		bypassFencedLanguages: DEFAULT_BYPASS_LANGUAGES,
+		defaultCps: 28,
+		emaAlpha: .14,
+		flushCps: 96,
+		largeAppendChars: 100,
+		maxActiveCps: 102,
+		maxCps: 56,
+		maxFlushCps: 220,
+		minCommitIntervalMs: 56,
+		minCps: 14,
+		settleAfterMs: 460,
+		settleDrainMaxMs: 680,
+		settleDrainMinMs: 240,
+		targetBufferMs: 170
+	}
+};
+const clamp = (value, min, max) => {
+	return Math.min(max, Math.max(min, value));
+};
+const MAX_COMMIT_INTERVAL_MS = 96;
+const COMMIT_INTERVAL_TAIL_SCALE_UNITS = 256;
+const findTailUnits = (content) => {
+	const boundary = content.lastIndexOf("\n\n");
+	return boundary === -1 ? content.length : content.length - boundary - 2;
+};
+const countChars = (text) => {
+	let count = 0;
+	for (const _char of text) count += 1;
+	return count;
+};
+const useSmoothStreamContent = (content, { enabled = true, preset = "balanced" } = {}) => {
+	const config = PRESET_CONFIG[preset];
+	const profiler = useStreamdownProfiler();
+	const [displayedContent, setDisplayedContent] = useState(content);
+	const displayedContentRef = useRef(content);
+	const displayedCountRef = useRef(countChars(content));
+	const targetContentRef = useRef(content);
+	const targetCharsRef = useRef([...content]);
+	const targetCountRef = useRef(targetCharsRef.current.length);
+	const emaCpsRef = useRef(config.defaultCps);
+	const tailUnitsRef = useRef(findTailUnits(content));
+	const lastInputTsRef = useRef(0);
+	const lastInputCountRef = useRef(targetCountRef.current);
+	const chunkSizeEmaRef = useRef(1);
+	const arrivalCpsEmaRef = useRef(config.defaultCps);
+	const rafRef = useRef(null);
+	const lastFrameTsRef = useRef(null);
+	const wakeTimerRef = useRef(null);
+	const clearWakeTimer = useCallback(() => {
+		if (wakeTimerRef.current !== null) {
+			clearTimeout(wakeTimerRef.current);
+			wakeTimerRef.current = null;
+		}
+	}, []);
+	const stopFrameLoop = useCallback(() => {
+		if (rafRef.current !== null) {
+			cancelAnimationFrame(rafRef.current);
+			rafRef.current = null;
+		}
+		lastFrameTsRef.current = null;
+	}, []);
+	const stopScheduling = useCallback(() => {
+		stopFrameLoop();
+		clearWakeTimer();
+	}, [clearWakeTimer, stopFrameLoop]);
+	const startFrameLoopRef = useRef(() => {});
+	const scheduleFrameWake = useCallback((delayMs) => {
+		clearWakeTimer();
+		wakeTimerRef.current = setTimeout(() => {
+			wakeTimerRef.current = null;
+			startFrameLoopRef.current();
+		}, Math.max(1, Math.ceil(delayMs)));
+	}, [clearWakeTimer]);
+	const syncImmediate = useCallback((nextContent) => {
+		stopScheduling();
+		const chars = [...nextContent];
+		const now = getNow();
+		targetContentRef.current = nextContent;
+		targetCharsRef.current = chars;
+		targetCountRef.current = chars.length;
+		displayedContentRef.current = nextContent;
+		displayedCountRef.current = chars.length;
+		setDisplayedContent(nextContent);
+		emaCpsRef.current = config.defaultCps;
+		chunkSizeEmaRef.current = 1;
+		arrivalCpsEmaRef.current = config.defaultCps;
+		tailUnitsRef.current = findTailUnits(nextContent);
+		lastInputTsRef.current = now;
+		lastInputCountRef.current = chars.length;
+	}, [config.defaultCps, stopScheduling]);
+	const startFrameLoop = useCallback(() => {
+		clearWakeTimer();
+		if (rafRef.current !== null) return;
+		const tick = (ts) => {
+			const targetCount = targetCountRef.current;
+			const displayedCount = displayedCountRef.current;
+			const backlog = targetCount - displayedCount;
+			if (backlog <= 0) {
+				stopFrameLoop();
+				return;
+			}
+			if (lastFrameTsRef.current === null) {
+				lastFrameTsRef.current = ts;
+				rafRef.current = requestAnimationFrame(tick);
+				return;
+			}
+			const commitIntervalMs = Math.min(MAX_COMMIT_INTERVAL_MS, config.minCommitIntervalMs * (1 + tailUnitsRef.current / COMMIT_INTERVAL_TAIL_SCALE_UNITS));
+			const frameIntervalMs = Math.max(0, ts - lastFrameTsRef.current);
+			if (frameIntervalMs < commitIntervalMs) {
+				rafRef.current = requestAnimationFrame(tick);
+				return;
+			}
+			const frameStart = getNow();
+			const dtSeconds = Math.max(.001, Math.min(frameIntervalMs / 1e3, .12));
+			lastFrameTsRef.current = ts;
+			const idleMs = frameStart - lastInputTsRef.current;
+			const inputActive = idleMs <= config.activeInputWindowMs;
+			const settling = !inputActive && idleMs >= config.settleAfterMs;
+			const baseCps = clamp(emaCpsRef.current, config.minCps, config.maxCps);
+			const baseLagChars = Math.max(1, Math.round(baseCps * config.targetBufferMs / 1e3));
+			const lagUpperBound = Math.max(baseLagChars + 2, baseLagChars * 3);
+			const targetLagChars = inputActive ? Math.round(clamp(baseLagChars + chunkSizeEmaRef.current * .35, baseLagChars, lagUpperBound)) : 0;
+			const desiredDisplayed = Math.max(0, targetCount - targetLagChars);
+			let currentCps;
+			if (inputActive) {
+				const backlogPressure = targetLagChars > 0 ? backlog / targetLagChars : 1;
+				const chunkPressure = targetLagChars > 0 ? chunkSizeEmaRef.current / targetLagChars : 1;
+				const arrivalPressure = arrivalCpsEmaRef.current / Math.max(baseCps, 1);
+				const combinedPressure = clamp(backlogPressure * .6 + chunkPressure * .25 + arrivalPressure * .15, 1, 4.5);
+				const activeCap = clamp(config.maxActiveCps + chunkSizeEmaRef.current * 6, config.maxActiveCps, config.maxFlushCps);
+				currentCps = clamp(baseCps * combinedPressure, config.minCps, activeCap);
+			} else if (settling) {
+				const drainTargetMs = clamp(backlog * 8, config.settleDrainMinMs, config.settleDrainMaxMs);
+				currentCps = clamp(backlog * 1e3 / drainTargetMs, config.flushCps, config.maxFlushCps);
+			} else currentCps = clamp(Math.max(config.flushCps, baseCps * 1.8, arrivalCpsEmaRef.current * .8), config.flushCps, config.maxFlushCps);
+			const urgentBacklog = inputActive && targetLagChars > 0 && backlog > targetLagChars * 2.2;
+			const burstyInput = inputActive && chunkSizeEmaRef.current >= targetLagChars * .9;
+			let revealChars = Math.max(inputActive ? urgentBacklog || burstyInput ? 2 : 1 : 2, Math.round(currentCps * dtSeconds));
+			if (inputActive) {
+				const shortfall = desiredDisplayed - displayedCount;
+				if (shortfall <= 0) {
+					stopFrameLoop();
+					scheduleFrameWake(config.activeInputWindowMs - idleMs);
+					profiler?.recordAnimationFrame({
+						backlog,
+						durationMs: getNow() - frameStart,
+						frameIntervalMs,
+						inputActive,
+						revealChars: 0,
+						settling
+					});
+					return;
+				}
+				revealChars = Math.min(revealChars, shortfall, backlog);
+			} else revealChars = Math.min(revealChars, backlog);
+			const nextCount = displayedCount + revealChars;
+			const segment = targetCharsRef.current.slice(displayedCount, nextCount).join("");
+			if (segment) {
+				const nextDisplayed = displayedContentRef.current + segment;
+				displayedContentRef.current = nextDisplayed;
+				displayedCountRef.current = nextCount;
+				setDisplayedContent(nextDisplayed);
+			} else {
+				displayedContentRef.current = targetContentRef.current;
+				displayedCountRef.current = targetCount;
+				setDisplayedContent(targetContentRef.current);
+			}
+			profiler?.recordAnimationFrame({
+				backlog,
+				durationMs: getNow() - frameStart,
+				frameIntervalMs,
+				inputActive,
+				revealChars: segment ? revealChars : backlog,
+				settling
+			});
+			rafRef.current = requestAnimationFrame(tick);
+		};
+		rafRef.current = requestAnimationFrame(tick);
+	}, [
+		clearWakeTimer,
+		config.activeInputWindowMs,
+		config.flushCps,
+		config.maxActiveCps,
+		config.maxCps,
+		config.maxFlushCps,
+		config.minCommitIntervalMs,
+		config.minCps,
+		config.settleAfterMs,
+		config.settleDrainMaxMs,
+		config.settleDrainMinMs,
+		config.targetBufferMs,
+		scheduleFrameWake,
+		stopFrameLoop
+	]);
+	startFrameLoopRef.current = startFrameLoop;
+	useEffect(() => {
+		if (!enabled) {
+			syncImmediate(content);
+			return;
+		}
+		const prevTargetContent = targetContentRef.current;
+		if (content === prevTargetContent) return;
+		const now = getNow();
+		if (!content.startsWith(prevTargetContent)) {
+			syncImmediate(content);
+			return;
+		}
+		if (config.bypassFencedLanguages.length > 0) {
+			const openLang = findOpenFenceLanguage(content);
+			if (openLang !== null && config.bypassFencedLanguages.includes(openLang)) {
+				syncImmediate(content);
+				return;
+			}
+		}
+		const appendedChars = [...content.slice(prevTargetContent.length)];
+		const appendedCount = appendedChars.length;
+		profiler?.recordInputAppend({
+			appendedChars: appendedCount,
+			contentLength: countChars(content)
+		});
+		if (appendedCount > config.largeAppendChars) {
+			syncImmediate(content);
+			return;
+		}
+		targetContentRef.current = content;
+		targetCharsRef.current.push(...appendedChars);
+		targetCountRef.current += appendedCount;
+		tailUnitsRef.current = findTailUnits(content);
+		const deltaChars = targetCountRef.current - lastInputCountRef.current;
+		const deltaMs = Math.max(1, now - lastInputTsRef.current);
+		if (deltaChars > 0) {
+			const instantCps = deltaChars * 1e3 / deltaMs;
+			const normalizedInstantCps = clamp(instantCps, config.minCps, config.maxFlushCps * 2);
+			const chunkEmaAlpha = .35;
+			chunkSizeEmaRef.current = chunkSizeEmaRef.current * (1 - chunkEmaAlpha) + appendedCount * chunkEmaAlpha;
+			arrivalCpsEmaRef.current = arrivalCpsEmaRef.current * (1 - chunkEmaAlpha) + normalizedInstantCps * chunkEmaAlpha;
+			const clampedCps = clamp(instantCps, config.minCps, config.maxActiveCps);
+			emaCpsRef.current = emaCpsRef.current * (1 - config.emaAlpha) + clampedCps * config.emaAlpha;
+		}
+		lastInputTsRef.current = now;
+		lastInputCountRef.current = targetCountRef.current;
+		startFrameLoop();
+	}, [
+		config.bypassFencedLanguages,
+		config.emaAlpha,
+		config.largeAppendChars,
+		config.maxActiveCps,
+		config.maxCps,
+		config.maxFlushCps,
+		config.minCps,
+		content,
+		enabled,
+		startFrameLoop,
+		syncImmediate,
+		profiler
+	]);
+	useEffect(() => {
+		return () => {
+			stopScheduling();
+		};
+	}, [stopScheduling]);
+	return displayedContent;
+};
+//#endregion
+export { countChars, useSmoothStreamContent };
+
+//# sourceMappingURL=useSmoothStreamContent.mjs.map

package/ui/es/Markdown/SyntaxMarkdown/useSmoothStreamContent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSmoothStreamContent.mjs","names":["now"],"sources":["../../../src/Markdown/SyntaxMarkdown/useSmoothStreamContent.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\r\n\r\nimport { useStreamdownProfiler } from '../streamProfiler';\r\nimport { type StreamSmoothingPreset } from '../type';\r\nimport { getNow } from '../../utils/getNow';\r\n\r\nimport { findOpenFenceLanguage } from './fenceState';\r\n\r\ninterface StreamSmoothingPresetConfig {\r\n  activeInputWindowMs: number;\r\n  /**\r\n   * Code-fence languages whose contents bypass smoothing entirely. While\r\n   * the input ends inside an open fence in this set, every chunk is\r\n   * `syncImmediate`-d to the display so downstream consumers (the\r\n   * HtmlPreview iframe in particular) see partial HTML at the demo's\r\n   * actual production rate instead of waiting on the smoother's\r\n   * ~maxFlushCps budget. As soon as the fence closes — or another\r\n   * non-bypass fence opens — smoothing resumes for the rest of the\r\n   * stream. Default `['html']` covers the artifact case that motivated\r\n   * this; tune via preset if you need to bypass `mermaid`, `svg`, etc.\r\n   */\r\n  bypassFencedLanguages: readonly string[];\r\n  defaultCps: number;\r\n  emaAlpha: number;\r\n  flushCps: number;\r\n  largeAppendChars: number;\r\n  maxActiveCps: number;\r\n  maxCps: number;\r\n  maxFlushCps: number;\r\n  minCommitIntervalMs: number;\r\n  minCps: number;\r\n  settleAfterMs: number;\r\n  settleDrainMaxMs: number;\r\n  settleDrainMinMs: number;\r\n  targetBufferMs: number;\r\n}\r\n\r\nconst DEFAULT_BYPASS_LANGUAGES = ['html'] as const;\r\n\r\nconst PRESET_CONFIG: Record<StreamSmoothingPreset, StreamSmoothingPresetConfig> = {\r\n  balanced: {\r\n    activeInputWindowMs: 220,\r\n    bypassFencedLanguages: DEFAULT_BYPASS_LANGUAGES,\r\n    defaultCps: 38,\r\n    emaAlpha: 0.2,\r\n    flushCps: 120,\r\n    largeAppendChars: 120,\r\n    maxActiveCps: 132,\r\n    maxCps: 72,\r\n    maxFlushCps: 280,\r\n    minCommitIntervalMs: 48,\r\n    minCps: 18,\r\n    settleAfterMs: 360,\r\n    settleDrainMaxMs: 520,\r\n    settleDrainMinMs: 180,\r\n    targetBufferMs: 120,\r\n  },\r\n  realtime: {\r\n    activeInputWindowMs: 140,\r\n    bypassFencedLanguages: DEFAULT_BYPASS_LANGUAGES,\r\n    defaultCps: 50,\r\n    emaAlpha: 0.3,\r\n    flushCps: 170,\r\n    largeAppendChars: 180,\r\n    maxActiveCps: 180,\r\n    maxCps: 96,\r\n    maxFlushCps: 360,\r\n    minCommitIntervalMs: 32,\r\n    minCps: 24,\r\n    settleAfterMs: 260,\r\n    settleDrainMaxMs: 360,\r\n    settleDrainMinMs: 140,\r\n    targetBufferMs: 40,\r\n  },\r\n  silky: {\r\n    activeInputWindowMs: 320,\r\n    bypassFencedLanguages: DEFAULT_BYPASS_LANGUAGES,\r\n    defaultCps: 28,\r\n    emaAlpha: 0.14,\r\n    flushCps: 96,\r\n    largeAppendChars: 100,\r\n    maxActiveCps: 102,\r\n    maxCps: 56,\r\n    maxFlushCps: 220,\r\n    minCommitIntervalMs: 56,\r\n    minCps: 14,\r\n    settleAfterMs: 460,\r\n    settleDrainMaxMs: 680,\r\n    settleDrainMinMs: 240,\r\n    targetBufferMs: 170,\r\n  },\r\n};\r\n\r\nconst clamp = (value: number, min: number, max: number): number => {\r\n  return Math.min(max, Math.max(min, value));\r\n};\r\n\r\n// Every reveal commit re-parses and re-wraps the entire trailing block, so\r\n// the per-commit cost grows linearly with how far the content is from the\r\n// last block boundary. Widen the commit interval as that distance grows —\r\n// long paragraphs/code fences keep total work bounded while short blocks\r\n// stay at the preset's snappy interval. Per-char animation-delay stagger\r\n// hides the lower commit rate.\r\nconst MAX_COMMIT_INTERVAL_MS = 96;\r\nconst COMMIT_INTERVAL_TAIL_SCALE_UNITS = 256;\r\n\r\nconst findTailUnits = (content: string): number => {\r\n  const boundary = content.lastIndexOf('\\n\\n');\r\n  return boundary === -1 ? content.length : content.length - boundary - 2;\r\n};\r\n\r\nexport const countChars = (text: string): number => {\r\n  let count = 0;\r\n  for (const _char of text) count += 1;\r\n  return count;\r\n};\r\n\r\ninterface UseSmoothStreamContentOptions {\r\n  enabled?: boolean;\r\n  preset?: StreamSmoothingPreset;\r\n}\r\n\r\nexport const useSmoothStreamContent = (\r\n  content: string,\r\n  { enabled = true, preset = 'balanced' }: UseSmoothStreamContentOptions = {},\r\n): string => {\r\n  const config = PRESET_CONFIG[preset];\r\n  const profiler = useStreamdownProfiler();\r\n  const [displayedContent, setDisplayedContent] = useState(content);\r\n\r\n  const displayedContentRef = useRef(content);\r\n  const displayedCountRef = useRef(countChars(content));\r\n\r\n  const targetContentRef = useRef(content);\r\n  const targetCharsRef = useRef([...content]);\r\n  const targetCountRef = useRef(targetCharsRef.current.length);\r\n\r\n  const emaCpsRef = useRef(config.defaultCps);\r\n  const tailUnitsRef = useRef(findTailUnits(content));\r\n  const lastInputTsRef = useRef(0);\r\n  const lastInputCountRef = useRef(targetCountRef.current);\r\n  const chunkSizeEmaRef = useRef(1);\r\n  const arrivalCpsEmaRef = useRef(config.defaultCps);\r\n\r\n  const rafRef = useRef<number | null>(null);\r\n  const lastFrameTsRef = useRef<number | null>(null);\r\n  const wakeTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\r\n\r\n  const clearWakeTimer = useCallback(() => {\r\n    if (wakeTimerRef.current !== null) {\r\n      clearTimeout(wakeTimerRef.current);\r\n      wakeTimerRef.current = null;\r\n    }\r\n  }, []);\r\n\r\n  const stopFrameLoop = useCallback(() => {\r\n    if (rafRef.current !== null) {\r\n      cancelAnimationFrame(rafRef.current);\r\n      rafRef.current = null;\r\n    }\r\n    lastFrameTsRef.current = null;\r\n  }, []);\r\n\r\n  const stopScheduling = useCallback(() => {\r\n    stopFrameLoop();\r\n    clearWakeTimer();\r\n  }, [clearWakeTimer, stopFrameLoop]);\r\n\r\n  const startFrameLoopRef = useRef<() => void>(() => {});\r\n\r\n  const scheduleFrameWake = useCallback(\r\n    (delayMs: number) => {\r\n      clearWakeTimer();\r\n\r\n      wakeTimerRef.current = setTimeout(\r\n        () => {\r\n          wakeTimerRef.current = null;\r\n          startFrameLoopRef.current();\r\n        },\r\n        Math.max(1, Math.ceil(delayMs)),\r\n      );\r\n    },\r\n    [clearWakeTimer],\r\n  );\r\n\r\n  const syncImmediate = useCallback(\r\n    (nextContent: string) => {\r\n      stopScheduling();\r\n\r\n      const chars = [...nextContent];\r\n      const now = getNow();\r\n\r\n      targetContentRef.current = nextContent;\r\n      targetCharsRef.current = chars;\r\n      targetCountRef.current = chars.length;\r\n\r\n      displayedContentRef.current = nextContent;\r\n      displayedCountRef.current = chars.length;\r\n      setDisplayedContent(nextContent);\r\n\r\n      emaCpsRef.current = config.defaultCps;\r\n      chunkSizeEmaRef.current = 1;\r\n      arrivalCpsEmaRef.current = config.defaultCps;\r\n      tailUnitsRef.current = findTailUnits(nextContent);\r\n      lastInputTsRef.current = now;\r\n      lastInputCountRef.current = chars.length;\r\n    },\r\n    [config.defaultCps, stopScheduling],\r\n  );\r\n\r\n  const startFrameLoop = useCallback(() => {\r\n    clearWakeTimer();\r\n    if (rafRef.current !== null) return;\r\n\r\n    const tick = (ts: number) => {\r\n      const targetCount = targetCountRef.current;\r\n      const displayedCount = displayedCountRef.current;\r\n      const backlog = targetCount - displayedCount;\r\n\r\n      if (backlog <= 0) {\r\n        stopFrameLoop();\r\n        return;\r\n      }\r\n\r\n      if (lastFrameTsRef.current === null) {\r\n        lastFrameTsRef.current = ts;\r\n        rafRef.current = requestAnimationFrame(tick);\r\n        return;\r\n      }\r\n\r\n      // Reveal commits are throttled below the display refresh rate: each\r\n      // commit re-renders the tail block and re-runs remend + lexing, so\r\n      // committing at 60-120fps burns CPU without visible benefit — the\r\n      // per-char stagger inside a commit is carried by animation-delay.\r\n      const commitIntervalMs = Math.min(\r\n        MAX_COMMIT_INTERVAL_MS,\r\n        config.minCommitIntervalMs * (1 + tailUnitsRef.current / COMMIT_INTERVAL_TAIL_SCALE_UNITS),\r\n      );\r\n      const frameIntervalMs = Math.max(0, ts - lastFrameTsRef.current);\r\n      if (frameIntervalMs < commitIntervalMs) {\r\n        rafRef.current = requestAnimationFrame(tick);\r\n        return;\r\n      }\r\n\r\n      const frameStart = getNow();\r\n      const dtSeconds = Math.max(0.001, Math.min(frameIntervalMs / 1000, 0.12));\r\n      lastFrameTsRef.current = ts;\r\n\r\n      const now = frameStart;\r\n      const idleMs = now - lastInputTsRef.current;\r\n      const inputActive = idleMs <= config.activeInputWindowMs;\r\n      const settling = !inputActive && idleMs >= config.settleAfterMs;\r\n\r\n      const baseCps = clamp(emaCpsRef.current, config.minCps, config.maxCps);\r\n      const baseLagChars = Math.max(1, Math.round((baseCps * config.targetBufferMs) / 1000));\r\n      const lagUpperBound = Math.max(baseLagChars + 2, baseLagChars * 3);\r\n      const targetLagChars = inputActive\r\n        ? Math.round(\r\n            clamp(baseLagChars + chunkSizeEmaRef.current * 0.35, baseLagChars, lagUpperBound),\r\n          )\r\n        : 0;\r\n      const desiredDisplayed = Math.max(0, targetCount - targetLagChars);\r\n\r\n      let currentCps: number;\r\n      if (inputActive) {\r\n        const backlogPressure = targetLagChars > 0 ? backlog / targetLagChars : 1;\r\n        const chunkPressure = targetLagChars > 0 ? chunkSizeEmaRef.current / targetLagChars : 1;\r\n        const arrivalPressure = arrivalCpsEmaRef.current / Math.max(baseCps, 1);\r\n        const combinedPressure = clamp(\r\n          backlogPressure * 0.6 + chunkPressure * 0.25 + arrivalPressure * 0.15,\r\n          1,\r\n          4.5,\r\n        );\r\n        const activeCap = clamp(\r\n          config.maxActiveCps + chunkSizeEmaRef.current * 6,\r\n          config.maxActiveCps,\r\n          config.maxFlushCps,\r\n        );\r\n        currentCps = clamp(baseCps * combinedPressure, config.minCps, activeCap);\r\n      } else if (settling) {\r\n        // If upstream likely ended, cap the remaining tail duration so\r\n        // we do not keep replaying old backlog for seconds.\r\n        const drainTargetMs = clamp(backlog * 8, config.settleDrainMinMs, config.settleDrainMaxMs);\r\n        const settleCps = (backlog * 1000) / drainTargetMs;\r\n        currentCps = clamp(settleCps, config.flushCps, config.maxFlushCps);\r\n      } else {\r\n        const idleFlushCps = Math.max(\r\n          config.flushCps,\r\n          baseCps * 1.8,\r\n          arrivalCpsEmaRef.current * 0.8,\r\n        );\r\n        currentCps = clamp(idleFlushCps, config.flushCps, config.maxFlushCps);\r\n      }\r\n\r\n      const urgentBacklog = inputActive && targetLagChars > 0 && backlog > targetLagChars * 2.2;\r\n      const burstyInput = inputActive && chunkSizeEmaRef.current >= targetLagChars * 0.9;\r\n      const minRevealChars = inputActive ? (urgentBacklog || burstyInput ? 2 : 1) : 2;\r\n      let revealChars = Math.max(minRevealChars, Math.round(currentCps * dtSeconds));\r\n\r\n      if (inputActive) {\r\n        const shortfall = desiredDisplayed - displayedCount;\r\n        if (shortfall <= 0) {\r\n          stopFrameLoop();\r\n          scheduleFrameWake(config.activeInputWindowMs - idleMs);\r\n\r\n          profiler?.recordAnimationFrame({\r\n            backlog,\r\n            durationMs: getNow() - frameStart,\r\n            frameIntervalMs,\r\n            inputActive,\r\n            revealChars: 0,\r\n            settling,\r\n          });\r\n          return;\r\n        }\r\n        revealChars = Math.min(revealChars, shortfall, backlog);\r\n      } else {\r\n        revealChars = Math.min(revealChars, backlog);\r\n      }\r\n\r\n      const nextCount = displayedCount + revealChars;\r\n      const segment = targetCharsRef.current.slice(displayedCount, nextCount).join('');\r\n\r\n      if (segment) {\r\n        const nextDisplayed = displayedContentRef.current + segment;\r\n        displayedContentRef.current = nextDisplayed;\r\n        displayedCountRef.current = nextCount;\r\n        setDisplayedContent(nextDisplayed);\r\n      } else {\r\n        displayedContentRef.current = targetContentRef.current;\r\n        displayedCountRef.current = targetCount;\r\n        setDisplayedContent(targetContentRef.current);\r\n      }\r\n\r\n      profiler?.recordAnimationFrame({\r\n        backlog,\r\n        durationMs: getNow() - frameStart,\r\n        frameIntervalMs,\r\n        inputActive,\r\n        revealChars: segment ? revealChars : backlog,\r\n        settling,\r\n      });\r\n\r\n      rafRef.current = requestAnimationFrame(tick);\r\n    };\r\n\r\n    rafRef.current = requestAnimationFrame(tick);\r\n  }, [\r\n    clearWakeTimer,\r\n    config.activeInputWindowMs,\r\n    config.flushCps,\r\n    config.maxActiveCps,\r\n    config.maxCps,\r\n    config.maxFlushCps,\r\n    config.minCommitIntervalMs,\r\n    config.minCps,\r\n    config.settleAfterMs,\r\n    config.settleDrainMaxMs,\r\n    config.settleDrainMinMs,\r\n    config.targetBufferMs,\r\n    scheduleFrameWake,\r\n    stopFrameLoop,\r\n  ]);\r\n  startFrameLoopRef.current = startFrameLoop;\r\n\r\n  useEffect(() => {\r\n    if (!enabled) {\r\n      syncImmediate(content);\r\n      return;\r\n    }\r\n\r\n    const prevTargetContent = targetContentRef.current;\r\n    if (content === prevTargetContent) return;\r\n\r\n    const now = getNow();\r\n    const appendOnly = content.startsWith(prevTargetContent);\r\n\r\n    if (!appendOnly) {\r\n      syncImmediate(content);\r\n      return;\r\n    }\r\n\r\n    // Bypass smoothing entirely while the input ends inside an open\r\n    // fence whose language is opted out — see the preset config.\r\n    // Without this, a 5 KB inline `<style>` block can keep `</style>`\r\n    // (and therefore the HtmlPreview head-close trigger) trapped in the\r\n    // smoother's buffer for tens of seconds, leaving the iframe pinned\r\n    // on the loading placeholder while the artifact \"looks stuck\".\r\n    if (config.bypassFencedLanguages.length > 0) {\r\n      const openLang = findOpenFenceLanguage(content);\r\n      if (openLang !== null && config.bypassFencedLanguages.includes(openLang)) {\r\n        syncImmediate(content);\r\n        return;\r\n      }\r\n    }\r\n\r\n    const appended = content.slice(prevTargetContent.length);\r\n    const appendedChars = [...appended];\r\n    const appendedCount = appendedChars.length;\r\n\r\n    profiler?.recordInputAppend({\r\n      appendedChars: appendedCount,\r\n      contentLength: countChars(content),\r\n    });\r\n\r\n    if (appendedCount > config.largeAppendChars) {\r\n      syncImmediate(content);\r\n      return;\r\n    }\r\n\r\n    targetContentRef.current = content;\r\n    targetCharsRef.current.push(...appendedChars);\r\n    targetCountRef.current += appendedCount;\r\n\r\n    tailUnitsRef.current = findTailUnits(content);\r\n\r\n    const deltaChars = targetCountRef.current - lastInputCountRef.current;\r\n    const deltaMs = Math.max(1, now - lastInputTsRef.current);\r\n\r\n    if (deltaChars > 0) {\r\n      const instantCps = (deltaChars * 1000) / deltaMs;\r\n      const normalizedInstantCps = clamp(instantCps, config.minCps, config.maxFlushCps * 2);\r\n      const chunkEmaAlpha = 0.35;\r\n      chunkSizeEmaRef.current =\r\n        chunkSizeEmaRef.current * (1 - chunkEmaAlpha) + appendedCount * chunkEmaAlpha;\r\n      arrivalCpsEmaRef.current =\r\n        arrivalCpsEmaRef.current * (1 - chunkEmaAlpha) + normalizedInstantCps * chunkEmaAlpha;\r\n\r\n      const clampedCps = clamp(instantCps, config.minCps, config.maxActiveCps);\r\n      emaCpsRef.current = emaCpsRef.current * (1 - config.emaAlpha) + clampedCps * config.emaAlpha;\r\n    }\r\n\r\n    lastInputTsRef.current = now;\r\n    lastInputCountRef.current = targetCountRef.current;\r\n\r\n    startFrameLoop();\r\n  }, [\r\n    config.bypassFencedLanguages,\r\n    config.emaAlpha,\r\n    config.largeAppendChars,\r\n    config.maxActiveCps,\r\n    config.maxCps,\r\n    config.maxFlushCps,\r\n    config.minCps,\r\n    content,\r\n    enabled,\r\n    startFrameLoop,\r\n    syncImmediate,\r\n    profiler,\r\n  ]);\r\n\r\n  useEffect(() => {\r\n    return () => {\r\n      stopScheduling();\r\n    };\r\n  }, [stopScheduling]);\r\n\r\n  return displayedContent;\r\n};\r\n"],"mappings":"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"}

package/ui/es/Markdown/SyntaxMarkdown/useStreamQueue.mjs

@@ -0,0 +1,87 @@
+import { countChars } from "./useSmoothStreamContent.mjs";
+import { useCallback, useEffect, useRef, useState } from "react";
+//#region src/Markdown/SyntaxMarkdown/useStreamQueue.ts
+const BASE_DELAY = 18;
+const ACCELERATION_FACTOR = .3;
+const MAX_BLOCK_DURATION = 3e3;
+function computeCharDelay(queueLength, charCount) {
+	let delay = BASE_DELAY / (1 + queueLength * ACCELERATION_FACTOR);
+	delay = Math.min(delay, MAX_BLOCK_DURATION / Math.max(charCount, 1));
+	return delay;
+}
+function useStreamQueue(blocks) {
+	const [revealedCount, setRevealedCount] = useState(0);
+	const timerRef = useRef(null);
+	const prevBlocksLenRef = useRef(0);
+	const minRevealedRef = useRef(0);
+	if (blocks.length === 0 && prevBlocksLenRef.current !== 0) minRevealedRef.current = 0;
+	if (blocks.length > prevBlocksLenRef.current && prevBlocksLenRef.current > 0) {
+		const prevTail = prevBlocksLenRef.current - 1;
+		minRevealedRef.current = Math.max(minRevealedRef.current, prevTail + 1);
+	}
+	prevBlocksLenRef.current = blocks.length;
+	useEffect(() => {
+		if (blocks.length === 0) {
+			setRevealedCount(0);
+			minRevealedRef.current = 0;
+			if (timerRef.current) {
+				clearTimeout(timerRef.current);
+				timerRef.current = null;
+			}
+		}
+	}, [blocks.length]);
+	const effectiveRevealedCount = Math.max(revealedCount, minRevealedRef.current);
+	const tailIndex = blocks.length - 1;
+	const getBlockState = useCallback((index) => {
+		if (index < effectiveRevealedCount) return "revealed";
+		if (index === effectiveRevealedCount && index < tailIndex) return "animating";
+		if (index === effectiveRevealedCount && index === tailIndex) return "streaming";
+		return "queued";
+	}, [effectiveRevealedCount, tailIndex]);
+	const queueLength = Math.max(0, tailIndex - effectiveRevealedCount - 1);
+	const animatingIndex = effectiveRevealedCount < tailIndex ? effectiveRevealedCount : -1;
+	const animatingCharCount = animatingIndex >= 0 ? countChars(blocks[animatingIndex]?.content ?? "") : 0;
+	const activeIndex = animatingIndex >= 0 ? animatingIndex : animatingIndex < 0 && tailIndex >= effectiveRevealedCount ? tailIndex : -1;
+	const activeCharCount = activeIndex >= 0 ? countChars(blocks[activeIndex]?.content ?? "") : 0;
+	const frozenRef = useRef({
+		delay: BASE_DELAY,
+		index: -1
+	});
+	if (activeIndex >= 0 && activeIndex !== frozenRef.current.index) frozenRef.current = {
+		delay: computeCharDelay(queueLength, activeCharCount),
+		index: activeIndex
+	};
+	const charDelay = activeIndex >= 0 ? frozenRef.current.delay : BASE_DELAY;
+	const onAnimationDone = useCallback(() => {
+		setRevealedCount(effectiveRevealedCount + 1);
+	}, [effectiveRevealedCount]);
+	useEffect(() => {
+		if (timerRef.current) {
+			clearTimeout(timerRef.current);
+			timerRef.current = null;
+		}
+		if (animatingIndex < 0) return;
+		const totalTime = Math.max(0, (animatingCharCount - 1) * charDelay) + 180;
+		timerRef.current = setTimeout(onAnimationDone, totalTime);
+		return () => {
+			if (timerRef.current) {
+				clearTimeout(timerRef.current);
+				timerRef.current = null;
+			}
+		};
+	}, [
+		animatingIndex,
+		animatingCharCount,
+		charDelay,
+		onAnimationDone
+	]);
+	return {
+		charDelay,
+		getBlockState,
+		queueLength
+	};
+}
+//#endregion
+export { useStreamQueue };
+
+//# sourceMappingURL=useStreamQueue.mjs.map

package/ui/es/Markdown/SyntaxMarkdown/useStreamQueue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStreamQueue.mjs","names":[],"sources":["../../../src/Markdown/SyntaxMarkdown/useStreamQueue.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\r\n\r\nimport { STREAM_FADE_DURATION } from './style';\r\nimport { countChars } from './useSmoothStreamContent';\r\n\r\nexport interface BlockInfo {\r\n  content: string;\r\n  startOffset: number;\r\n}\r\n\r\nexport type BlockState = 'revealed' | 'animating' | 'streaming' | 'queued';\r\n\r\nconst BASE_DELAY = 18;\r\nconst ACCELERATION_FACTOR = 0.3;\r\nconst MAX_BLOCK_DURATION = 3000;\r\n\r\nfunction computeCharDelay(queueLength: number, charCount: number): number {\r\n  const acceleration = 1 + queueLength * ACCELERATION_FACTOR;\r\n  let delay = BASE_DELAY / acceleration;\r\n  delay = Math.min(delay, MAX_BLOCK_DURATION / Math.max(charCount, 1));\r\n  return delay;\r\n}\r\n\r\nexport interface UseStreamQueueReturn {\r\n  charDelay: number;\r\n  getBlockState: (index: number) => BlockState;\r\n  queueLength: number;\r\n}\r\n\r\nexport function useStreamQueue(blocks: BlockInfo[]): UseStreamQueueReturn {\r\n  const [revealedCount, setRevealedCount] = useState(0);\r\n  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\r\n  const prevBlocksLenRef = useRef(0);\r\n  const minRevealedRef = useRef(0);\r\n\r\n  // Synchronous auto-reveal during render.\r\n  // When blocks grow, the previous tail (streaming block) is instantly\r\n  // promoted to revealed — its chars are already visible via stream-mode\r\n  // animation. This runs during render (not in effect) so there is NO\r\n  // intermediate frame where the old streaming block enters 'animating'\r\n  // state and gets stagger plugins that would restart its animations.\r\n  if (blocks.length === 0 && prevBlocksLenRef.current !== 0) {\r\n    minRevealedRef.current = 0;\r\n  }\r\n  if (blocks.length > prevBlocksLenRef.current && prevBlocksLenRef.current > 0) {\r\n    const prevTail = prevBlocksLenRef.current - 1;\r\n    minRevealedRef.current = Math.max(minRevealedRef.current, prevTail + 1);\r\n  }\r\n  prevBlocksLenRef.current = blocks.length;\r\n\r\n  // State reset when stream restarts (blocks empty)\r\n  useEffect(() => {\r\n    if (blocks.length === 0) {\r\n      setRevealedCount(0);\r\n      minRevealedRef.current = 0;\r\n      if (timerRef.current) {\r\n        clearTimeout(timerRef.current);\r\n        timerRef.current = null;\r\n      }\r\n    }\r\n  }, [blocks.length]);\r\n\r\n  const effectiveRevealedCount = Math.max(revealedCount, minRevealedRef.current);\r\n  const tailIndex = blocks.length - 1;\r\n\r\n  const getBlockState = useCallback(\r\n    (index: number): BlockState => {\r\n      if (index < effectiveRevealedCount) return 'revealed';\r\n      if (index === effectiveRevealedCount && index < tailIndex) return 'animating';\r\n      if (index === effectiveRevealedCount && index === tailIndex) return 'streaming';\r\n      return 'queued';\r\n    },\r\n    [effectiveRevealedCount, tailIndex],\r\n  );\r\n\r\n  const queueLength = Math.max(0, tailIndex - effectiveRevealedCount - 1);\r\n\r\n  const animatingIndex = effectiveRevealedCount < tailIndex ? effectiveRevealedCount : -1;\r\n  const animatingCharCount =\r\n    animatingIndex >= 0 ? countChars(blocks[animatingIndex]?.content ?? '') : 0;\r\n\r\n  const streamingIndex = animatingIndex < 0 && tailIndex >= effectiveRevealedCount ? tailIndex : -1;\r\n  const activeIndex = animatingIndex >= 0 ? animatingIndex : streamingIndex;\r\n  const activeCharCount = activeIndex >= 0 ? countChars(blocks[activeIndex]?.content ?? '') : 0;\r\n\r\n  // Freeze charDelay when entering a new active block (animating or streaming)\r\n  const frozenRef = useRef({ delay: BASE_DELAY, index: -1 });\r\n  if (activeIndex >= 0 && activeIndex !== frozenRef.current.index) {\r\n    frozenRef.current = {\r\n      delay: computeCharDelay(queueLength, activeCharCount),\r\n      index: activeIndex,\r\n    };\r\n  }\r\n  const charDelay = activeIndex >= 0 ? frozenRef.current.delay : BASE_DELAY;\r\n\r\n  const onAnimationDone = useCallback(() => {\r\n    setRevealedCount(effectiveRevealedCount + 1);\r\n  }, [effectiveRevealedCount]);\r\n\r\n  useEffect(() => {\r\n    if (timerRef.current) {\r\n      clearTimeout(timerRef.current);\r\n      timerRef.current = null;\r\n    }\r\n\r\n    if (animatingIndex < 0) return;\r\n\r\n    const totalTime = Math.max(0, (animatingCharCount - 1) * charDelay) + STREAM_FADE_DURATION;\r\n    timerRef.current = setTimeout(onAnimationDone, totalTime);\r\n\r\n    return () => {\r\n      if (timerRef.current) {\r\n        clearTimeout(timerRef.current);\r\n        timerRef.current = null;\r\n      }\r\n    };\r\n  }, [animatingIndex, animatingCharCount, charDelay, onAnimationDone]);\r\n\r\n  return { charDelay, getBlockState, queueLength };\r\n}\r\n"],"mappings":";;;AAYA,MAAM,aAAa;AACnB,MAAM,sBAAsB;AAC5B,MAAM,qBAAqB;AAE3B,SAAS,iBAAiB,aAAqB,WAA2B;CAExE,IAAI,QAAQ,cADS,IAAI,cAAc;AAEvC,SAAQ,KAAK,IAAI,OAAO,qBAAqB,KAAK,IAAI,WAAW,EAAE,CAAC;AACpE,QAAO;;AAST,SAAgB,eAAe,QAA2C;CACxE,MAAM,CAAC,eAAe,oBAAoB,SAAS,EAAE;CACrD,MAAM,WAAW,OAA6C,KAAK;CACnE,MAAM,mBAAmB,OAAO,EAAE;CAClC,MAAM,iBAAiB,OAAO,EAAE;AAQhC,KAAI,OAAO,WAAW,KAAK,iBAAiB,YAAY,EACtD,gBAAe,UAAU;AAE3B,KAAI,OAAO,SAAS,iBAAiB,WAAW,iBAAiB,UAAU,GAAG;EAC5E,MAAM,WAAW,iBAAiB,UAAU;AAC5C,iBAAe,UAAU,KAAK,IAAI,eAAe,SAAS,WAAW,EAAE;;AAEzE,kBAAiB,UAAU,OAAO;AAGlC,iBAAgB;AACd,MAAI,OAAO,WAAW,GAAG;AACvB,oBAAiB,EAAE;AACnB,kBAAe,UAAU;AACzB,OAAI,SAAS,SAAS;AACpB,iBAAa,SAAS,QAAQ;AAC9B,aAAS,UAAU;;;IAGtB,CAAC,OAAO,OAAO,CAAC;CAEnB,MAAM,yBAAyB,KAAK,IAAI,eAAe,eAAe,QAAQ;CAC9E,MAAM,YAAY,OAAO,SAAS;CAElC,MAAM,gBAAgB,aACnB,UAA8B;AAC7B,MAAI,QAAQ,uBAAwB,QAAO;AAC3C,MAAI,UAAU,0BAA0B,QAAQ,UAAW,QAAO;AAClE,MAAI,UAAU,0BAA0B,UAAU,UAAW,QAAO;AACpE,SAAO;IAET,CAAC,wBAAwB,UAAU,CACpC;CAED,MAAM,cAAc,KAAK,IAAI,GAAG,YAAY,yBAAyB,EAAE;CAEvE,MAAM,iBAAiB,yBAAyB,YAAY,yBAAyB;CACrF,MAAM,qBACJ,kBAAkB,IAAI,WAAW,OAAO,iBAAiB,WAAW,GAAG,GAAG;CAG5E,MAAM,cAAc,kBAAkB,IAAI,iBADnB,iBAAiB,KAAK,aAAa,yBAAyB,YAAY;CAE/F,MAAM,kBAAkB,eAAe,IAAI,WAAW,OAAO,cAAc,WAAW,GAAG,GAAG;CAG5F,MAAM,YAAY,OAAO;EAAE,OAAO;EAAY,OAAO;EAAI,CAAC;AAC1D,KAAI,eAAe,KAAK,gBAAgB,UAAU,QAAQ,MACxD,WAAU,UAAU;EAClB,OAAO,iBAAiB,aAAa,gBAAgB;EACrD,OAAO;EACR;CAEH,MAAM,YAAY,eAAe,IAAI,UAAU,QAAQ,QAAQ;CAE/D,MAAM,kBAAkB,kBAAkB;AACxC,mBAAiB,yBAAyB,EAAE;IAC3C,CAAC,uBAAuB,CAAC;AAE5B,iBAAgB;AACd,MAAI,SAAS,SAAS;AACpB,gBAAa,SAAS,QAAQ;AAC9B,YAAS,UAAU;;AAGrB,MAAI,iBAAiB,EAAG;EAExB,MAAM,YAAY,KAAK,IAAI,IAAI,qBAAqB,KAAK,UAAU,GAAA;AACnE,WAAS,UAAU,WAAW,iBAAiB,UAAU;AAEzD,eAAa;AACX,OAAI,SAAS,SAAS;AACpB,iBAAa,SAAS,QAAQ;AAC9B,aAAS,UAAU;;;IAGtB;EAAC;EAAgB;EAAoB;EAAW;EAAgB,CAAC;AAEpE,QAAO;EAAE;EAAW;EAAe;EAAa"}

package/ui/es/Markdown/Typography.d.mts

@@ -0,0 +1,8 @@
+import { TypographyProps } from "./type.mjs";
+import * as _$react from "react";
+
+//#region src/Markdown/Typography.d.ts
+declare const Typography: _$react.NamedExoticComponent<TypographyProps>;
+//#endregion
+export { Typography };
+//# sourceMappingURL=Typography.d.mts.map

package/ui/es/Markdown/Typography.mjs

@@ -0,0 +1,27 @@
+"use client";
+import { styles } from "./markdown.style.mjs";
+import { memo } from "react";
+import { jsx } from "react/jsx-runtime";
+import { cx } from "antd-style";
+//#region src/Markdown/Typography.tsx
+const Typography = memo(({ ref, children, className, fontSize = 16, headerMultiple = 1, marginMultiple = 2, lineHeight = 1.8, borderRadius = 8, style, ...rest }) => {
+	return /* @__PURE__ */ jsx("article", {
+		className: cx(styles.root, className),
+		ref,
+		style: {
+			"--hubstr-markdown-border-radius": borderRadius,
+			"--hubstr-markdown-font-size": `${fontSize}px`,
+			"--hubstr-markdown-header-multiple": headerMultiple,
+			"--hubstr-markdown-line-height": lineHeight,
+			"--hubstr-markdown-margin-multiple": marginMultiple,
+			...style
+		},
+		...rest,
+		children
+	});
+});
+Typography.displayName = "Typography";
+//#endregion
+export { Typography as default };
+
+//# sourceMappingURL=Typography.mjs.map

package/ui/es/Markdown/Typography.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Typography.mjs","names":[],"sources":["../../src/Markdown/Typography.tsx"],"sourcesContent":["'use client';\r\n\r\nimport { cx } from 'antd-style';\r\nimport { memo } from 'react';\r\n\r\nimport { styles } from './markdown.style';\r\nimport type { TypographyProps } from './type';\r\n\r\nconst Typography = memo<TypographyProps>(\r\n  ({\r\n    ref,\r\n    children,\r\n    className,\r\n    fontSize = 16,\r\n    headerMultiple = 1,\r\n    marginMultiple = 2,\r\n    lineHeight = 1.8,\r\n    borderRadius = 8,\r\n    style,\r\n    ...rest\r\n  }) => {\r\n    return (\r\n      <article\r\n        className={cx(styles.root, className)}\r\n        ref={ref}\r\n        style={{\r\n          // @ts-ignore\r\n          '--hubstr-markdown-border-radius': borderRadius,\r\n          '--hubstr-markdown-font-size': `${fontSize}px`,\r\n          '--hubstr-markdown-header-multiple': headerMultiple,\r\n          '--hubstr-markdown-line-height': lineHeight,\r\n          '--hubstr-markdown-margin-multiple': marginMultiple,\r\n          ...style,\r\n        }}\r\n        {...rest}\r\n      >\r\n        {children}\r\n      </article>\r\n    );\r\n  },\r\n);\r\n\r\nTypography.displayName = 'Typography';\r\n\r\nexport default Typography;\r\n"],"mappings":";;;;;;AAQA,MAAM,aAAa,MAChB,EACC,KACA,UACA,WACA,WAAW,IACX,iBAAiB,GACjB,iBAAiB,GACjB,aAAa,KACb,eAAe,GACf,OACA,GAAG,WACC;AACJ,QACE,oBAAC,WAAD;EACE,WAAW,GAAG,OAAO,MAAM,UAAU;EAChC;EACL,OAAO;GAEL,mCAAmC;GACnC,+BAA+B,GAAG,SAAS;GAC3C,qCAAqC;GACrC,iCAAiC;GACjC,qCAAqC;GACrC,GAAG;GACJ;EACD,GAAI;EAEH;EACO,CAAA;EAGf;AAED,WAAW,cAAc"}

package/ui/es/Markdown/components/CodeBlock.mjs

@@ -0,0 +1,56 @@
+import "../../Highlighter/const.mjs";
+import { isFullHtmlDocument } from "../../HtmlPreview/const.mjs";
+import Pre, { PreHtmlPreview, PreMermaid, PreSingleLine } from "../../mdx/mdxComponents/Pre.mjs";
+import { memo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/Markdown/components/CodeBlock.tsx
+const countLines = (str) => {
+	const matches = str.match(/\n/g);
+	return matches ? matches.length : 1;
+};
+const useCode = (raw) => {
+	if (!raw) return;
+	const { children = "", className } = raw?.props || { children: "" };
+	if (!children) return;
+	const content = Array.isArray(children) ? children[0] : children;
+	const lang = className?.replace("language-", "") || "plaintext";
+	return {
+		content,
+		isSingleLine: countLines(content) <= 1 && content.length <= 32,
+		lang
+	};
+};
+const CodeBlock = memo(({ fullFeatured, enableHtmlPreview, enableMermaid, highlight, html, mermaid, children, animated, ...rest }) => {
+	const code = useCode(children);
+	if (!code) return;
+	if (enableMermaid && code.lang === "mermaid") return /* @__PURE__ */ jsx(PreMermaid, {
+		animated,
+		fullFeatured,
+		...mermaid,
+		...rest,
+		children: code.content
+	});
+	if (enableHtmlPreview && code.lang === "html" && isFullHtmlDocument(code.content)) return /* @__PURE__ */ jsx(PreHtmlPreview, {
+		animated,
+		fullFeatured,
+		...html,
+		...rest,
+		children: code.content
+	});
+	if (!highlight && code.isSingleLine) return /* @__PURE__ */ jsx(PreSingleLine, {
+		language: code.lang,
+		children: code.content
+	});
+	return /* @__PURE__ */ jsx(Pre, {
+		animated,
+		fullFeatured,
+		language: code.lang,
+		...highlight,
+		...rest,
+		children: code.content
+	});
+}, (prevProps, nextProps) => prevProps.children === nextProps.children);
+//#endregion
+export { CodeBlock };
+
+//# sourceMappingURL=CodeBlock.mjs.map

package/ui/es/Markdown/components/CodeBlock.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeBlock.mjs","names":[],"sources":["../../../src/Markdown/components/CodeBlock.tsx"],"sourcesContent":["import { memo } from 'react';\r\n\r\nimport type { HighlighterProps } from '../../Highlighter';\r\nimport { FALLBACK_LANG } from '../../Highlighter/const';\r\nimport { isFullHtmlDocument } from '../../HtmlPreview/const';\r\nimport type { HtmlPreviewProps } from '../../HtmlPreview/type';\r\nimport Pre, { PreHtmlPreview, PreMermaid, PreSingleLine } from '../../mdx/mdxComponents/Pre';\r\nimport type { MermaidProps } from '../../Mermaid';\r\n\r\nconst countLines = (str: string): number => {\r\n  const regex = /\\n/g;\r\n  const matches = str.match(regex);\r\n  return matches ? matches.length : 1;\r\n};\r\n\r\nexport const useCode = (raw: any) => {\r\n  if (!raw) return;\r\n\r\n  const { children = '', className } = raw?.props || { children: '' };\r\n\r\n  if (!children) return;\r\n\r\n  const content = Array.isArray(children) ? (children[0] as string) : children;\r\n\r\n  const lang = className?.replace('language-', '') || FALLBACK_LANG;\r\n\r\n  const isSingleLine = countLines(content) <= 1 && content.length <= 32;\r\n\r\n  return {\r\n    content,\r\n    isSingleLine,\r\n    lang,\r\n  };\r\n};\r\n\r\ninterface CodeBlockProps {\r\n  animated?: boolean;\r\n  children: any;\r\n  enableHtmlPreview?: boolean;\r\n  enableMermaid?: boolean;\r\n  fullFeatured?: boolean;\r\n  highlight?: HighlighterProps;\r\n  html?: HtmlPreviewProps;\r\n  mermaid?: MermaidProps;\r\n}\r\n\r\nexport const CodeBlock = memo<CodeBlockProps>(\r\n  ({\r\n    fullFeatured,\r\n    enableHtmlPreview,\r\n    enableMermaid,\r\n    highlight,\r\n    html,\r\n    mermaid,\r\n    children,\r\n    animated,\r\n    ...rest\r\n  }) => {\r\n    const code = useCode(children);\r\n\r\n    if (!code) return;\r\n\r\n    if (enableMermaid && code.lang === 'mermaid')\r\n      return (\r\n        <PreMermaid animated={animated} fullFeatured={fullFeatured} {...mermaid} {...rest}>\r\n          {code.content}\r\n        </PreMermaid>\r\n      );\r\n\r\n    // Auto-route to HTML preview only for full HTML documents. Fragments fall\r\n    // through to the normal highlighter — inline-rendering a `<div>` snippet\r\n    // produces a degraded experience and risks hiding the actual code from\r\n    // the reader.\r\n    if (enableHtmlPreview && code.lang === 'html' && isFullHtmlDocument(code.content))\r\n      return (\r\n        <PreHtmlPreview animated={animated} fullFeatured={fullFeatured} {...html} {...rest}>\r\n          {code.content}\r\n        </PreHtmlPreview>\r\n      );\r\n\r\n    if (!highlight && code.isSingleLine)\r\n      return <PreSingleLine language={code.lang}>{code.content}</PreSingleLine>;\r\n\r\n    return (\r\n      <Pre\r\n        animated={animated}\r\n        fullFeatured={fullFeatured}\r\n        language={code.lang}\r\n        {...highlight}\r\n        {...rest}\r\n      >\r\n        {code.content}\r\n      </Pre>\r\n    );\r\n  },\r\n  (prevProps, nextProps) => prevProps.children === nextProps.children,\r\n);\r\n"],"mappings":";;;;;;AASA,MAAM,cAAc,QAAwB;CAE1C,MAAM,UAAU,IAAI,MAAM,MAAM;AAChC,QAAO,UAAU,QAAQ,SAAS;;AAGpC,MAAa,WAAW,QAAa;AACnC,KAAI,CAAC,IAAK;CAEV,MAAM,EAAE,WAAW,IAAI,cAAc,KAAK,SAAS,EAAE,UAAU,IAAI;AAEnE,KAAI,CAAC,SAAU;CAEf,MAAM,UAAU,MAAM,QAAQ,SAAS,GAAI,SAAS,KAAgB;CAEpE,MAAM,OAAO,WAAW,QAAQ,aAAa,GAAG,IAAA;AAIhD,QAAO;EACL;EACA,cAJmB,WAAW,QAAQ,IAAI,KAAK,QAAQ,UAAU;EAKjE;EACD;;AAcH,MAAa,YAAY,MACtB,EACC,cACA,mBACA,eACA,WACA,MACA,SACA,UACA,UACA,GAAG,WACC;CACJ,MAAM,OAAO,QAAQ,SAAS;AAE9B,KAAI,CAAC,KAAM;AAEX,KAAI,iBAAiB,KAAK,SAAS,UACjC,QACE,oBAAC,YAAD;EAAsB;EAAwB;EAAc,GAAI;EAAS,GAAI;YAC1E,KAAK;EACK,CAAA;AAOjB,KAAI,qBAAqB,KAAK,SAAS,UAAU,mBAAmB,KAAK,QAAQ,CAC/E,QACE,oBAAC,gBAAD;EAA0B;EAAwB;EAAc,GAAI;EAAM,GAAI;YAC3E,KAAK;EACS,CAAA;AAGrB,KAAI,CAAC,aAAa,KAAK,aACrB,QAAO,oBAAC,eAAD;EAAe,UAAU,KAAK;YAAO,KAAK;EAAwB,CAAA;AAE3E,QACE,oBAAC,KAAD;EACY;EACI;EACd,UAAU,KAAK;EACf,GAAI;EACJ,GAAI;YAEH,KAAK;EACF,CAAA;IAGT,WAAW,cAAc,UAAU,aAAa,UAAU,SAC5D"}

package/ui/es/Markdown/components/Footnotes.mjs

@@ -0,0 +1,91 @@
+"use client";
+import A from "../../A/index.mjs";
+import FlexBasic_default from "../../Flex/FlexBasic.mjs";
+import Block from "../../Block/Block.mjs";
+import Text from "../../Text/Text.mjs";
+import SearchResultCards from "./SearchResultCards/index.mjs";
+import { createElement, memo, useMemo } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/Markdown/components/Footnotes.tsx
+const DefaultFootnotes = memo(({ dataSource }) => {
+	const items = useMemo(() => dataSource.find((child) => child?.type === "ol")?.props?.children?.map((item) => {
+		if (typeof item === "string" || item?.type !== "li") return false;
+		const data = item?.props?.children?.find((note) => note?.props?.children)?.props?.children;
+		if (!data || !Array.isArray(data)) return false;
+		return {
+			children: data[0],
+			props: data[1]?.props || {}
+		};
+	}).filter(Boolean), [dataSource]);
+	if (!Array.isArray(items)) return null;
+	return /* @__PURE__ */ jsx(FlexBasic_default, {
+		horizontal: true,
+		align: "flex-start",
+		as: "section",
+		className: "footnotes",
+		"data-footnotes": "true",
+		gap: "0.5em",
+		justify: "flex-start",
+		wrap: "wrap",
+		children: items.map(({ children, props }, index) => {
+			const { node, href, ...rest } = props;
+			return /* @__PURE__ */ createElement(href ? A : "div", {
+				...href ? {
+					href,
+					...rest
+				} : rest,
+				key: index
+			}, /* @__PURE__ */ jsxs(Block, {
+				horizontal: true,
+				align: "stretch",
+				style: {
+					overflow: "hidden",
+					position: "relative"
+				},
+				variant: "outlined",
+				children: [/* @__PURE__ */ jsx(Block, {
+					paddingInline: "0.66em",
+					style: { borderRadius: 0 },
+					variant: "filled",
+					children: /* @__PURE__ */ jsx(Text, {
+						code: true,
+						as: "span",
+						type: "secondary",
+						children: index + 1
+					})
+				}), /* @__PURE__ */ jsx(Text, {
+					as: "span",
+					style: { paddingInline: "0.66em" },
+					type: "secondary",
+					children
+				})]
+			}));
+		})
+	});
+});
+const Footnotes = memo(({ children, ...rest }) => {
+	const links = useMemo(() => {
+		try {
+			return JSON.parse(rest["data-footnote-links"] || "[]");
+		} catch (error) {
+			console.error("Failed to parse footnote links:", error);
+			return [];
+		}
+	}, [rest["data-footnote-links"]]);
+	const isError = links.length === 0;
+	if (!children) return;
+	if (isError) {
+		if (!Array.isArray(children)) return children;
+		return /* @__PURE__ */ jsx(DefaultFootnotes, { dataSource: children });
+	}
+	return /* @__PURE__ */ jsx("section", {
+		className: "footnotes",
+		"data-footnotes": "true",
+		children: /* @__PURE__ */ jsx(SearchResultCards, { dataSource: links })
+	});
+});
+Footnotes.displayName = "Footnotes";
+//#endregion
+export { Footnotes as default };
+
+//# sourceMappingURL=Footnotes.mjs.map