@tnotesjs/ui 0.1.5 → 0.2.1

package/src/excalidraw/editorSession.ts

@@ -0,0 +1,224 @@
+/**
+ * 画布编辑会话（宿主无关）。
+ *
+ * 计划 E3 的硬约束：
+ * - 内容变化自动写盘，无保存按钮；连续变化合并（200ms）但有最大等待上限（1s），
+ *   避免一直拖动手势导致永不落盘
+ * - 写入严格有序：同一文件的写请求串行；旧完成的回调不能清掉更新的状态
+ * - 没有手动保存流程，但必须有 pending/writing/failed/conflict 状态，
+ *   失败时保留最新内存场景，不能显示成"已持久化"
+ * - 只有真正需要持久化的内容变化才触发写入（平移/缩放/选中不算）
+ */
+import { ref, type Ref } from 'vue'
+
+import { parseExcalidrawScene } from './scene'
+
+export type ExcalidrawWriteState = 'idle' | 'pending' | 'writing' | 'failed' | 'conflict'
+
+export interface ExcalidrawSaveInput {
+  content: string
+  expectedRevision: string
+}
+
+export type ExcalidrawSaveResult =
+  { ok: true; revision: string } | { ok: false; code: 'conflict' | 'error'; message: string }
+
+export interface ExcalidrawSessionOptions {
+  initialContent: string
+  initialRevision: string
+  save: (input: ExcalidrawSaveInput) => Promise<ExcalidrawSaveResult>
+  debounceMs?: number
+  maxWaitMs?: number
+}
+
+export interface ExcalidrawSession {
+  state: Ref<ExcalidrawWriteState>
+  lastError: Ref<string>
+  revision: Ref<string>
+  /** 编辑器内容变化回调（只在持久化内容真的变了时才调用） */
+  update(content: string): void
+  /** 立即写入：失去焦点、关闭入口、切换承载位置时调用 */
+  flush(): Promise<void>
+  /** 失败后重试（内容仍在内存里） */
+  retry(): Promise<void>
+  /**
+   * 把一段内容当作「已持久化」的基线：丢弃待写队列、更新 revision。
+   *
+   * 用途：编辑器首帧会把磁盘场景规范化（补齐 groupIds/roundness/gridSize 等字段），
+   * 那不是用户编辑，不能因此回写一份「规范化副本」；也可能用于放弃本地修改。
+   */
+  adopt(content: string, revision?: string): void
+  currentContent(): string
+  pendingContent(): string | null
+  hasPending(): boolean
+  dispose(): void
+}
+
+/**
+ * 只有元素 / 内嵌文件 / 与文档语义有关的 appState 才算"需要持久化"。
+ * 平移、缩放、选中、当前工具、滚动位置都属于展示状态，改了不该写盘。
+ */
+const PERSISTED_APP_STATE_KEYS = [
+  'viewBackgroundColor',
+  'gridSize',
+  'currentItemFontFamily',
+  'currentItemStrokeColor',
+  'currentItemBackgroundColor',
+  'currentItemFillStyle',
+  'currentItemStrokeWidth',
+  'currentItemRoughness',
+  'currentItemOpacity',
+  'name'
+] as const
+
+/** 提取用于比较的持久化指纹；解析失败时退回整串内容（保证坏数据也会被写回报告）。 */
+export function persistedSceneSignature(content: string): string {
+  const parsed = parseExcalidrawScene(content)
+  if (!parsed.ok) return content
+  const appState: Record<string, unknown> = {}
+  for (const key of PERSISTED_APP_STATE_KEYS) {
+    if (key in parsed.scene.appState) appState[key] = parsed.scene.appState[key]
+  }
+  return JSON.stringify({ elements: parsed.scene.elements, files: parsed.scene.files, appState })
+}
+
+export function createExcalidrawSession(options: ExcalidrawSessionOptions): ExcalidrawSession {
+  const debounceMs = options.debounceMs ?? 200
+  const maxWaitMs = options.maxWaitMs ?? 1000
+  const state = ref<ExcalidrawWriteState>('idle')
+  const lastError = ref('')
+  const revision = ref(options.initialRevision)
+
+  let savedSignature = persistedSceneSignature(options.initialContent)
+  let savedContent = options.initialContent
+  let queued: string | null = null
+  let writing = false
+  let writeAgain = false
+  let disposed = false
+  let debounceTimer: ReturnType<typeof setTimeout> | null = null
+  let maxTimer: ReturnType<typeof setTimeout> | null = null
+
+  function clearTimers(): void {
+    if (debounceTimer) clearTimeout(debounceTimer)
+    if (maxTimer) clearTimeout(maxTimer)
+    debounceTimer = null
+    maxTimer = null
+  }
+
+  function schedule(): void {
+    if (debounceTimer) clearTimeout(debounceTimer)
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null
+      void flush()
+    }, debounceMs)
+    // 最大等待：连续编辑时至少每 maxWaitMs 落盘一次
+    if (!maxTimer) {
+      maxTimer = setTimeout(() => {
+        maxTimer = null
+        void flush()
+      }, maxWaitMs)
+    }
+  }
+
+  function update(content: string): void {
+    if (disposed) return
+    const signature = persistedSceneSignature(content)
+    if (signature === savedSignature && queued === null) return // 展示状态变化，不写盘
+    queued = content
+    if (state.value !== 'writing') state.value = 'pending'
+    schedule()
+  }
+
+  async function runWrite(): Promise<void> {
+    if (writing || disposed) {
+      if (writing) writeAgain = true
+      return
+    }
+    const content = queued
+    if (content === null) return
+    if (persistedSceneSignature(content) === savedSignature) {
+      queued = null
+      state.value = 'idle'
+      return
+    }
+
+    writing = true
+    state.value = 'writing'
+    const writingSignature = persistedSceneSignature(content)
+    try {
+      const result = await options.save({ content, expectedRevision: revision.value })
+      if (disposed) return
+      if (result.ok) {
+        revision.value = result.revision
+        savedContent = content
+        savedSignature = writingSignature
+        lastError.value = ''
+        // 旧回调不能清掉更新的状态：只有当前队列就是刚写成功的内容才算干净
+        if (queued !== null && persistedSceneSignature(queued) === writingSignature) {
+          queued = null
+        }
+        state.value = queued === null ? 'idle' : 'pending'
+      } else if (result.code === 'conflict') {
+        state.value = 'conflict'
+        lastError.value = result.message
+      } else {
+        state.value = 'failed'
+        lastError.value = result.message
+      }
+    } catch (error) {
+      if (!disposed) {
+        state.value = 'failed'
+        lastError.value = error instanceof Error ? error.message : String(error)
+      }
+    } finally {
+      writing = false
+      if (writeAgain) {
+        writeAgain = false
+        void runWrite()
+      }
+    }
+  }
+
+  async function flush(): Promise<void> {
+    if (disposed) return
+    clearTimers()
+    await runWrite()
+  }
+
+  async function retry(): Promise<void> {
+    if (disposed) return
+    if (state.value === 'failed' && queued === null) queued = savedContent
+    await flush()
+  }
+
+  function adopt(content: string, nextRevision?: string): void {
+    if (disposed) return
+    clearTimers()
+    queued = null
+    savedContent = content
+    savedSignature = persistedSceneSignature(content)
+    if (nextRevision !== undefined) revision.value = nextRevision
+    lastError.value = ''
+    state.value = 'idle'
+  }
+
+  function dispose(): void {
+    disposed = true
+    clearTimers()
+    queued = null
+  }
+
+  return {
+    state,
+    lastError,
+    revision,
+    update,
+    flush,
+    retry,
+    adopt,
+    currentContent: () => queued ?? savedContent,
+    pendingContent: () => queued,
+    hasPending: () => queued !== null,
+    dispose
+  }
+}

