@incremark/solid 0.3.3

package/dist/index.js

@@ -0,0 +1,2123 @@
+// src/composables/useIncremark.ts
+import {
+  createSignal as createSignal3,
+  createEffect as createEffect2
+} from "solid-js";
+import {
+  createIncremarkParser
+} from "@incremark/core";
+
+// src/composables/useProvideDefinations.tsx
+import { createSignal } from "solid-js";
+import { createContext } from "solid-js";
+import { jsx } from "solid-js/jsx-runtime";
+var DefinationsContext = createContext();
+function DefinationsProvider(props) {
+  return /* @__PURE__ */ jsx(DefinationsContext.Provider, { value: props.value, children: props.children });
+}
+function useProvideDefinations() {
+  const [definations, setDefinations] = createSignal({});
+  const [footnoteDefinitions, setFootnoteDefinitions] = createSignal({});
+  const [footnoteReferenceOrder, setFootnoteReferenceOrder] = createSignal([]);
+  function clearDefinations() {
+    setDefinations({});
+  }
+  function clearFootnoteDefinitions() {
+    setFootnoteDefinitions({});
+  }
+  function clearFootnoteReferenceOrder() {
+    setFootnoteReferenceOrder([]);
+  }
+  function clearAllDefinations() {
+    clearDefinations();
+    clearFootnoteDefinitions();
+    clearFootnoteReferenceOrder();
+  }
+  const contextValue = {
+    definations,
+    setDefinations,
+    footnoteDefinitions,
+    setFootnoteDefinitions,
+    footnoteReferenceOrder,
+    setFootnoteReferenceOrder,
+    clearAllDefinations
+  };
+  return {
+    definations,
+    setDefinations,
+    footnoteDefinitions,
+    setFootnoteDefinitions,
+    footnoteReferenceOrder,
+    setFootnoteReferenceOrder,
+    clearDefinations,
+    clearFootnoteDefinitions,
+    clearFootnoteReferenceOrder,
+    clearAllDefinations,
+    DefinationsProvider,
+    contextValue
+  };
+}
+
+// src/composables/useTypewriter.ts
+import {
+  createSignal as createSignal2,
+  createEffect,
+  onCleanup
+} from "solid-js";
+import { createStore, reconcile } from "solid-js/store";
+import {
+  createBlockTransformer,
+  defaultPlugins,
+  mathPlugin,
+  collectFootnoteReferences
+} from "@incremark/core";
+
+// src/utils/cursor.ts
+function addCursorToNode(node, cursor) {
+  if (node.type === "code") {
+    return node;
+  }
+  const cloned = JSON.parse(JSON.stringify(node));
+  function addToLast(n) {
+    if (n.type === "code") {
+      return false;
+    }
+    if (n.children && n.children.length > 0) {
+      for (let i = n.children.length - 1; i >= 0; i--) {
+        if (addToLast(n.children[i])) {
+          return true;
+        }
+      }
+      n.children.push({ type: "text", value: cursor });
+      return true;
+    }
+    if (n.type === "text" && typeof n.value === "string") {
+      n.value += cursor;
+      return true;
+    }
+    if (typeof n.value === "string") {
+      n.value += cursor;
+      return true;
+    }
+    return false;
+  }
+  addToLast(cloned);
+  return cloned;
+}
+
+// src/composables/useTypewriter.ts
+function useTypewriter(options) {
+  const { typewriter: typewriterInput, completedBlocks, pendingBlocks } = options;
+  const initialConfig = typewriterInput();
+  const [typewriterEnabled, setTypewriterEnabled] = createSignal2(initialConfig?.enabled ?? !!initialConfig);
+  const [isTypewriterProcessing, setIsTypewriterProcessing] = createSignal2(false);
+  const [isTypewriterPaused, setIsTypewriterPaused] = createSignal2(false);
+  const [typewriterEffect, setTypewriterEffect] = createSignal2(initialConfig?.effect ?? "none");
+  const [typewriterCursor, setTypewriterCursor] = createSignal2(initialConfig?.cursor ?? "|");
+  const [isAnimationComplete, setIsAnimationComplete] = createSignal2(true);
+  const [blocksStore, setBlocksStore] = createStore({ items: [] });
+  let transformer = null;
+  let displayBlocksCache = [];
+  function convertToRenderBlocks(displayBlocks) {
+    return displayBlocks.map((db, index) => {
+      const isPending = !db.isDisplayComplete;
+      const isLastPending = isPending && index === displayBlocks.length - 1;
+      let node = db.displayNode;
+      if (typewriterEffect() === "typing" && isLastPending) {
+        node = addCursorToNode(db.displayNode, typewriterCursor());
+      }
+      return {
+        id: db.id,
+        status: db.status,
+        node,
+        startOffset: 0,
+        endOffset: 0,
+        rawText: "",
+        isLastPending
+      };
+    });
+  }
+  if (initialConfig) {
+    transformer = createBlockTransformer({
+      charsPerTick: initialConfig.charsPerTick ?? [1, 3],
+      tickInterval: initialConfig.tickInterval ?? 30,
+      effect: initialConfig.effect ?? "none",
+      pauseOnHidden: initialConfig.pauseOnHidden ?? true,
+      // 默认插件 + 数学公式插件（数学公式应该整体显示，不参与打字机逐字符效果）
+      plugins: initialConfig.plugins ?? [...defaultPlugins, mathPlugin],
+      onChange: (blocks) => {
+        displayBlocksCache = blocks;
+        const newRenderBlocks = convertToRenderBlocks(displayBlocksCache);
+        setBlocksStore("items", reconcile(newRenderBlocks, { key: "id", merge: true }));
+        setIsTypewriterProcessing(transformer?.isProcessing() ?? false);
+        setIsTypewriterPaused(transformer?.isPausedState() ?? false);
+        if (transformer?.isProcessing() ?? false) {
+          setIsAnimationComplete(false);
+        }
+      },
+      onAllComplete: () => {
+        setIsAnimationComplete(true);
+      }
+    });
+  }
+  createEffect(() => {
+    const newConfig = typewriterInput();
+    if (!newConfig) return;
+    if (newConfig.enabled !== void 0) {
+      setTypewriterEnabled(newConfig.enabled);
+    }
+    if (newConfig.effect !== void 0) {
+      setTypewriterEffect(newConfig.effect);
+    }
+    if (newConfig.cursor !== void 0) {
+      setTypewriterCursor(newConfig.cursor);
+    }
+    transformer?.setOptions({
+      charsPerTick: newConfig.charsPerTick,
+      tickInterval: newConfig.tickInterval,
+      effect: newConfig.effect,
+      pauseOnHidden: newConfig.pauseOnHidden
+    });
+    if (newConfig.enabled === false && transformer) {
+      transformer.reset();
+    }
+  });
+  if (transformer) {
+    createEffect(() => {
+      if (!typewriterEnabled()) return;
+      const allBlocks = [...completedBlocks(), ...pendingBlocks()];
+      transformer.push(allBlocks);
+    });
+  }
+  const rawBlocks = () => [...completedBlocks(), ...pendingBlocks()];
+  createEffect(() => {
+    const enabled = typewriterEnabled();
+    const blocks = rawBlocks();
+    if (!enabled || !transformer) {
+      setBlocksStore("items", reconcile(blocks, { key: "id", merge: true }));
+    }
+  });
+  const displayedFootnoteReferenceOrder = () => {
+    if (!typewriterEnabled() || !transformer) {
+      const references2 = [];
+      const seen2 = /* @__PURE__ */ new Set();
+      for (const block of rawBlocks()) {
+        const blockRefs = collectFootnoteReferences(block.node);
+        for (const ref of blockRefs) {
+          if (!seen2.has(ref)) {
+            seen2.add(ref);
+            references2.push(ref);
+          }
+        }
+      }
+      return references2;
+    }
+    if (!isAnimationComplete()) {
+      return [];
+    }
+    const references = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const db of displayBlocksCache) {
+      const blockRefs = collectFootnoteReferences(db.displayNode);
+      for (const ref of blockRefs) {
+        if (!seen.has(ref)) {
+          seen.add(ref);
+          references.push(ref);
+        }
+      }
+    }
+    return references;
+  };
+  const typewriterControls = {
+    enabled: () => typewriterEnabled(),
+    setEnabled: (value) => {
+      setTypewriterEnabled(value);
+    },
+    isProcessing: () => isTypewriterProcessing(),
+    isPaused: () => isTypewriterPaused(),
+    effect: () => typewriterEffect(),
+    skip: () => transformer?.skip(),
+    pause: () => {
+      transformer?.pause();
+      setIsTypewriterPaused(true);
+    },
+    resume: () => {
+      transformer?.resume();
+      setIsTypewriterPaused(false);
+    },
+    setOptions: (opts) => {
+      if (opts.enabled !== void 0) {
+        setTypewriterEnabled(opts.enabled);
+      }
+      if (opts.charsPerTick !== void 0 || opts.tickInterval !== void 0 || opts.effect !== void 0 || opts.pauseOnHidden !== void 0) {
+        transformer?.setOptions({
+          charsPerTick: opts.charsPerTick,
+          tickInterval: opts.tickInterval,
+          effect: opts.effect,
+          pauseOnHidden: opts.pauseOnHidden
+        });
+      }
+      if (opts.effect !== void 0) {
+        setTypewriterEffect(opts.effect);
+      }
+      if (opts.cursor !== void 0) {
+        setTypewriterCursor(opts.cursor);
+      }
+    }
+  };
+  onCleanup(() => {
+    transformer?.destroy();
+  });
+  return {
+    blocks: blocksStore.items,
+    typewriter: typewriterControls,
+    transformer,
+    isAnimationComplete: () => isAnimationComplete(),
+    displayedFootnoteReferenceOrder: () => displayedFootnoteReferenceOrder()
+  };
+}
+
+// src/utils/animatedChunks.ts
+var animatedChunks = /* @__PURE__ */ new Set();
+function shouldAnimateChunk(createdAt) {
+  if (animatedChunks.has(createdAt)) {
+    return false;
+  }
+  animatedChunks.add(createdAt);
+  return true;
+}
+function clearAnimatedChunks() {
+  animatedChunks.clear();
+}
+
+// src/composables/useIncremark.ts
+function useIncremark(optionsInput = () => ({})) {
+  const { setDefinations, setFootnoteDefinitions, footnoteReferenceOrder, setFootnoteReferenceOrder, contextValue, DefinationsProvider: DefinationsProvider2 } = useProvideDefinations();
+  function createParser(options) {
+    return createIncremarkParser({
+      ...options,
+      onChange: (state) => {
+        setDefinations(state.definitions);
+        setFootnoteDefinitions(state.footnoteDefinitions);
+        options.onChange?.(state);
+      }
+    });
+  }
+  let parser = createParser(optionsInput());
+  const [completedBlocks, setCompletedBlocks] = createSignal3([]);
+  const [pendingBlocks, setPendingBlocks] = createSignal3([]);
+  const [isLoading, setIsLoading] = createSignal3(false);
+  const [markdown, setMarkdown] = createSignal3("");
+  const [isFinalized, setIsFinalized] = createSignal3(false);
+  const { blocks, typewriter, transformer, isAnimationComplete, displayedFootnoteReferenceOrder } = useTypewriter({
+    typewriter: () => optionsInput().typewriter,
+    completedBlocks,
+    pendingBlocks
+  });
+  const isDisplayComplete = () => {
+    if (!optionsInput().typewriter || !typewriter.enabled()) {
+      return isFinalized();
+    }
+    return isFinalized() && isAnimationComplete();
+  };
+  const [ast, setAst] = createSignal3({
+    type: "root",
+    children: []
+  });
+  function handleUpdate(update, isFinalize = false) {
+    setMarkdown(parser.getBuffer());
+    if (update.updated.length > 0) {
+      const idsToRemove = new Set(update.updated.map((b) => b.id));
+      setCompletedBlocks((prev) => prev.filter((b) => !idsToRemove.has(b.id)));
+    }
+    if (update.completed.length > 0) {
+      setCompletedBlocks((prev) => [...prev, ...update.completed]);
+    }
+    setPendingBlocks(update.pending);
+    if (isFinalize) {
+      if (update.pending.length > 0) {
+        setCompletedBlocks((prev) => [...prev, ...update.pending]);
+        setPendingBlocks([]);
+      }
+      setIsLoading(false);
+      setIsFinalized(true);
+    } else {
+      setIsLoading(true);
+    }
+    setFootnoteReferenceOrder(update.footnoteReferenceOrder);
+  }
+  function append(chunk) {
+    const update = parser.append(chunk);
+    setAst(update.ast);
+    handleUpdate(update, false);
+    return update;
+  }
+  function finalize() {
+    const update = parser.finalize();
+    handleUpdate(update, true);
+    return update;
+  }
+  function abort() {
+    return finalize();
+  }
+  function reset() {
+    parser.reset();
+    setCompletedBlocks([]);
+    setPendingBlocks([]);
+    setMarkdown("");
+    setIsLoading(false);
+    setIsFinalized(false);
+    setFootnoteReferenceOrder([]);
+    transformer?.reset();
+    clearAnimatedChunks();
+  }
+  let lastOptionsStr = "";
+  createEffect2(() => {
+    const opts = optionsInput();
+    const { typewriter: _, astBuilder, ...parserOptions } = opts;
+    const optionsStr = JSON.stringify(parserOptions) + "|" + (astBuilder?.name ?? "default");
+    if (optionsStr !== lastOptionsStr) {
+      lastOptionsStr = optionsStr;
+      const { typewriter: _2, ...parserOptions2 } = opts;
+      parser.updateOptions(parserOptions2);
+      setCompletedBlocks([]);
+      setPendingBlocks([]);
+      setMarkdown("");
+      setIsLoading(false);
+      setIsFinalized(false);
+      setFootnoteReferenceOrder([]);
+      transformer?.reset();
+    }
+  });
+  createEffect2(() => {
+    const newOrder = displayedFootnoteReferenceOrder();
+    setFootnoteReferenceOrder(newOrder);
+  });
+  function render(content) {
+    const update = parser.render(content);
+    setMarkdown(parser.getBuffer());
+    setCompletedBlocks(parser.getCompletedBlocks());
+    setPendingBlocks([]);
+    setIsLoading(false);
+    setIsFinalized(true);
+    setFootnoteReferenceOrder(update.footnoteReferenceOrder);
+    setFootnoteReferenceOrder(update.footnoteReferenceOrder);
+    return update;
+  }
+  const result = {
+    /** 已收集的完整 Markdown 字符串 */
+    markdown,
+    /** 已完成的块列表 */
+    completedBlocks,
+    /** 待处理的块列表 */
+    pendingBlocks,
+    /** 当前完整的 AST */
+    ast,
+    /** 用于渲染的 blocks（根据打字机设置自动处理） */
+    blocks,
+    /** 是否正在加载 */
+    isLoading,
+    /** 是否已完成（finalize） */
+    isFinalized,
+    /**
+     * 内容是否完全显示完成
+     * - 无打字机：等于 isFinalized
+     * - 有打字机：isFinalized + 动画播放完成
+     * 适用于控制 footnote 等需要在内容完全显示后才出现的元素
+     */
+    isDisplayComplete,
+    /** 脚注引用的出现顺序 */
+    footnoteReferenceOrder,
+    /** 追加内容 */
+    append,
+    /** 完成解析 */
+    finalize,
+    /** 强制中断 */
+    abort,
+    /** 重置解析器和打字机 */
+    reset,
+    /** 一次性渲染（reset + append + finalize） */
+    render,
+    /** 解析器实例 */
+    parser,
+    /** 打字机控制 */
+    typewriter,
+    /** Context value for DefinationsProvider */
+    contextValue,
+    /** DefinationsProvider component */
+    DefinationsProvider: DefinationsProvider2
+  };
+  return result;
+}
+
+// src/composables/useShiki.ts
+import { createSignal as createSignal4 } from "solid-js";
+var _ShikiManager = class _ShikiManager {
+  constructor() {
+    /** 存储 highlighter 实例，key 为主题名称 */
+    this.highlighters = /* @__PURE__ */ new Map();
+  }
+  static getInstance() {
+    if (!_ShikiManager.instance) {
+      _ShikiManager.instance = new _ShikiManager();
+    }
+    return _ShikiManager.instance;
+  }
+  /**
+   * 获取或创建 highlighter
+   * @param theme 主题名称
+   * @returns highlighter 实例
+   */
+  async getHighlighter(theme) {
+    if (this.highlighters.has(theme)) {
+      return this.highlighters.get(theme);
+    }
+    const { createHighlighter } = await import("shiki");
+    const highlighter = await createHighlighter({
+      themes: [theme],
+      langs: []
+    });
+    const info = {
+      highlighter,
+      loadedLanguages: /* @__PURE__ */ new Set(),
+      loadedThemes: /* @__PURE__ */ new Set([theme])
+    };
+    this.highlighters.set(theme, info);
+    return info;
+  }
+  /**
+   * 加载语言（按需）
+   * @param theme 主题名称
+   * @param lang 语言名称
+   */
+  async loadLanguage(theme, lang) {
+    const info = this.highlighters.get(theme);
+    if (!info || info.loadedLanguages.has(lang)) return;
+    try {
+      await info.highlighter.loadLanguage(lang);
+      info.loadedLanguages.add(lang);
+    } catch {
+    }
+  }
+  /**
+   * 加载主题（按需）
+   * @param theme 主题名称
+   */
+  async loadTheme(theme) {
+    const info = this.highlighters.get(theme);
+    if (!info || info.loadedThemes.has(theme)) return;
+    try {
+      await info.highlighter.loadTheme(theme);
+      info.loadedThemes.add(theme);
+    } catch {
+    }
+  }
+  /**
+   * 高亮代码
+   * @param theme 主题名称
+   * @param code 代码内容
+   * @param lang 语言名称
+   * @param fallbackTheme 回退主题
+   * @returns 高亮后的 HTML
+   */
+  async codeToHtml(theme, code, lang, fallbackTheme) {
+    const info = this.highlighters.get(theme);
+    if (!info) throw new Error("Highlighter not found");
+    const actualLang = info.loadedLanguages.has(lang) ? lang : "text";
+    const actualTheme = info.loadedThemes.has(theme) ? theme : fallbackTheme;
+    return info.highlighter.codeToHtml(code, {
+      lang: actualLang,
+      theme: actualTheme
+    });
+  }
+  /**
+   * 清理所有 highlighter（应用退出或需要重置时调用）
+   */
+  disposeAll() {
+    for (const [, info] of this.highlighters) {
+      if (info.highlighter?.dispose) {
+        info.highlighter.dispose();
+      }
+    }
+    this.highlighters.clear();
+  }
+};
+_ShikiManager.instance = null;
+var ShikiManager = _ShikiManager;
+var shikiManagerInstance = null;
+function getShikiManager() {
+  if (!shikiManagerInstance) {
+    shikiManagerInstance = ShikiManager.getInstance();
+  }
+  return shikiManagerInstance;
+}
+function useShiki(theme) {
+  const [highlighterInfo, setHighlighterInfo] = createSignal4(null);
+  const [isHighlighting, setIsHighlighting] = createSignal4(false);
+  const [isReady, setIsReady] = createSignal4(false);
+  async function initHighlighter() {
+    if (isReady()) return;
+    try {
+      const info = await getShikiManager().getHighlighter(theme);
+      setHighlighterInfo(info);
+      setIsReady(true);
+    } catch (e) {
+      console.warn("Failed to initialize Shiki highlighter:", e);
+      throw e;
+    }
+  }
+  async function getHighlighter() {
+    if (!highlighterInfo()) {
+      const info = await getShikiManager().getHighlighter(theme);
+      setHighlighterInfo(info);
+      setIsReady(true);
+      return info;
+    }
+    return highlighterInfo();
+  }
+  async function highlight(code, lang, fallbackTheme) {
+    setIsHighlighting(true);
+    try {
+      const info = await getHighlighter();
+      const manager = getShikiManager();
+      if (!info.loadedLanguages.has(lang) && lang !== "text") {
+        await manager.loadLanguage(theme, lang);
+      }
+      if (!info.loadedThemes.has(theme)) {
+        await manager.loadTheme(theme);
+      }
+      return await manager.codeToHtml(
+        theme,
+        code,
+        lang,
+        fallbackTheme
+      );
+    } catch (e) {
+      throw e;
+    } finally {
+      setIsHighlighting(false);
+    }
+  }
+  return {
+    highlighterInfo,
+    isHighlighting,
+    isReady,
+    initHighlighter,
+    highlight
+  };
+}
+
+// src/components/ConfigProvider.tsx
+import { createContext as createContext2, useContext, createSignal as createSignal5, createMemo } from "solid-js";
+import { zhCN } from "@incremark/shared";
+import { jsx as jsx2 } from "solid-js/jsx-runtime";
+var LocaleContext = createContext2();
+var ConfigProvider = (props) => {
+  const [locale, setLocale] = createSignal5(props.locale || zhCN);
+  createMemo(() => {
+    setLocale(props.locale || zhCN);
+  });
+  return /* @__PURE__ */ jsx2(LocaleContext.Provider, { value: { locale }, children: props.children });
+};
+function useLocale() {
+  const context = useContext(LocaleContext);
+  const locale = context?.locale || (() => zhCN);
+  return (key) => {
+    const keys = key.split(".");
+    let value = locale();
+    for (const k of keys) {
+      value = value?.[k];
+    }
+    return value || key;
+  };
+}
+
+// src/composables/useDefinationsContext.ts
+import { useContext as useContext2 } from "solid-js";
+function useDefinationsContext() {
+  const context = useContext2(DefinationsContext);
+  if (!context) {
+    throw new Error("DefinationsContext not found. Make sure you are using this within a component that provides DefinationsContext.");
+  }
+  return context;
+}
+
+// src/composables/useDevTools.ts
+import { createSignal as createSignal6 } from "solid-js";
+function useDevTools(options = {}) {
+  const [enabled, setEnabled] = createSignal6(options.enabled ?? false);
+  const [blocks, setBlocks] = createSignal6([]);
+  const [ast, setAst] = createSignal6(null);
+  const stats = () => ({
+    blockCount: blocks().length,
+    completedCount: blocks().filter((b) => b.status === "completed").length,
+    pendingCount: blocks().filter((b) => b.status !== "completed").length
+  });
+  function toggle() {
+    setEnabled((prev) => !prev);
+  }
+  return {
+    enabled,
+    toggle,
+    setEnabled,
+    blocks,
+    setBlocks,
+    ast,
+    setAst,
+    stats
+  };
+}
+
+// src/composables/useStreamRenderer.ts
+import { createSignal as createSignal7 } from "solid-js";
+function useStreamRenderer(options = {}) {
+  const [blocks, setBlocks] = createSignal7(options.initialBlocks ?? []);
+  function addBlocks(newBlocks) {
+    setBlocks((prev) => [...prev, ...newBlocks]);
+  }
+  function clearBlocks() {
+    setBlocks([]);
+  }
+  const blockCount = () => blocks().length;
+  return {
+    blocks,
+    setBlocks,
+    addBlocks,
+    clearBlocks,
+    blockCount
+  };
+}
+
+// src/composables/useBlockTransformer.ts
+import { createSignal as createSignal8 } from "solid-js";
+import {
+  createBlockTransformer as createBlockTransformer2
+} from "@incremark/core";
+function useBlockTransformer(options = {}) {
+  const [displayBlocks, setDisplayBlocks] = createSignal8([]);
+  const [isProcessing, setIsProcessing] = createSignal8(false);
+  const [isPaused, setIsPaused] = createSignal8(false);
+  const transformer = createBlockTransformer2({
+    charsPerTick: options.charsPerTick ?? [1, 3],
+    tickInterval: options.tickInterval ?? 30,
+    effect: options.effect ?? "none",
+    pauseOnHidden: options.pauseOnHidden ?? true,
+    plugins: options.plugins,
+    onChange: (blocks) => {
+      setDisplayBlocks(blocks);
+      setIsProcessing(transformer?.isProcessing() ?? false);
+      setIsPaused(transformer?.isPausedState() ?? false);
+    }
+  });
+  function push(blocks) {
+    transformer.push(blocks);
+  }
+  function skip() {
+    transformer.skip();
+  }
+  function pause() {
+    transformer.pause();
+  }
+  function resume() {
+    transformer.resume();
+  }
+  function reset() {
+    transformer.reset();
+  }
+  function destroy() {
+    transformer.destroy();
+  }
+  function setOptions(opts) {
+    transformer.setOptions(opts);
+  }
+  return {
+    displayBlocks,
+    isProcessing,
+    isPaused,
+    push,
+    skip,
+    pause,
+    resume,
+    reset,
+    destroy,
+    setOptions
+  };
+}
+
+// src/components/Incremark.tsx
+import { For as For9, Show as Show13, mergeProps } from "solid-js";
+
+// src/components/IncremarkRenderer.tsx
+import { Show as Show11 } from "solid-js";
+import { Dynamic as Dynamic5 } from "solid-js/web";
+
+// src/components/IncremarkHeading.tsx
+import { Dynamic as Dynamic2 } from "solid-js/web";
+
+// src/components/IncremarkInline.tsx
+import { hasChunks, getStableText, isHtmlNode } from "@incremark/shared";
+import { For as For2, Index, Show as Show3 } from "solid-js";
+
+// src/components/IncremarkMath.tsx
+import { createSignal as createSignal9, createEffect as createEffect4, onCleanup as onCleanup3, Show } from "solid-js";
+import { jsx as jsx3, jsxs } from "solid-js/jsx-runtime";
+var IncremarkMath = (props) => {
+  const [renderedHtml, setRenderedHtml] = createSignal9("");
+  const [isLoading, setIsLoading] = createSignal9(false);
+  const isInline = () => props.node.type === "inlineMath";
+  const formula = () => props.node.value;
+  let renderTimer = null;
+  let katexRef = null;
+  function scheduleRender() {
+    if (!formula()) {
+      setRenderedHtml("");
+      return;
+    }
+    if (renderTimer) {
+      clearTimeout(renderTimer);
+    }
+    setIsLoading(true);
+    renderTimer = setTimeout(() => {
+      doRender();
+    }, props.renderDelay ?? 0);
+  }
+  async function doRender() {
+    if (!formula()) return;
+    try {
+      if (!katexRef) {
+        const katexModule = await import("katex");
+        katexRef = katexModule.default;
+      }
+      const katex = katexRef;
+      setRenderedHtml(katex.renderToString(formula(), {
+        displayMode: !isInline(),
+        throwOnError: false,
+        strict: false
+      }));
+    } catch {
+      setRenderedHtml("");
+    } finally {
+      setIsLoading(false);
+    }
+  }
+  createEffect4(() => {
+    scheduleRender();
+  });
+  onCleanup3(() => {
+    if (renderTimer) {
+      clearTimeout(renderTimer);
+    }
+  });
+  if (isInline()) {
+    return /* @__PURE__ */ jsxs("span", { class: "incremark-math-inline", children: [
+      /* @__PURE__ */ jsx3(Show, { when: renderedHtml() && !isLoading(), children: /* @__PURE__ */ jsx3("span", { innerHTML: renderedHtml() }) }),
+      /* @__PURE__ */ jsx3(Show, { when: !renderedHtml() || isLoading(), children: /* @__PURE__ */ jsx3("code", { class: "math-source", children: formula() }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { class: "incremark-math-block", children: [
+    /* @__PURE__ */ jsx3(Show, { when: renderedHtml() && !isLoading(), children: /* @__PURE__ */ jsx3("div", { innerHTML: renderedHtml(), class: "math-rendered" }) }),
+    /* @__PURE__ */ jsx3(Show, { when: !renderedHtml() || isLoading(), children: /* @__PURE__ */ jsx3("pre", { class: "math-source-block", children: /* @__PURE__ */ jsx3("code", { children: formula() }) }) })
+  ] });
+};
+
+// src/components/IncremarkHtmlElement.tsx
+import { For, Show as Show2 } from "solid-js";
+import { Dynamic } from "solid-js/web";
+import { Fragment, jsx as jsx4 } from "solid-js/jsx-runtime";
+var INLINE_ELEMENTS = [
+  "a",
+  "abbr",
+  "acronym",
+  "b",
+  "bdo",
+  "big",
+  "br",
+  "button",
+  "cite",
+  "code",
+  "dfn",
+  "em",
+  "i",
+  "img",
+  "input",
+  "kbd",
+  "label",
+  "map",
+  "object",
+  "output",
+  "q",
+  "samp",
+  "script",
+  "select",
+  "small",
+  "span",
+  "strong",
+  "sub",
+  "sup",
+  "textarea",
+  "time",
+  "tt",
+  "var"
+];
+var VOID_ELEMENTS = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+function isInlineElement(tagName) {
+  return INLINE_ELEMENTS.includes(tagName.toLowerCase());
+}
+function isVoidElement(tagName) {
+  return VOID_ELEMENTS.includes(tagName.toLowerCase());
+}
+function hasOnlyInlineChildren(children) {
+  if (!children || children.length === 0) return true;
+  return children.every((child) => {
+    const type = child.type;
+    const inlineTypes = ["text", "strong", "emphasis", "inlineCode", "link", "image", "break", "html", "htmlElement"];
+    if (inlineTypes.includes(type)) {
+      if (type === "htmlElement") {
+        return isInlineElement(child.tagName);
+      }
+      return true;
+    }
+    return false;
+  });
+}
+function renderChildren(children) {
+  if (!children || children.length === 0) return null;
+  if (hasOnlyInlineChildren(children)) {
+    return /* @__PURE__ */ jsx4(IncremarkInline, { nodes: children });
+  }
+  return /* @__PURE__ */ jsx4(For, { each: children, children: (child, idx) => {
+    if (child.type === "htmlElement") {
+      return /* @__PURE__ */ jsx4(IncremarkHtmlElement, { node: child });
+    }
+    if (child.type === "text") {
+      return /* @__PURE__ */ jsx4(Fragment, { children: child.value });
+    }
+    if (["strong", "emphasis", "inlineCode", "link", "image", "break"].includes(child.type)) {
+      return /* @__PURE__ */ jsx4(IncremarkInline, { nodes: [child] });
+    }
+    if (child.type === "paragraph") {
+      return /* @__PURE__ */ jsx4("p", { children: /* @__PURE__ */ jsx4(IncremarkInline, { nodes: child.children }) });
+    }
+    return /* @__PURE__ */ jsx4(IncremarkRenderer, { node: child });
+  } });
+}
+var IncremarkHtmlElement = (props) => {
+  const tagName = () => props.node.tagName;
+  const attrs = () => props.node.attrs || {};
+  const children = () => props.node.children || [];
+  const isVoid = () => isVoidElement(tagName());
+  return /* @__PURE__ */ jsx4(
+    Dynamic,
+    {
+      component: tagName(),
+      ...attrs(),
+      class: `incremark-html-element incremark-${tagName()}`,
+      children: /* @__PURE__ */ jsx4(Show2, { when: !isVoid(), children: renderChildren(children()) })
+    }
+  );
+};
+
+// src/components/IncremarkInline.tsx
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs2 } from "solid-js/jsx-runtime";
+function isHtmlElementNode(node) {
+  return node.type === "htmlElement";
+}
+function isImageReference(node) {
+  return node.type === "imageReference";
+}
+function isLinkReference(node) {
+  return node.type === "linkReference";
+}
+var IncremarkInline = (props) => {
+  const { definations, footnoteDefinitions } = useDefinationsContext();
+  function getChunks(node) {
+    if (hasChunks(node)) {
+      return node.chunks;
+    }
+    return void 0;
+  }
+  function isInlineMath(node) {
+    return node.type === "inlineMath";
+  }
+  return /* @__PURE__ */ jsx5(Fragment2, { children: /* @__PURE__ */ jsx5(For2, { each: props.nodes, children: (node, idx) => /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    /* @__PURE__ */ jsxs2(Show3, { when: node.type === "text", children: [
+      getStableText(node),
+      /* @__PURE__ */ jsx5(Index, { each: getChunks(node) || [], children: (chunk, idx2) => /* @__PURE__ */ jsx5(
+        "span",
+        {
+          class: "incremark-fade-in",
+          "data-chunk-key": chunk().createdAt,
+          children: chunk().text
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsx5(Show3, { when: isInlineMath(node), children: /* @__PURE__ */ jsx5(IncremarkMath, { node }) }),
+    /* @__PURE__ */ jsx5(Show3, { when: isHtmlElementNode(node), children: /* @__PURE__ */ jsx5(IncremarkHtmlElement, { node }) }),
+    /* @__PURE__ */ jsx5(Show3, { when: isHtmlNode(node), children: /* @__PURE__ */ jsx5("span", { class: "incremark-inline-html", innerHTML: node.value }) }),
+    /* @__PURE__ */ jsx5(Show3, { when: node.type === "strong", children: /* @__PURE__ */ jsx5("strong", { children: /* @__PURE__ */ jsx5(IncremarkInline, { nodes: node.children }) }) }),
+    /* @__PURE__ */ jsx5(Show3, { when: node.type === "emphasis", children: /* @__PURE__ */ jsx5("em", { children: /* @__PURE__ */ jsx5(IncremarkInline, { nodes: node.children }) }) }),
+    /* @__PURE__ */ jsx5(Show3, { when: node.type === "inlineCode", children: /* @__PURE__ */ jsx5("code", { class: "incremark-inline-code", children: node.value }) }),
+    /* @__PURE__ */ jsx5(Show3, { when: node.type === "link", children: /* @__PURE__ */ jsx5(
+      "a",
+      {
+        class: "incremark-link",
+        href: node.url,
+        target: "_blank",
+        rel: "noopener noreferrer",
+        children: /* @__PURE__ */ jsx5(IncremarkInline, { nodes: node.children })
+      }
+    ) }),
+    /* @__PURE__ */ jsx5(Show3, { when: node.type === "image", children: /* @__PURE__ */ jsx5(
+      "img",
+      {
+        class: "incremark-image",
+        src: node.url,
+        alt: node.alt || "",
+        title: node.title || void 0,
+        loading: "lazy"
+      }
+    ) }),
+    /* @__PURE__ */ jsx5(Show3, { when: isImageReference(node), children: /* @__PURE__ */ jsx5(
+      Show3,
+      {
+        when: definations()[node.identifier],
+        fallback: /* @__PURE__ */ jsxs2("span", { class: "incremark-image-ref-missing", children: [
+          "![",
+          node.alt,
+          "][",
+          node.identifier || node.label,
+          "]"
+        ] }),
+        children: /* @__PURE__ */ jsx5(
+          "img",
+          {
+            class: "incremark-image incremark-reference-image",
+            src: definations()[node.identifier].url,
+            alt: node.alt || "",
+            title: definations()[node.identifier].title || void 0,
+            loading: "lazy"
+          }
+        )
+      }
+    ) }),
+    /* @__PURE__ */ jsx5(Show3, { when: isLinkReference(node), children: /* @__PURE__ */ jsx5(
+      Show3,
+      {
+        when: definations()[node.identifier],
+        fallback: /* @__PURE__ */ jsxs2("span", { class: "incremark-link-ref-missing", children: [
+          "[",
+          node.children.map((c) => c.value).join(""),
+          "][",
+          node.identifier || node.label,
+          "]"
+        ] }),
+        children: /* @__PURE__ */ jsx5(
+          "a",
+          {
+            class: "incremark-link incremark-reference-link",
+            href: definations()[node.identifier].url,
+            title: definations()[node.identifier].title || void 0,
+            target: "_blank",
+            rel: "noopener noreferrer",
+            children: /* @__PURE__ */ jsx5(IncremarkInline, { nodes: node.children })
+          }
+        )
+      }
+    ) }),
+    /* @__PURE__ */ jsx5(Show3, { when: node.type === "footnoteReference", children: /* @__PURE__ */ jsx5("sup", { class: "incremark-footnote-ref", children: /* @__PURE__ */ jsxs2("a", { href: `#fn-${node.identifier}`, id: `fnref-${node.identifier}`, children: [
+      "[",
+      node.identifier,
+      "]"
+    ] }) }) }),
+    /* @__PURE__ */ jsx5(Show3, { when: node.type === "break", children: /* @__PURE__ */ jsx5("br", {}) }),
+    /* @__PURE__ */ jsx5(Show3, { when: node.type === "delete", children: /* @__PURE__ */ jsx5("del", { children: /* @__PURE__ */ jsx5(IncremarkInline, { nodes: node.children }) }) })
+  ] }) }) });
+};
+
+// src/components/IncremarkHeading.tsx
+import { jsx as jsx6 } from "solid-js/jsx-runtime";
+var IncremarkHeading = (props) => {
+  const tag = () => `h${props.node.depth}`;
+  return /* @__PURE__ */ jsx6(Dynamic2, { component: tag(), class: `incremark-heading h${props.node.depth}`, children: /* @__PURE__ */ jsx6(IncremarkInline, { nodes: props.node.children }) });
+};
+
+// src/components/IncremarkParagraph.tsx
+import { jsx as jsx7 } from "solid-js/jsx-runtime";
+var IncremarkParagraph = (props) => {
+  return /* @__PURE__ */ jsx7("p", { class: "incremark-paragraph", children: /* @__PURE__ */ jsx7(IncremarkInline, { nodes: props.node.children }) });
+};
+
+// src/components/IncremarkCode.tsx
+import { Show as Show7 } from "solid-js";
+import { Dynamic as Dynamic3 } from "solid-js/web";
+
+// src/components/IncremarkCodeMermaid.tsx
+import { createEffect as createEffect5, createSignal as createSignal10, onCleanup as onCleanup4, onMount, Show as Show4 } from "solid-js";
+import { GravityMermaid, LucideCode, LucideEye, LucideCopy, LucideCopyCheck } from "@incremark/icons";
+import { isClipboardAvailable } from "@incremark/shared";
+
+// src/components/SvgIcon.tsx
+import { jsx as jsx8 } from "solid-js/jsx-runtime";
+var SvgIcon = (props) => {
+  return /* @__PURE__ */ jsx8(
+    "span",
+    {
+      classList: {
+        "incremark-icon": true,
+        [props.sizeClass || ""]: !!props.sizeClass
+      },
+      innerHTML: props.svg,
+      "aria-hidden": "true"
+    }
+  );
+};
+
+// src/components/IncremarkCodeMermaid.tsx
+import { jsx as jsx9, jsxs as jsxs3 } from "solid-js/jsx-runtime";
+var IncremarkCodeMermaid = (props) => {
+  const [mermaidSvg, setMermaidSvg] = createSignal10("");
+  const [mermaidError, setMermaidError] = createSignal10("");
+  const [mermaidLoading, setMermaidLoading] = createSignal10(false);
+  const [copied, setCopied] = createSignal10(false);
+  const [mermaidViewMode, setMermaidViewMode] = createSignal10("preview");
+  let mermaidInstance = null;
+  let renderTimer = null;
+  let copyTimeoutId = null;
+  let chartId = `mermaid-${Math.random().toString(36).substr(2, 9)}`;
+  const code = () => props.node.value;
+  const t = useLocale();
+  function toggleMermaidView() {
+    setMermaidViewMode((prev) => prev === "preview" ? "source" : "preview");
+  }
+  onMount(async () => {
+    try {
+      const mermaidModule = await import("mermaid");
+      const mermaid = mermaidModule.default;
+      mermaid.initialize({
+        startOnLoad: false,
+        theme: "dark",
+        securityLevel: "loose",
+        suppressErrorRendering: true
+      });
+      mermaidInstance = mermaid;
+    } catch (e) {
+      console.warn("Failed to initialize Mermaid:", e);
+      setMermaidError("Failed to initialize");
+    }
+  });
+  function scheduleRender() {
+    if (!code()) {
+      return;
+    }
+    if (renderTimer) {
+      clearTimeout(renderTimer);
+    }
+    setMermaidLoading(true);
+    setMermaidError("");
+    renderTimer = setTimeout(() => {
+      doRender();
+    }, props.mermaidDelay ?? 500);
+  }
+  async function doRender() {
+    if (!code() || !mermaidInstance) return;
+    try {
+      const { svg } = await mermaidInstance.render(chartId, code());
+      setMermaidSvg(svg);
+      setMermaidError("");
+    } catch (e) {
+      setMermaidError("");
+      setMermaidSvg("");
+    } finally {
+      setMermaidLoading(false);
+    }
+  }
+  createEffect5(() => {
+    scheduleRender();
+  });
+  onCleanup4(() => {
+    if (renderTimer) {
+      clearTimeout(renderTimer);
+    }
+    if (copyTimeoutId) {
+      clearTimeout(copyTimeoutId);
+    }
+  });
+  async function copyCode() {
+    if (!isClipboardAvailable()) return;
+    try {
+      await navigator.clipboard.writeText(code());
+      setCopied(true);
+      if (copyTimeoutId) {
+        clearTimeout(copyTimeoutId);
+      }
+      copyTimeoutId = setTimeout(() => {
+        setCopied(false);
+      }, 2e3);
+    } catch {
+    }
+  }
+  return /* @__PURE__ */ jsxs3("div", { class: "incremark-mermaid", children: [
+    /* @__PURE__ */ jsxs3("div", { class: "mermaid-header", children: [
+      /* @__PURE__ */ jsxs3("span", { class: "language", children: [
+        /* @__PURE__ */ jsx9(SvgIcon, { svg: GravityMermaid, sizeClass: "language-icon" }),
+        "MERMAID"
+      ] }),
+      /* @__PURE__ */ jsxs3("div", { class: "mermaid-actions", children: [
+        /* @__PURE__ */ jsx9(
+          "button",
+          {
+            class: "code-btn",
+            onClick: toggleMermaidView,
+            type: "button",
+            disabled: !mermaidSvg(),
+            "aria-label": mermaidViewMode() === "preview" ? t("mermaid.viewSource") : t("mermaid.preview"),
+            title: mermaidViewMode() === "preview" ? "View Source" : "Preview",
+            children: /* @__PURE__ */ jsx9(SvgIcon, { svg: mermaidViewMode() === "preview" ? LucideCode : LucideEye })
+          }
+        ),
+        /* @__PURE__ */ jsx9(
+          "button",
+          {
+            class: "code-btn",
+            onClick: copyCode,
+            type: "button",
+            "aria-label": copied() ? t("mermaid.copied") : t("mermaid.copy"),
+            title: copied() ? "Copied!" : "Copy",
+            children: /* @__PURE__ */ jsx9(SvgIcon, { svg: copied() ? LucideCopyCheck : LucideCopy })
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3("div", { class: "mermaid-content", children: [
+      /* @__PURE__ */ jsx9(Show4, { when: mermaidLoading() && !mermaidSvg(), children: /* @__PURE__ */ jsx9("div", { class: "mermaid-loading", children: /* @__PURE__ */ jsx9("pre", { class: "mermaid-source-code", children: code() }) }) }),
+      /* @__PURE__ */ jsx9(Show4, { when: mermaidViewMode() === "source" && !mermaidLoading(), children: /* @__PURE__ */ jsx9("pre", { class: "mermaid-source-code", children: code() }) }),
+      /* @__PURE__ */ jsx9(Show4, { when: mermaidViewMode() === "preview" && mermaidSvg() && !mermaidLoading(), children: /* @__PURE__ */ jsx9("div", { innerHTML: mermaidSvg(), class: "mermaid-svg" }) }),
+      /* @__PURE__ */ jsx9(Show4, { when: !mermaidSvg() && !mermaidLoading() && mermaidViewMode() === "preview", children: /* @__PURE__ */ jsx9("pre", { class: "mermaid-source-code", children: code() }) })
+    ] })
+  ] });
+};
+
+// src/components/IncremarkCodeDefault.tsx
+import { createEffect as createEffect7, createSignal as createSignal12, onCleanup as onCleanup6, Show as Show6 } from "solid-js";
+import { LucideCopy as LucideCopy2, LucideCopyCheck as LucideCopyCheck2 } from "@incremark/icons";
+import { isClipboardAvailable as isClipboardAvailable2 } from "@incremark/shared";
+
+// src/components/CachedCodeRenderer.tsx
+import { CodeToTokenTransformStream } from "shiki-stream";
+import { getTokenStyleObject } from "@shikijs/core";
+import { createEffect as createEffect6, createSignal as createSignal11, on, onCleanup as onCleanup5, onMount as onMount2, For as For3, Show as Show5 } from "solid-js";
+import { batch } from "solid-js";
+import { jsx as jsx10 } from "solid-js/jsx-runtime";
+var isBrowser = typeof window !== "undefined";
+var CachedCodeRenderer = (props) => {
+  const [hasStreamError, setHasStreamError] = createSignal11(false);
+  const [tokens, setTokens] = createSignal11([]);
+  const [index, setIndex] = createSignal11(0);
+  let controller = null;
+  let abortController = null;
+  onMount2(() => {
+    if (!isBrowser) return;
+    const textStream = new ReadableStream({
+      start(_controller) {
+        controller = _controller;
+      }
+    });
+    try {
+      const tokenStream = textStream.pipeThrough(
+        new CodeToTokenTransformStream({
+          highlighter: props.highlighter,
+          lang: props.lang,
+          theme: props.theme,
+          allowRecalls: true
+        })
+      );
+      let started = false;
+      abortController = new AbortController();
+      tokenStream.pipeTo(new WritableStream({
+        write(token) {
+          if (abortController?.signal.aborted) return;
+          if (!started) {
+            started = true;
+            props.onStreamStart?.();
+          }
+          batch(() => {
+            if ("recall" in token) {
+              setTokens((ts) => ts.slice(0, -token.recall));
+            } else {
+              setTokens((ts) => [...ts, token]);
+            }
+          });
+        },
+        close: () => {
+          if (!abortController?.signal.aborted) {
+            props.onStreamEnd?.();
+          }
+        },
+        abort: () => {
+          if (!abortController?.signal.aborted) {
+            props.onStreamEnd?.();
+          }
+        }
+      }), { signal: abortController.signal }).catch((error) => {
+        if (error instanceof Error && error.name === "AbortError") {
+          return;
+        }
+        if (error instanceof Error && error.message.includes("not found")) {
+          setHasStreamError(true);
+          return;
+        }
+        console.error("Stream error:", error);
+        setHasStreamError(true);
+      });
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not found")) {
+        setHasStreamError(true);
+        return;
+      }
+      console.error("Failed to create token stream:", error);
+      setHasStreamError(true);
+    }
+  });
+  createEffect6(on(
+    () => props.code,
+    (newCode) => {
+      if (!isBrowser || !controller || abortController?.signal.aborted) return;
+      const currentIndex = index();
+      if (newCode.length > currentIndex && !hasStreamError()) {
+        const incremental = newCode.slice(currentIndex);
+        controller.enqueue(incremental);
+        setIndex(newCode.length);
+      }
+    }
+  ));
+  onCleanup5(() => {
+    abortController?.abort();
+    controller = null;
+    setHasStreamError(false);
+    setTokens([]);
+    setIndex(0);
+  });
+  return /* @__PURE__ */ jsx10(
+    Show5,
+    {
+      when: !(hasStreamError() || !isBrowser || tokens().length === 0),
+      fallback: (
+        // SSR 或错误时渲染原始代码
+        /* @__PURE__ */ jsx10("pre", { class: "shiki incremark-code-stream", children: /* @__PURE__ */ jsx10("code", { children: props.code }) })
+      ),
+      children: /* @__PURE__ */ jsx10("pre", { class: "shiki incremark-code-stream", children: /* @__PURE__ */ jsx10("code", { children: /* @__PURE__ */ jsx10(For3, { each: tokens(), children: (token) => /* @__PURE__ */ jsx10("span", { style: token.htmlStyle ?? getTokenStyleObject(token), children: token.content }) }) }) })
+    }
+  );
+};
+
+// src/components/IncremarkCodeDefault.tsx
+import { jsx as jsx11, jsxs as jsxs4 } from "solid-js/jsx-runtime";
+var IncremarkCodeDefault = (props) => {
+  const [copied, setCopied] = createSignal12(false);
+  const language = () => props.node.lang || "text";
+  const code = () => props.node.value;
+  const t = useLocale();
+  const { highlighterInfo, initHighlighter } = useShiki(props.theme ?? "github-dark");
+  const [isLanguageLoaded, setIsLanguageLoaded] = createSignal12(false);
+  const shouldEnableHighlight = () => {
+    return !props.disableHighlight && code() && code().length > 0;
+  };
+  createEffect7(async () => {
+    const info = highlighterInfo();
+    const lang = language();
+    const shouldHighlight = shouldEnableHighlight();
+    if (!shouldHighlight) {
+      return;
+    }
+    if (!info) {
+      await initHighlighter();
+    } else if (lang && lang !== "text") {
+      if (!info.loadedLanguages.has(lang)) {
+        try {
+          setIsLanguageLoaded(false);
+          const supportedLangs = info.highlighter.getLoadedLanguages();
+          const bundledLangs = await import("shiki").then((m) => Object.keys(m.bundledLanguages || {}));
+          const isSupported = supportedLangs.includes(lang) || bundledLangs.includes(lang);
+          if (isSupported) {
+            await info.highlighter.loadLanguage(lang);
+            info.loadedLanguages.add(lang);
+          }
+          setIsLanguageLoaded(true);
+        } catch {
+          setIsLanguageLoaded(true);
+        }
+      } else {
+        setIsLanguageLoaded(true);
+      }
+    } else {
+      setIsLanguageLoaded(true);
+    }
+  });
+  let copyTimeoutId = null;
+  onCleanup6(() => {
+    if (copyTimeoutId) {
+      clearTimeout(copyTimeoutId);
+    }
+  });
+  async function copyCode() {
+    if (!isClipboardAvailable2()) return;
+    try {
+      await navigator.clipboard.writeText(code());
+      setCopied(true);
+      if (copyTimeoutId) {
+        clearTimeout(copyTimeoutId);
+      }
+      copyTimeoutId = setTimeout(() => {
+        setCopied(false);
+      }, 2e3);
+    } catch {
+    }
+  }
+  return /* @__PURE__ */ jsxs4("div", { class: "incremark-code", children: [
+    /* @__PURE__ */ jsxs4("div", { class: "code-header", children: [
+      /* @__PURE__ */ jsx11("span", { class: "language", children: language() }),
+      /* @__PURE__ */ jsx11(
+        "button",
+        {
+          class: "code-btn",
+          onClick: copyCode,
+          type: "button",
+          "aria-label": copied() ? t("code.copied") : t("code.copy"),
+          title: copied() ? "Copied!" : "Copy",
+          children: /* @__PURE__ */ jsx11(SvgIcon, { svg: copied() ? LucideCopyCheck2 : LucideCopy2 })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx11("div", { class: "code-content", children: /* @__PURE__ */ jsx11("div", { class: "shiki-wrapper", children: /* @__PURE__ */ jsx11(
+      Show6,
+      {
+        when: shouldEnableHighlight() && highlighterInfo() && isLanguageLoaded(),
+        fallback: (
+          // 无高亮模式（禁用高亮、无代码内容、或语言未加载完成时显示）
+          /* @__PURE__ */ jsx11("pre", { class: "code-fallback", children: /* @__PURE__ */ jsx11("code", { children: code() }) })
+        ),
+        children: /* @__PURE__ */ jsx11(
+          CachedCodeRenderer,
+          {
+            code: code(),
+            lang: language(),
+            theme: props.theme ?? "github-dark",
+            highlighter: highlighterInfo().highlighter
+          }
+        )
+      }
+    ) }) })
+  ] });
+};
+
+// src/components/IncremarkCode.tsx
+import { Fragment as Fragment3, jsx as jsx12, jsxs as jsxs5 } from "solid-js/jsx-runtime";
+var IncremarkCode = (props) => {
+  const language = () => props.node.lang || "text";
+  const CustomCodeBlock = () => props.customCodeBlocks?.[language()];
+  const shouldUseCustomCodeBlock = () => {
+    const component = props.customCodeBlocks?.[language()];
+    if (!component) return false;
+    const config = props.codeBlockConfigs?.[language()];
+    if (config?.takeOver) {
+      return true;
+    }
+    return props.blockStatus === "completed";
+  };
+  const isMermaid = () => language() === "mermaid";
+  const DefaultCodeComponent = () => props.defaultCodeComponent ?? IncremarkCodeDefault;
+  const customProps = () => ({
+    codeStr: props.node.value,
+    lang: language(),
+    completed: props.blockStatus === "completed",
+    takeOver: props.codeBlockConfigs?.[language()]?.takeOver
+  });
+  const defaultProps = () => ({
+    node: props.node,
+    theme: props.theme,
+    fallbackTheme: props.fallbackTheme,
+    disableHighlight: props.disableHighlight,
+    blockStatus: props.blockStatus
+  });
+  const mermaidProps = () => ({
+    node: props.node,
+    mermaidDelay: props.mermaidDelay
+  });
+  return /* @__PURE__ */ jsxs5(Fragment3, { children: [
+    /* @__PURE__ */ jsx12(Show7, { when: CustomCodeBlock() && shouldUseCustomCodeBlock(), children: /* @__PURE__ */ jsx12(
+      Dynamic3,
+      {
+        component: CustomCodeBlock(),
+        ...customProps()
+      }
+    ) }),
+    /* @__PURE__ */ jsx12(Show7, { when: isMermaid() && !shouldUseCustomCodeBlock(), children: /* @__PURE__ */ jsx12(
+      IncremarkCodeMermaid,
+      {
+        node: props.node,
+        mermaidDelay: props.mermaidDelay
+      }
+    ) }),
+    /* @__PURE__ */ jsx12(Show7, { when: !isMermaid() && !shouldUseCustomCodeBlock(), children: /* @__PURE__ */ jsx12(
+      Dynamic3,
+      {
+        component: DefaultCodeComponent(),
+        ...defaultProps()
+      }
+    ) })
+  ] });
+};
+var IncremarkCode_default = IncremarkCode;
+
+// src/components/IncremarkList.tsx
+import { Show as Show8, Index as Index2 } from "solid-js";
+import { jsx as jsx13, jsxs as jsxs6 } from "solid-js/jsx-runtime";
+var IncremarkList = (props) => {
+  const ordered = () => props.node.ordered;
+  const start = () => props.node.start || void 0;
+  function getItemInlineContent(item) {
+    const firstChild = item.children[0];
+    if (firstChild?.type === "paragraph") {
+      return firstChild.children;
+    }
+    return [];
+  }
+  function getItemBlockChildren(item) {
+    return item.children.filter((child, index) => {
+      if (index === 0 && child.type === "paragraph") {
+        return false;
+      }
+      return true;
+    });
+  }
+  function hasBlockChildren(item) {
+    return getItemBlockChildren(item).length > 0;
+  }
+  const hasTaskList = () => props.node.children.some((item) => item.checked !== null && item.checked !== void 0);
+  return /* @__PURE__ */ jsx13(
+    Show8,
+    {
+      when: ordered(),
+      fallback: /* @__PURE__ */ jsx13(
+        "ul",
+        {
+          class: `incremark-list${hasTaskList() ? " task-list" : ""}`,
+          children: /* @__PURE__ */ jsx13(Index2, { each: props.node.children, children: (item, index) => {
+            const itemData = item();
+            const isTaskItem = itemData.checked !== null && itemData.checked !== void 0;
+            return /* @__PURE__ */ jsxs6(
+              "li",
+              {
+                class: `incremark-list-item${isTaskItem ? " task-item" : ""}`,
+                children: [
+                  /* @__PURE__ */ jsx13(Show8, { when: isTaskItem, children: /* @__PURE__ */ jsxs6("label", { class: "task-label", children: [
+                    /* @__PURE__ */ jsx13(
+                      "input",
+                      {
+                        type: "checkbox",
+                        checked: itemData.checked ?? false,
+                        disabled: true,
+                        class: "checkbox"
+                      }
+                    ),
+                    /* @__PURE__ */ jsx13("span", { class: "task-content", children: /* @__PURE__ */ jsx13(IncremarkInline, { nodes: getItemInlineContent(itemData) }) })
+                  ] }) }),
+                  /* @__PURE__ */ jsxs6(Show8, { when: !isTaskItem, children: [
+                    /* @__PURE__ */ jsx13(IncremarkInline, { nodes: getItemInlineContent(itemData) }),
+                    /* @__PURE__ */ jsx13(Show8, { when: hasBlockChildren(itemData), children: /* @__PURE__ */ jsx13(Index2, { each: getItemBlockChildren(itemData), children: (child) => /* @__PURE__ */ jsx13(IncremarkRenderer, { node: child() }) }) })
+                  ] })
+                ]
+              }
+            );
+          } })
+        }
+      ),
+      children: /* @__PURE__ */ jsx13(
+        "ol",
+        {
+          class: `incremark-list${hasTaskList() ? " task-list" : ""}`,
+          start: start(),
+          children: /* @__PURE__ */ jsx13(Index2, { each: props.node.children, children: (item, index) => {
+            const itemData = item();
+            const isTaskItem = itemData.checked !== null && itemData.checked !== void 0;
+            return /* @__PURE__ */ jsxs6(
+              "li",
+              {
+                class: `incremark-list-item${isTaskItem ? " task-item" : ""}`,
+                children: [
+                  /* @__PURE__ */ jsx13(Show8, { when: isTaskItem, children: /* @__PURE__ */ jsxs6("label", { class: "task-label", children: [
+                    /* @__PURE__ */ jsx13(
+                      "input",
+                      {
+                        type: "checkbox",
+                        checked: itemData.checked ?? false,
+                        disabled: true,
+                        class: "checkbox"
+                      }
+                    ),
+                    /* @__PURE__ */ jsx13("span", { class: "task-content", children: /* @__PURE__ */ jsx13(IncremarkInline, { nodes: getItemInlineContent(itemData) }) })
+                  ] }) }),
+                  /* @__PURE__ */ jsxs6(Show8, { when: !isTaskItem, children: [
+                    /* @__PURE__ */ jsx13(IncremarkInline, { nodes: getItemInlineContent(itemData) }),
+                    /* @__PURE__ */ jsx13(Show8, { when: hasBlockChildren(itemData), children: /* @__PURE__ */ jsx13(Index2, { each: getItemBlockChildren(itemData), children: (child) => /* @__PURE__ */ jsx13(IncremarkRenderer, { node: child() }) }) })
+                  ] })
+                ]
+              }
+            );
+          } })
+        }
+      )
+    }
+  );
+};
+
+// src/components/IncremarkTable.tsx
+import { For as For5, Show as Show9 } from "solid-js";
+import { jsx as jsx14, jsxs as jsxs7 } from "solid-js/jsx-runtime";
+var IncremarkTable = (props) => {
+  function getCellContent(cell) {
+    return cell.children;
+  }
+  const firstRow = () => props.node.children[0];
+  const remainingRows = () => props.node.children.slice(1);
+  const getAlignClass = (cellIndex) => {
+    return `incremark-table-align-${props.node.align?.[cellIndex] || "left"}`;
+  };
+  return /* @__PURE__ */ jsx14("div", { class: "incremark-table-wrapper", children: /* @__PURE__ */ jsxs7("table", { class: "incremark-table", children: [
+    /* @__PURE__ */ jsx14(Show9, { when: firstRow(), children: /* @__PURE__ */ jsx14("thead", { children: /* @__PURE__ */ jsx14("tr", { children: /* @__PURE__ */ jsx14(For5, { each: firstRow().children, children: (cell, cellIndex) => /* @__PURE__ */ jsx14("th", { class: getAlignClass(cellIndex()), children: /* @__PURE__ */ jsx14(IncremarkInline, { nodes: getCellContent(cell) }) }) }) }) }) }),
+    /* @__PURE__ */ jsx14("tbody", { children: /* @__PURE__ */ jsx14(For5, { each: remainingRows(), children: (row) => /* @__PURE__ */ jsx14("tr", { children: /* @__PURE__ */ jsx14(For5, { each: row.children, children: (cell, cellIndex) => /* @__PURE__ */ jsx14("td", { class: getAlignClass(cellIndex()), children: /* @__PURE__ */ jsx14(IncremarkInline, { nodes: getCellContent(cell) }) }) }) }) }) })
+  ] }) });
+};
+
+// src/components/IncremarkBlockquote.tsx
+import { For as For6 } from "solid-js";
+import { jsx as jsx15 } from "solid-js/jsx-runtime";
+var IncremarkBlockquote = (props) => {
+  return /* @__PURE__ */ jsx15("blockquote", { class: "incremark-blockquote", children: /* @__PURE__ */ jsx15(For6, { each: props.node.children, children: (child) => /* @__PURE__ */ jsx15(IncremarkRenderer, { node: child }) }) });
+};
+
+// src/components/IncremarkThematicBreak.tsx
+import { jsx as jsx16 } from "solid-js/jsx-runtime";
+var IncremarkThematicBreak = () => {
+  return /* @__PURE__ */ jsx16("hr", { class: "incremark-thematic-break" });
+};
+
+// src/components/IncremarkContainer.tsx
+import { For as For7, Show as Show10 } from "solid-js";
+import { Dynamic as Dynamic4 } from "solid-js/web";
+import { jsx as jsx17 } from "solid-js/jsx-runtime";
+function parseOptions(attributes) {
+  if (!attributes) return {};
+  const options = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    try {
+      options[key] = JSON.parse(value);
+    } catch {
+      options[key] = value;
+    }
+  }
+  return options;
+}
+var IncremarkContainer = (props) => {
+  const containerName = () => props.node.name;
+  const options = () => parseOptions(props.node.attributes);
+  const CustomContainer = () => props.customContainers?.[containerName()];
+  const hasCustomContainer = () => !!props.customContainers?.[containerName()];
+  return /* @__PURE__ */ jsx17(
+    Show10,
+    {
+      when: hasCustomContainer(),
+      fallback: /* @__PURE__ */ jsx17("div", { class: `incremark-container incremark-container-${containerName()}`, children: /* @__PURE__ */ jsx17(Show10, { when: props.node.children && props.node.children.length > 0, children: /* @__PURE__ */ jsx17("div", { class: "incremark-container-content", children: /* @__PURE__ */ jsx17(For7, { each: props.node.children, children: (child) => /* @__PURE__ */ jsx17(IncremarkRenderer, { node: child }) }) }) }) }),
+      children: /* @__PURE__ */ jsx17(
+        Dynamic4,
+        {
+          component: CustomContainer(),
+          name: containerName(),
+          options: options(),
+          children: /* @__PURE__ */ jsx17(Show10, { when: props.node.children && props.node.children.length > 0, children: /* @__PURE__ */ jsx17(For7, { each: props.node.children, children: (child) => /* @__PURE__ */ jsx17(IncremarkRenderer, { node: child }) }) })
+        }
+      )
+    }
+  );
+};
+
+// src/components/IncremarkDefault.tsx
+import { jsx as jsx18 } from "solid-js/jsx-runtime";
+var IncremarkDefault = (props) => {
+  return /* @__PURE__ */ jsx18("pre", { class: "incremark-debug", children: /* @__PURE__ */ jsx18("code", { children: JSON.stringify(props.node, null, 2) }) });
+};
+
+// src/components/IncremarkRenderer.tsx
+import { Fragment as Fragment4, jsx as jsx19, jsxs as jsxs8 } from "solid-js/jsx-runtime";
+var defaultComponentMap = {
+  heading: IncremarkHeading,
+  paragraph: IncremarkParagraph,
+  code: IncremarkCode_default,
+  list: IncremarkList,
+  table: IncremarkTable,
+  blockquote: IncremarkBlockquote,
+  thematicBreak: IncremarkThematicBreak,
+  math: IncremarkMath,
+  inlineMath: IncremarkMath,
+  htmlElement: IncremarkHtmlElement,
+  containerDirective: IncremarkContainer,
+  leafDirective: IncremarkContainer,
+  textDirective: IncremarkContainer
+};
+function getComponent(type, customComponents) {
+  const map = { ...defaultComponentMap, ...customComponents };
+  return map[type] || IncremarkDefault;
+}
+function isContainerNode(node) {
+  const type = node.type;
+  return type === "containerDirective" || type === "leafDirective" || type === "textDirective";
+}
+function isHtmlNode2(node) {
+  return node.type === "html";
+}
+var IncremarkRenderer = (props) => {
+  return /* @__PURE__ */ jsxs8(Fragment4, { children: [
+    /* @__PURE__ */ jsx19(Show11, { when: isHtmlNode2(props.node), children: /* @__PURE__ */ jsx19("pre", { class: "incremark-html-code", children: /* @__PURE__ */ jsx19("code", { children: props.node.value }) }) }),
+    /* @__PURE__ */ jsx19(Show11, { when: isContainerNode(props.node) && !isHtmlNode2(props.node), children: /* @__PURE__ */ jsx19(
+      IncremarkContainer,
+      {
+        node: props.node,
+        customContainers: props.customContainers
+      }
+    ) }),
+    /* @__PURE__ */ jsx19(
+      Show11,
+      {
+        when: props.node.type === "code" && !isHtmlNode2(props.node) && !isContainerNode(props.node),
+        children: /* @__PURE__ */ jsx19(
+          IncremarkCode_default,
+          {
+            node: props.node,
+            customCodeBlocks: props.customCodeBlocks,
+            codeBlockConfigs: props.codeBlockConfigs,
+            blockStatus: props.blockStatus,
+            defaultCodeComponent: props.components?.["code"]
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx19(
+      Show11,
+      {
+        when: props.node.type !== "code" && !isHtmlNode2(props.node) && !isContainerNode(props.node),
+        children: /* @__PURE__ */ jsx19(
+          Dynamic5,
+          {
+            component: getComponent(props.node.type, props.components),
+            node: props.node
+          }
+        )
+      }
+    )
+  ] });
+};
+var IncremarkRenderer_default = IncremarkRenderer;
+
+// src/components/IncremarkFootnotes.tsx
+import { For as For8, Show as Show12 } from "solid-js";
+import { jsx as jsx20, jsxs as jsxs9 } from "solid-js/jsx-runtime";
+var IncremarkFootnotes = () => {
+  const { footnoteDefinitions, footnoteReferenceOrder } = useDefinationsContext();
+  const orderedFootnotes = () => {
+    return footnoteReferenceOrder().map((identifier) => ({
+      identifier,
+      definition: footnoteDefinitions()[identifier]
+    })).filter((item) => item.definition !== void 0);
+  };
+  const hasFootnotes = () => orderedFootnotes().length > 0;
+  return /* @__PURE__ */ jsx20(Show12, { when: hasFootnotes(), children: /* @__PURE__ */ jsxs9("section", { class: "incremark-footnotes", children: [
+    /* @__PURE__ */ jsx20("hr", { class: "incremark-footnotes-divider" }),
+    /* @__PURE__ */ jsx20("ol", { class: "incremark-footnotes-list", children: /* @__PURE__ */ jsx20(For8, { each: orderedFootnotes(), children: (item, index) => /* @__PURE__ */ jsxs9(
+      "li",
+      {
+        id: `fn-${item.identifier}`,
+        class: "incremark-footnote-item",
+        children: [
+          /* @__PURE__ */ jsxs9("div", { class: "incremark-footnote-content", children: [
+            /* @__PURE__ */ jsxs9("span", { class: "incremark-footnote-number", children: [
+              index() + 1,
+              "."
+            ] }),
+            /* @__PURE__ */ jsx20("div", { class: "incremark-footnote-body", children: /* @__PURE__ */ jsx20(For8, { each: item.definition.children, children: (child) => /* @__PURE__ */ jsx20(
+              IncremarkRenderer_default,
+              {
+                node: child
+              }
+            ) }) })
+          ] }),
+          /* @__PURE__ */ jsx20(
+            "a",
+            {
+              href: `#fnref-${item.identifier}`,
+              class: "incremark-footnote-backref",
+              "aria-label": "\u8FD4\u56DE\u5F15\u7528\u4F4D\u7F6E",
+              children: "\u21A9"
+            }
+          )
+        ]
+      }
+    ) }) })
+  ] }) });
+};
+
+// src/components/Incremark.tsx
+import { jsx as jsx21, jsxs as jsxs10 } from "solid-js/jsx-runtime";
+function IncremarkInner(props) {
+  const mergedProps = mergeProps({
+    isDisplayComplete: false,
+    pendingClass: "incremark-pending",
+    completedClass: "incremark-completed",
+    showBlockStatus: false
+  }, props);
+  const components = () => mergedProps.components || {};
+  const customContainers = () => mergedProps.customContainers || {};
+  const customCodeBlocks = () => mergedProps.customCodeBlocks || {};
+  const codeBlockConfigs = () => mergedProps.codeBlockConfigs || {};
+  const {
+    footnoteReferenceOrder
+  } = useDefinationsContext();
+  const actualBlocks = () => {
+    if (mergedProps.incremark) {
+      return mergedProps.incremark.blocks;
+    }
+    return typeof mergedProps.blocks === "function" ? mergedProps.blocks() : mergedProps.blocks;
+  };
+  const actualIsDisplayComplete = () => {
+    if (mergedProps.incremark) {
+      return mergedProps.incremark.isDisplayComplete();
+    }
+    return typeof mergedProps.isDisplayComplete === "function" ? mergedProps.isDisplayComplete() : mergedProps.isDisplayComplete;
+  };
+  return /* @__PURE__ */ jsxs10("div", { class: "incremark", children: [
+    /* @__PURE__ */ jsx21(For9, { each: actualBlocks(), children: (block) => /* @__PURE__ */ jsx21(
+      Show13,
+      {
+        when: block.node.type !== "definition" && block.node.type !== "footnoteDefinition",
+        children: /* @__PURE__ */ jsx21(
+          "div",
+          {
+            class: `incremark-block ${block.status === "completed" ? mergedProps.completedClass : mergedProps.pendingClass}${mergedProps.showBlockStatus ? " incremark-show-status" : ""}${block.isLastPending ? " incremark-last-pending" : ""}`,
+            children: /* @__PURE__ */ jsx21(
+              IncremarkRenderer_default,
+              {
+                node: block.node,
+                customContainers: customContainers(),
+                customCodeBlocks: customCodeBlocks(),
+                codeBlockConfigs: codeBlockConfigs(),
+                components: components(),
+                blockStatus: block.status
+              }
+            )
+          }
+        )
+      }
+    ) }),
+    /* @__PURE__ */ jsx21(Show13, { when: actualIsDisplayComplete() && footnoteReferenceOrder().length > 0, children: /* @__PURE__ */ jsx21(IncremarkFootnotes, {}) })
+  ] });
+}
+var Incremark = (props) => {
+  return /* @__PURE__ */ jsx21(IncremarkInner, { ...props });
+};
+var Incremark_default = Incremark;
+
+// src/components/IncremarkContent.tsx
+import { createEffect as createEffect8 } from "solid-js";
+import { jsx as jsx22 } from "solid-js/jsx-runtime";
+var IncremarkContent = (props) => {
+  const incremarkOptions = () => ({
+    gfm: true,
+    htmlTree: true,
+    containers: true,
+    math: true,
+    ...props.incremarkOptions
+  });
+  const { blocks, append, finalize, render, reset, isDisplayComplete, markdown, contextValue, DefinationsProvider: DefinationsProvider2 } = useIncremark(incremarkOptions);
+  const isStreamMode = () => typeof props.stream === "function";
+  async function handleStreamInput() {
+    if (!props.stream) return;
+    try {
+      const stream = props.stream();
+      for await (const chunk of stream) {
+        append(chunk);
+      }
+      finalize();
+    } catch (error) {
+      console.error("Stream error: ", error);
+      finalize();
+    }
+  }
+  function handleContentInput(newContent, oldContent) {
+    if (!newContent) {
+      if (oldContent) {
+        reset();
+      }
+      return;
+    }
+    if (newContent?.startsWith(oldContent ?? "")) {
+      const delta = newContent.slice((oldContent || "").length);
+      append(delta);
+    } else {
+      render(newContent);
+    }
+  }
+  createEffect8(() => {
+    const newContent = props.content;
+    if (isStreamMode()) {
+      handleStreamInput();
+    } else {
+      handleContentInput(newContent, markdown());
+    }
+  });
+  createEffect8(() => {
+    const newIsFinished = props.isFinished;
+    if (newIsFinished && props.content === markdown()) {
+      finalize();
+    }
+  });
+  return /* @__PURE__ */ jsx22(DefinationsProvider2, { value: contextValue, children: /* @__PURE__ */ jsx22(
+    Incremark_default,
+    {
+      blocks,
+      pendingClass: props.pendingClass,
+      isDisplayComplete: isDisplayComplete(),
+      showBlockStatus: props.showBlockStatus,
+      components: props.components,
+      customContainers: props.customContainers,
+      customCodeBlocks: props.customCodeBlocks,
+      codeBlockConfigs: props.codeBlockConfigs
+    }
+  ) });
+};
+
+// src/components/AutoScrollContainer.tsx
+import { createSignal as createSignal13, onCleanup as onCleanup7, onMount as onMount4 } from "solid-js";
+import { jsx as jsx23 } from "solid-js/jsx-runtime";
+var AutoScrollContainer = (props) => {
+  let containerRef;
+  const [isUserScrolledUp, setIsUserScrolledUp] = createSignal13(false);
+  let lastScrollTop = 0;
+  let lastScrollHeight = 0;
+  const enabled = () => typeof props.enabled === "function" ? props.enabled() : props.enabled ?? true;
+  const threshold = () => props.threshold ?? 50;
+  const scrollBehavior = () => props.behavior ?? "instant";
+  function isNearBottom() {
+    if (!containerRef) return true;
+    const { scrollTop, scrollHeight, clientHeight } = containerRef;
+    return scrollHeight - scrollTop - clientHeight <= threshold();
+  }
+  function scrollToBottom(force = false) {
+    if (!containerRef) return;
+    if (isUserScrolledUp() && !force) return;
+    containerRef.scrollTo({
+      top: containerRef.scrollHeight,
+      behavior: scrollBehavior()
+    });
+  }
+  function hasScrollbar() {
+    if (!containerRef) return false;
+    return containerRef.scrollHeight > containerRef.clientHeight;
+  }
+  function handleScroll() {
+    if (!containerRef) return;
+    const { scrollTop, scrollHeight, clientHeight } = containerRef;
+    if (scrollHeight <= clientHeight) {
+      setIsUserScrolledUp(false);
+      lastScrollTop = 0;
+      lastScrollHeight = scrollHeight;
+      return;
+    }
+    if (isNearBottom()) {
+      setIsUserScrolledUp(false);
+    } else {
+      const isScrollingUp = scrollTop < lastScrollTop;
+      const isContentUnchanged = scrollHeight === lastScrollHeight;
+      if (isScrollingUp && isContentUnchanged) {
+        setIsUserScrolledUp(true);
+      }
+    }
+    lastScrollTop = scrollTop;
+    lastScrollHeight = scrollHeight;
+  }
+  let observer = null;
+  onMount4(() => {
+    if (!containerRef) return;
+    lastScrollTop = containerRef.scrollTop;
+    lastScrollHeight = containerRef.scrollHeight;
+    observer = new MutationObserver(() => {
+      requestAnimationFrame(() => {
+        if (!containerRef) return;
+        if (!hasScrollbar()) {
+          setIsUserScrolledUp(false);
+        }
+        lastScrollHeight = containerRef.scrollHeight;
+        if (enabled() && !isUserScrolledUp()) {
+          scrollToBottom();
+        }
+      });
+    });
+    observer.observe(containerRef, {
+      childList: true,
+      subtree: true,
+      characterData: true
+    });
+  });
+  onCleanup7(() => {
+    observer?.disconnect();
+  });
+  return /* @__PURE__ */ jsx23(
+    "div",
+    {
+      ref: containerRef,
+      class: "auto-scroll-container",
+      onScroll: handleScroll,
+      children: props.children
+    }
+  );
+};
+
+// src/components/ThemeProvider.tsx
+import { createContext as createContext3, useContext as useContext3, createMemo as createMemo4, createSignal as createSignal14 } from "solid-js";
+import { applyTheme } from "@incremark/theme";
+import { jsx as jsx24 } from "solid-js/jsx-runtime";
+var ThemeContext = createContext3();
+var ThemeProvider = (props) => {
+  let containerRef;
+  const [theme, setTheme] = createSignal14(props.theme || "default");
+  createMemo4(() => {
+    const currentTheme = props.theme || "default";
+    setTheme(currentTheme);
+    if (typeof document !== "undefined" && containerRef) {
+      applyTheme(containerRef, currentTheme);
+    }
+  });
+  return /* @__PURE__ */ jsx24(ThemeContext.Provider, { value: { theme, setTheme }, children: /* @__PURE__ */ jsx24("div", { ref: containerRef, class: "incremark-theme-provider", children: props.children }) });
+};
+function useTheme() {
+  const context = useContext3(ThemeContext);
+  if (!context) {
+    throw new Error("useTheme must be used within a ThemeProvider");
+  }
+  return context;
+}
+
+// src/index.ts
+import {
+  BlockTransformer,
+  createBlockTransformer as createBlockTransformer3,
+  countChars,
+  sliceAst,
+  cloneNode,
+  codeBlockPlugin,
+  mermaidPlugin,
+  imagePlugin,
+  mathPlugin as mathPlugin2,
+  thematicBreakPlugin,
+  defaultPlugins as defaultPlugins2,
+  allPlugins,
+  createPlugin
+} from "@incremark/core";
+import {
+  defaultTheme,
+  darkTheme,
+  generateCSSVars,
+  mergeTheme,
+  applyTheme as applyTheme2
+} from "@incremark/theme";
+import { en as enShared, zhCN as zhCNShared } from "@incremark/shared";
+export {
+  AutoScrollContainer,
+  BlockTransformer,
+  CachedCodeRenderer,
+  ConfigProvider,
+  ConfigProvider as ConfigProviderExport,
+  Incremark,
+  IncremarkBlockquote,
+  IncremarkCode,
+  IncremarkCode_default as IncremarkCodeAlias,
+  IncremarkCodeDefault,
+  IncremarkCodeMermaid,
+  IncremarkContainer,
+  IncremarkContent,
+  IncremarkDefault,
+  IncremarkFootnotes,
+  IncremarkHeading,
+  IncremarkHtmlElement,
+  IncremarkInline,
+  IncremarkList,
+  IncremarkMath,
+  IncremarkParagraph,
+  IncremarkRenderer,
+  IncremarkTable,
+  IncremarkThematicBreak,
+  SvgIcon,
+  ThemeProvider,
+  ThemeProvider as ThemeProviderExport,
+  allPlugins,
+  applyTheme2 as applyTheme,
+  clearAnimatedChunks,
+  cloneNode,
+  codeBlockPlugin,
+  countChars,
+  createBlockTransformer3 as createBlockTransformer,
+  createPlugin,
+  darkTheme,
+  defaultPlugins2 as defaultPlugins,
+  defaultTheme,
+  enShared as en,
+  generateCSSVars,
+  imagePlugin,
+  mathPlugin2 as mathPlugin,
+  mergeTheme,
+  mermaidPlugin,
+  shouldAnimateChunk,
+  sliceAst,
+  thematicBreakPlugin,
+  useBlockTransformer,
+  useDefinationsContext,
+  useDevTools,
+  useIncremark,
+  useLocale,
+  useProvideDefinations,
+  useStreamRenderer,
+  useTheme,
+  zhCNShared as zhCN
+};
+/**
+ * @file useTypewriter Composable - 打字机效果管理
+ *
+ * @description
+ * 管理打字机效果的状态和控制逻辑。
+ *
+ * @author Incremark Team
+ * @license MIT
+ */
+/**
+ * @file Animated Chunks Tracker
+ *
+ * @description
+ * 跟踪已播放过动画的 chunk，避免重复播放动画导致闪烁
+ *
+ * @author Incremark Team
+ * @license MIT
+ */
+//# sourceMappingURL=index.js.map