package/src/excalidraw/exporter.ts

@@ -0,0 +1,50 @@
+/**
+ * 懒加载的导出适配：**唯一**静态引用 @excalidraw/excalidraw 的地方。
+ * 宿主（Desk 卡片 / SSG 客户端）通过动态 import 使用它，避免把编辑器打进首屏。
+ */
+import { exportToSvg } from '@excalidraw/excalidraw'
+
+import { getExcalidrawAssetPath, inlineExcalidrawFonts } from './fonts'
+
+import type { ExcalidrawScene } from './scene'
+
+export interface ExcalidrawExportOptions {
+  /** 深色主题导出；只影响显示，不修改磁盘 appState */
+  dark: boolean
+  /** 导出背景；文档自身语义优先，默认沿用场景里的 viewBackgroundColor */
+  background?: boolean
+  /** 本地字体基址；缺省用 window.EXCALIDRAW_ASSET_PATH */
+  fontBase?: string
+  /** 便于测试注入 */
+  fetchImpl?: typeof fetch
+}
+
+/**
+ * 生成自包含的 SVG 字符串。实测官方导出会内嵌 @font-face 与内联图片 data URL，
+ * 因此可以安全地作为 <img src="data:image/svg+xml…"> 渲染：没有脚本执行、
+ * 没有外部网络请求。
+ */
+export async function renderExcalidrawSvg(
+  scene: ExcalidrawScene,
+  options: ExcalidrawExportOptions
+): Promise<string> {
+  const svg = await exportToSvg({
+    elements: scene.elements as never,
+    appState: {
+      ...(scene.appState as Record<string, unknown>),
+      exportWithDarkMode: options.dark,
+      ...(options.background === undefined ? {} : { exportBackground: options.background })
+    },
+    files: (scene.files ?? {}) as never
+  })
+  // 只读路径必须自包含：把 CDN/相对字体换成 data URL，离线与 <img> 渲染才不掉字体
+  const inlined = await inlineExcalidrawFonts(svg.outerHTML, {
+    base: options.fontBase ?? getExcalidrawAssetPath(),
+    fetchImpl: options.fetchImpl
+  })
+  if (inlined.remaining.length > 0) {
+    // 不能静默：宿主据此提示「字体未内联，离线可能掉字体」
+    console.warn('[tnotes] excalidraw fonts not inlined', inlined.remaining.slice(0, 3))
+  }
+  return inlined.svg
+}

package/src/excalidraw/focus.ts

@@ -0,0 +1,33 @@
+/**
+ * 画布键盘焦点。
+ *
+ * 背景（E0/E3 实测）：Excalidraw 把键盘快捷键挂在容器上，宿主节点被搬动
+ * （卡片 → 全屏 → 标签页）之后焦点会留在触发交接的控件上，快捷键不再送达编辑器；
+ * 指针路径正常。恢复方式只有一条：blur 当前焦点 → 给交互画布补 tabindex → focus。
+ *
+ * E4 补充：标签页/分栏切回来时承载容器可能还在 `display:none` 里（组件 watcher
+ * 触发的 DOM 更新还没落地），此时 `focus()` 静默失败、焦点留在 body。
+ * 因此用 `restoreCanvasKeyboardFocusWhenReady` 等到画布真的有高度再聚焦。
+ */
+export function restoreCanvasKeyboardFocus(host: HTMLElement): boolean {
+  if (typeof document === 'undefined') return false
+  const active = document.activeElement
+  if (active instanceof HTMLElement) active.blur()
+  const canvas = host.querySelector<HTMLElement>('.excalidraw__canvas.interactive')
+  if (!canvas) return false
+  if (!canvas.hasAttribute('tabindex')) canvas.setAttribute('tabindex', '0')
+  canvas.focus()
+  return document.activeElement === canvas
+}
+
+/** 等画布真的有布局（高度 > 0）再聚焦；最多重试 30 帧。 */
+export function restoreCanvasKeyboardFocusWhenReady(host: HTMLElement, attempt = 0): void {
+  if (typeof document === 'undefined') return
+  const canvas = host.querySelector<HTMLElement>('.excalidraw__canvas.interactive')
+  const laidOut = canvas ? canvas.getBoundingClientRect().height > 0 : false
+  if (laidOut || typeof requestAnimationFrame !== 'function' || attempt >= 30) {
+    restoreCanvasKeyboardFocus(host)
+    return
+  }
+  requestAnimationFrame(() => restoreCanvasKeyboardFocusWhenReady(host, attempt + 1))
+}

package/src/excalidraw/fonts.ts

@@ -0,0 +1,92 @@
+/**
+ * 字体自包含。
+ *
+ * 背景：`@excalidraw/excalidraw` 官方 npm 包把资源基址硬编码为
+ * `https://esm.sh/@excalidraw/excalidraw@<version>/dist/prod/`（源码里的
+ * `ASSETS_FALLBACK_URL`），导出的 SVG 会引用 CDN 字体：
+ * - 离线 Desk / 离线站点会掉字体；
+ * - 用 `<img>` 渲染 SVG 时浏览器禁止加载外部资源，字体一定不生效。
+ *
+ * 因此只读路径必须把 SVG 实际引用到的字体内联成 data URL；同时用
+ * `EXCALIDRAW_ASSET_PATH` 让编辑器与导出时的文本度量走本地字体目录。
+ */
+
+export interface InlineFontsOptions {
+  /** 本地资源基址（与 window.EXCALIDRAW_ASSET_PATH 同一口径），如 '/excalidraw/' */
+  base?: string
+  /** 便于测试注入 */
+  fetchImpl?: typeof fetch
+}
+
+export interface InlineFontsResult {
+  svg: string
+  /** 成功内联的字体文件数 */
+  inlined: number
+  /** 内联失败仍是外链的 URL（调用方应记录，不能静默） */
+  remaining: string[]
+}
+
+const FONT_URL_PATTERN = /url\((?:'|")?([^'")]+\.woff2?)(?:'|")?\)/g
+
+/** 把 CDN / 相对基址统一成本地基址下的字体路径。 */
+export function resolveFontUrl(rawUrl: string, base?: string): string {
+  const fileName = rawUrl.split('/fonts/').pop() ?? rawUrl.split('/').pop() ?? rawUrl
+  if (!base) return rawUrl
+  const prefix = base.endsWith('/') ? base : `${base}/`
+  return `${prefix}fonts/${fileName}`
+}
+
+function toBase64(bytes: Uint8Array): string {
+  // 纯浏览器实现：这个包不依赖 node 类型（Buffer 在 SSG/Desk 浏览器侧不存在）
+  let binary = ''
+  const chunk = 0x8000
+  for (let offset = 0; offset < bytes.length; offset += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + chunk))
+  }
+  return btoa(binary)
+}
+
+function mimeFor(url: string): string {
+  return url.endsWith('.woff') ? 'font/woff' : 'font/woff2'
+}
+
+export async function inlineExcalidrawFonts(
+  svg: string,
+  options: InlineFontsOptions = {}
+): Promise<InlineFontsResult> {
+  const fetchImpl = options.fetchImpl ?? (typeof fetch === 'function' ? fetch : undefined)
+  const urls = [...new Set([...svg.matchAll(FONT_URL_PATTERN)].map((match) => match[1]))]
+  if (urls.length === 0) return { svg, inlined: 0, remaining: [] }
+  if (!fetchImpl) return { svg, inlined: 0, remaining: urls }
+
+  const replacements = new Map<string, string>()
+  const remaining: string[] = []
+  for (const original of urls) {
+    const target = resolveFontUrl(original, options.base)
+    try {
+      const response = await fetchImpl(target)
+      if (!response.ok) throw new Error(`HTTP ${response.status}`)
+      const bytes = new Uint8Array(await response.arrayBuffer())
+      replacements.set(original, `data:${mimeFor(target)};base64,${toBase64(bytes)}`)
+    } catch {
+      remaining.push(target)
+    }
+  }
+
+  let next = svg
+  for (const [from, to] of replacements) {
+    next = next.split(from).join(to)
+  }
+  return { svg: next, inlined: replacements.size, remaining }
+}
+
+/** 告知 Excalidraw 从本地目录取字体（离线必需）。 */
+export function setExcalidrawAssetPath(base: string): void {
+  if (typeof window === 'undefined') return
+  ;(window as { EXCALIDRAW_ASSET_PATH?: string }).EXCALIDRAW_ASSET_PATH = base
+}
+
+export function getExcalidrawAssetPath(): string | undefined {
+  if (typeof window === 'undefined') return undefined
+  return (window as { EXCALIDRAW_ASSET_PATH?: string }).EXCALIDRAW_ASSET_PATH
+}

package/src/excalidraw/renderer.ts

@@ -0,0 +1,105 @@
+/**
+ * 只读画布渲染器的纯逻辑：与 Vue 组件解耦，便于单测。
+ *
+ * 职责：解析场景 → 命中缓存或懒加载导出 → 产出可直接给 <img> 的 data URL。
+ * 不做文件写入；过期结果一律丢弃；释放时清空 data URL。
+ */
+import { ref, type Ref } from 'vue'
+
+import { parseExcalidrawScene, sceneCacheKey, svgCache, type SvgCache } from './scene'
+
+export type ExcalidrawViewState = 'idle' | 'loading' | 'ready' | 'error'
+
+export interface ExcalidrawSvgRenderer {
+  state: Ref<ExcalidrawViewState>
+  errorReason: Ref<string>
+  dataUrl: Ref<string>
+  render(): Promise<void>
+  dispose(): void
+}
+
+export interface ExcalidrawSvgRendererOptions {
+  getContent: () => string
+  /** undefined 表示跟随宿主（由组件解析 .dark 后回传） */
+  getTheme: () => 'light' | 'dark'
+  /** 引擎版本进缓存键：升级 Excalidraw 后旧缓存自动失效 */
+  engine?: string
+  cache?: SvgCache
+  /** 便于测试注入；默认动态 import 真实导出器 */
+  loadExporter?: () => Promise<{
+    renderExcalidrawSvg: (scene: unknown, options: { dark: boolean }) => Promise<string>
+  }>
+}
+
+export function toSvgDataUrl(svg: string): string {
+  // encodeURIComponent：中文文本与特殊字符在 data URL 里都安全
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`
+}
+
+export function createExcalidrawSvgRenderer(
+  options: ExcalidrawSvgRendererOptions
+): ExcalidrawSvgRenderer {
+  const state = ref<ExcalidrawViewState>('idle')
+  const errorReason = ref('')
+  const dataUrl = ref('')
+  const cache = options.cache ?? svgCache
+  const engine = options.engine ?? 'excalidraw-0.18.1'
+  const loadExporter = options.loadExporter ?? (() => import('./exporter') as Promise<never>)
+  let generation = 0
+  let disposed = false
+
+  function fail(reason: string): void {
+    state.value = 'error'
+    errorReason.value = reason
+    dataUrl.value = ''
+  }
+
+  async function render(): Promise<void> {
+    if (disposed) return
+    const current = (generation += 1)
+    const content = options.getContent()
+    const dark = options.getTheme() === 'dark'
+
+    const parsed = parseExcalidrawScene(content)
+    if (!parsed.ok) {
+      fail(parsed.reason)
+      return
+    }
+    if (parsed.scene.elements.length === 0) {
+      fail('空画布')
+      return
+    }
+
+    const key = sceneCacheKey(content, dark, engine)
+    const cached = cache.get(key)
+    if (cached !== undefined) {
+      dataUrl.value = toSvgDataUrl(cached)
+      errorReason.value = ''
+      state.value = 'ready'
+      return
+    }
+
+    state.value = 'loading'
+    try {
+      const exporter = await loadExporter()
+      const svg = await exporter.renderExcalidrawSvg(parsed.scene, { dark })
+      if (disposed || current !== generation) return // 过期结果：内容或主题已更新
+      cache.set(key, svg)
+      dataUrl.value = toSvgDataUrl(svg)
+      errorReason.value = ''
+      state.value = 'ready'
+    } catch (error) {
+      if (disposed || current !== generation) return
+      fail(error instanceof Error ? error.message : String(error))
+    }
+  }
+
+  function dispose(): void {
+    disposed = true
+    generation += 1
+    dataUrl.value = ''
+    state.value = 'idle'
+  }
+
+  return { state, errorReason, dataUrl, render, dispose }
+}

package/src/excalidraw/scene.ts

@@ -0,0 +1,93 @@
+/**
+ * 只读画布场景的解析与缓存键。
+ *
+ * 不写任何文件：只读视图只把 JSON 解析成场景，导出结果只进内存缓存。
+ */
+
+export interface ExcalidrawScene {
+  elements: unknown[]
+  appState: Record<string, unknown>
+  files: Record<string, unknown>
+}
+
+export type SceneParseResult = { ok: true; scene: ExcalidrawScene } | { ok: false; reason: string }
+
+export function parseExcalidrawScene(content: string): SceneParseResult {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(content)
+  } catch {
+    return { ok: false, reason: '画布内容不是合法 JSON' }
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return { ok: false, reason: '画布内容不是场景对象' }
+  }
+  const candidate = parsed as Partial<ExcalidrawScene> & { type?: unknown }
+  if (candidate.type !== 'excalidraw' || !Array.isArray(candidate.elements)) {
+    return { ok: false, reason: '不是 Excalidraw 场景' }
+  }
+  return {
+    ok: true,
+    scene: {
+      elements: candidate.elements,
+      appState:
+        candidate.appState && typeof candidate.appState === 'object'
+          ? (candidate.appState as Record<string, unknown>)
+          : {},
+      files:
+        candidate.files && typeof candidate.files === 'object'
+          ? (candidate.files as Record<string, unknown>)
+          : {}
+    }
+  }
+}
+
+/** FNV-1a：浏览器里不需要 node:crypto，仅用于内存缓存键。 */
+export function sceneCacheKey(content: string, dark: boolean, engine: string): string {
+  let hash = 0x811c9dc5
+  for (let index = 0; index < content.length; index += 1) {
+    hash ^= content.charCodeAt(index)
+    hash = Math.imul(hash, 0x01000193) >>> 0
+  }
+  return `${engine}:${dark ? 'dark' : 'light'}:${hash.toString(16)}:${content.length}`
+}
+
+/**
+ * 有界内存缓存：画布越大缓存越值钱，但不能无上限。
+ * 只存字符串，卸载后由组件负责释放 Blob/data URL。
+ */
+export class SvgCache {
+  private readonly entries = new Map<string, string>()
+
+  constructor(private readonly limit = 24) {}
+
+  get(key: string): string | undefined {
+    const value = this.entries.get(key)
+    if (value === undefined) return undefined
+    // 命中后移到末尾，实现 LRU 淘汰
+    this.entries.delete(key)
+    this.entries.set(key, value)
+    return value
+  }
+
+  set(key: string, value: string): void {
+    this.entries.delete(key)
+    this.entries.set(key, value)
+    while (this.entries.size > this.limit) {
+      const oldest = this.entries.keys().next().value
+      if (oldest === undefined) break
+      this.entries.delete(oldest)
+    }
+  }
+
+  clear(): void {
+    this.entries.clear()
+  }
+
+  get size(): number {
+    return this.entries.size
+  }
+}
+
+/** 模块级共享缓存：同一篇笔记的多个入口（卡片/全屏）复用同一份导出结果。 */
+export const svgCache = new SvgCache()

package/src/index.ts

@@ -1,43 +1,35 @@
-export { default as BilibiliVideo } from "./components/BilibiliVideo/BilibiliVideo.vue";
-export { default as WordList } from "./components/WordList/WordList.vue";
-export { default as Mermaid } from "./components/Mermaid/Mermaid.vue";
-export { default as Mindmap } from "./components/Mindmap/Mindmap.vue";
-export { default as FocusBreadcrumbs } from "./components/Mindmap/FocusBreadcrumbs.vue";
-export { default as NotesTable } from "./components/NotesTable/NotesTable.vue";
-export { default as Footprints } from "./components/Footprints/Footprints.vue";
+export { default as BilibiliVideo } from './components/BilibiliVideo/BilibiliVideo.vue'
+export { default as WordList } from './components/WordList/WordList.vue'
+export { default as Mermaid } from './components/Mermaid/Mermaid.vue'
+export { default as Mindmap } from './components/Mindmap/Mindmap.vue'
+export { default as FocusBreadcrumbs } from './components/Mindmap/FocusBreadcrumbs.vue'
+export { default as NotesTable } from './components/NotesTable/NotesTable.vue'
+export { default as Footprints } from './components/Footprints/Footprints.vue'
 export {
   WORD_LIST_FEATURES_FULL,
   WORD_LIST_FEATURES_STATIC,
-  resolveWordListFeatures,
-} from "./components/WordList/wordListFeatures";
-export type { WordListFeatures } from "./components/WordList/wordListFeatures";
-export {
-  normalizeMindmapMarkdown,
-  parseMindmapFence,
-  parseMindmapReference,
-} from "./components/Mindmap/markdown";
-export type {
-  MindmapFenceOptions,
-  MindmapReference,
-  NormalizeMindmapOptions,
-} from "./components/Mindmap/markdown";
-export type { NotesTableRow } from "./components/NotesTable/types";
+  resolveWordListFeatures
+} from './components/WordList/wordListFeatures'
+export type { WordListFeatures } from './components/WordList/wordListFeatures'
+export { normalizeMindmapMarkdown, parseMindmapFence } from './components/Mindmap/markdown'
+export type { MindmapFenceOptions, NormalizeMindmapOptions } from './components/Mindmap/markdown'
+export type { NotesTableRow } from './components/NotesTable/types'
 export {
   parseFootprintsSource,
   rebuildFootprintsSource,
-  parseFootprintsDatetime,
-} from "./components/Footprints/parse";
-export type { FootprintsPayload } from "./components/Footprints/parse";
-export { default as Badge } from "./components/Badge/Badge.vue";
-export { default as CodeBlock } from "./components/CodeBlock/CodeBlock.vue";
-export { default as CodeGroup } from "./components/CodeGroup/CodeGroup.vue";
-export { default as ImagePreview } from "./components/ImagePreview/ImagePreview.vue";
-export * from "./browser/clipboard";
-export * from "./browser/theme";
-export * from "./code/highlight";
+  parseFootprintsDatetime
+} from './components/Footprints/parse'
+export type { FootprintsPayload } from './components/Footprints/parse'
+export { default as Badge } from './components/Badge/Badge.vue'
+export { default as CodeBlock } from './components/CodeBlock/CodeBlock.vue'
+export { default as CodeGroup } from './components/CodeGroup/CodeGroup.vue'
+export { default as ImagePreview } from './components/ImagePreview/ImagePreview.vue'
+export * from './browser/clipboard'
+export * from './browser/theme'
+export * from './code/highlight'
 export {
   hydrateTnSwipers,
   applySwiperTabsPadding,
   createSwiperTabNav,
-  wrapSlideIndex,
-} from "./swiper/hydrate";
+  wrapSlideIndex
+} from './swiper/hydrate'