vitepress-allyouneed 0.1.0

package/dist/index.js

@@ -0,0 +1,1441 @@
+// src/core/slugify.ts
+import { slugify as mditVueSlugify } from "@mdit-vue/shared";
+function defaultSlugify(text) {
+  return mditVueSlugify(text);
+}
+var CUSTOM_ID_RE = /\s*\{#([^}\s]+)\}\s*$/;
+function extractCustomId(headingText) {
+  const m = headingText.match(CUSTOM_ID_RE);
+  if (!m) return { text: headingText, customId: void 0 };
+  return {
+    text: headingText.replace(CUSTOM_ID_RE, ""),
+    customId: m[1]
+  };
+}
+
+// src/core/config-bridge.ts
+var DEFAULT_ASSET_EXTENSIONS = [
+  // 位图
+  "bmp",
+  "gif",
+  "jpeg",
+  "jpg",
+  "png",
+  "svg",
+  "webp",
+  "avif",
+  "ico",
+  // 视频
+  "mp4",
+  "webm",
+  "mov",
+  "m4v",
+  // 音频
+  "mp3",
+  "wav",
+  "ogg",
+  "m4a",
+  "flac",
+  // 文档
+  "pdf",
+  // Obsidian 专属
+  "canvas",
+  "excalidraw"
+];
+var DEFAULT_IMAGE_EXTENSIONS = [
+  "bmp",
+  "gif",
+  "jpeg",
+  "jpg",
+  "png",
+  "svg",
+  "webp",
+  "avif",
+  "ico"
+];
+function resolveOptions(user = {}, ctx = {}) {
+  const srcDir = user.srcDir ?? ctx.srcDir ?? process.cwd();
+  let base = user.base ?? ctx.base ?? "/";
+  if (!base.startsWith("/")) base = "/" + base;
+  if (!base.endsWith("/")) base = base + "/";
+  const cleanUrls = user.cleanUrls ?? ctx.cleanUrls ?? false;
+  const slugify = user.slugify ?? ctx.externalSlugify ?? defaultSlugify;
+  const wikilinksUser = user.wikilinks ?? {};
+  const embedsUser = user.embeds ?? {};
+  const scanUser = user.scan ?? {};
+  const assetsUser = user.assets ?? {};
+  const modulesUser = user.modules ?? {};
+  const wikilinksHtmlAttrs = wikilinksUser.htmlAttributes ?? {};
+  const embedsHtmlAttrs = embedsUser.htmlAttributes ?? {};
+  return {
+    srcDir,
+    base,
+    cleanUrls,
+    caseSensitive: user.caseSensitive ?? false,
+    deadLink: user.deadLink ?? "warn",
+    onConflict: user.onConflict ?? "shortest",
+    onAliasConflict: user.onAliasConflict ?? "first",
+    scan: {
+      include: scanUser.include ?? ["**/*.md", "**/*.markdown"],
+      exclude: scanUser.exclude ?? [],
+      followSymlinks: scanUser.followSymlinks ?? false,
+      respectGitignore: scanUser.respectGitignore ?? true,
+      assetExtensions: scanUser.assetExtensions ?? DEFAULT_ASSET_EXTENSIONS
+    },
+    assets: {
+      mode: assetsUser.mode ?? "auto",
+      preserveAssetPaths: assetsUser.preserveAssetPaths ?? false,
+      outputDir: assetsUser.outputDir ?? "_assets"
+    },
+    wikilinks: {
+      postProcessLinkTarget: wikilinksUser.postProcessLinkTarget ?? ((t) => t.trim()),
+      postProcessLinkLabel: wikilinksUser.postProcessLinkLabel ?? ((l) => l.trim()),
+      allowLinkLabelFormatting: wikilinksUser.allowLinkLabelFormatting ?? false,
+      linkText: wikilinksUser.linkText ?? "basename",
+      htmlAttributes: wikilinksHtmlAttrs
+    },
+    embeds: {
+      imageFileExt: embedsUser.imageFileExt ?? DEFAULT_IMAGE_EXTENSIONS,
+      defaultAltText: embedsUser.defaultAltText ?? false,
+      postProcessImageTarget: embedsUser.postProcessImageTarget ?? ((t) => t.trim()),
+      postProcessAltText: embedsUser.postProcessAltText ?? ((a) => a.trim()),
+      uriSuffix: embedsUser.uriSuffix ?? "",
+      transclusionMaxDepth: embedsUser.transclusionMaxDepth ?? 8,
+      htmlAttributes: embedsHtmlAttrs
+    },
+    modules: {
+      wikilinks: modulesUser.wikilinks ?? true,
+      embeds: modulesUser.embeds ?? true
+    },
+    slugify
+  };
+}
+
+// src/core/vault/index.ts
+import fs3 from "fs";
+import nodePath4 from "path";
+
+// src/utils/path.ts
+import nodePath from "path";
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function relative(from, to) {
+  return toPosix(nodePath.relative(from, to));
+}
+function stripMarkdownExt(target) {
+  return target.replace(/\.(md|markdown)$/i, "");
+}
+function basename(p, stripExt = false) {
+  const idx = p.lastIndexOf("/");
+  const file = idx === -1 ? p : p.slice(idx + 1);
+  if (!stripExt) return file;
+  const dot = file.lastIndexOf(".");
+  return dot <= 0 ? file : file.slice(0, dot);
+}
+function extname(p) {
+  const file = basename(p);
+  const dot = file.lastIndexOf(".");
+  if (dot <= 0) return "";
+  return file.slice(dot + 1).toLowerCase();
+}
+function splitPath(p) {
+  return toPosix(p).split("/").filter(Boolean);
+}
+function pathDepth(relPath) {
+  return splitPath(relPath).length;
+}
+
+// src/utils/url.ts
+function encodePath(s) {
+  return encodeURI(s);
+}
+function buildUrl(base, pathSegments, anchor) {
+  let normBase = base || "/";
+  if (!normBase.startsWith("/")) normBase = "/" + normBase;
+  if (!normBase.endsWith("/")) normBase = normBase + "/";
+  const joined = pathSegments.map((s) => s.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+  let url = normBase + joined;
+  url = url.replace(/\/{2,}/g, "/");
+  url = encodePath(url);
+  if (anchor) {
+    url += "#" + encodeURIComponent(anchor).replace(/%2F/g, "/");
+  }
+  return url;
+}
+function applyCleanUrls(path, cleanUrls) {
+  if (cleanUrls) return path;
+  if (/\.html$/i.test(path)) return path;
+  if (path.endsWith("/")) return path + "index.html";
+  return path + ".html";
+}
+
+// src/core/vault/scan.ts
+import fs from "fs";
+import nodePath2 from "path";
+function walk(srcDir, isIgnored, followSymlinks) {
+  const out = [];
+  const seenInodes = /* @__PURE__ */ new Set();
+  function visit(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = nodePath2.join(dir, ent.name);
+      const posix = toPosix(full);
+      if (isIgnored(posix)) continue;
+      let isDir = ent.isDirectory();
+      let isFile = ent.isFile();
+      if (ent.isSymbolicLink()) {
+        if (!followSymlinks) continue;
+        try {
+          const stat = fs.statSync(full);
+          isDir = stat.isDirectory();
+          isFile = stat.isFile();
+        } catch {
+          continue;
+        }
+      }
+      if (isDir) {
+        if (followSymlinks) {
+          try {
+            const stat = fs.statSync(full);
+            const key = `${stat.dev}:${stat.ino}`;
+            if (seenInodes.has(key)) continue;
+            seenInodes.add(key);
+          } catch {
+            continue;
+          }
+        }
+        visit(full);
+      } else if (isFile) {
+        try {
+          const stat = fs.statSync(full);
+          out.push({
+            absolutePath: posix,
+            size: stat.size,
+            mtime: stat.mtimeMs,
+            extension: extname(posix)
+          });
+        } catch {
+        }
+      }
+    }
+  }
+  visit(srcDir);
+  return out;
+}
+
+// src/core/vault/ignore.ts
+import fs2 from "fs";
+import nodePath3 from "path";
+import picomatch from "picomatch";
+var HARD_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  ".obsidian",
+  ".trash",
+  ".vitepress",
+  ".next",
+  ".nuxt",
+  ".cache",
+  ".idea",
+  ".vscode",
+  "dist",
+  "build"
+]);
+function buildIgnorer(srcDir, userExclude, respectGitignore) {
+  const patterns = [...userExclude];
+  if (respectGitignore) {
+    const gitignore = nodePath3.join(srcDir, ".gitignore");
+    try {
+      const content = fs2.readFileSync(gitignore, "utf8");
+      for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        patterns.push(trimmed.endsWith("/") ? trimmed + "**" : trimmed);
+      }
+    } catch {
+    }
+  }
+  const matchers = patterns.map(
+    (p) => picomatch(p, { dot: true, nocase: false })
+  );
+  return (absPath) => {
+    const rel = toPosix(relative(srcDir, absPath));
+    if (!rel || rel.startsWith("..")) return true;
+    for (const seg of rel.split("/")) {
+      if (HARD_IGNORE_DIRS.has(seg)) return true;
+    }
+    for (const m of matchers) {
+      if (m(rel)) return true;
+    }
+    return false;
+  };
+}
+
+// src/core/vault/frontmatter.ts
+import matter from "gray-matter";
+function parseFrontmatter(raw) {
+  try {
+    const { data, content } = matter(raw);
+    return { data: data ?? {}, content };
+  } catch (err) {
+    return {
+      data: {},
+      content: raw,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function normalizeAliases(raw) {
+  if (raw == null) return [];
+  if (typeof raw === "string") return raw.trim() ? [raw.trim()] : [];
+  if (Array.isArray(raw)) {
+    return raw.filter((v) => typeof v === "string").map((s) => s.trim()).filter(Boolean);
+  }
+  return [];
+}
+function normalizeTags(raw) {
+  if (raw == null) return [];
+  if (typeof raw === "string") {
+    return raw.split(/[,\s]+/).map((s) => s.trim().replace(/^#/, "")).filter(Boolean);
+  }
+  if (Array.isArray(raw)) {
+    return raw.filter((v) => typeof v === "string").map((s) => s.trim().replace(/^#/, "")).filter(Boolean);
+  }
+  return [];
+}
+
+// src/core/vault/headings.ts
+var HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
+var FENCE_RE = /^(`{3,}|~{3,})/;
+function collectHeadings(content, slugify) {
+  const lines = content.split(/\r?\n/);
+  const out = [];
+  let inFence = false;
+  let fenceMarker = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const fenceMatch = line.match(FENCE_RE);
+    if (fenceMatch) {
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = fenceMatch[1];
+      } else if (line.startsWith(fenceMarker)) {
+        inFence = false;
+        fenceMarker = "";
+      }
+      continue;
+    }
+    if (inFence) continue;
+    const m = line.match(HEADING_RE);
+    if (!m) continue;
+    const level = m[1].length;
+    const rawText = m[2];
+    const { text, customId } = extractCustomId(rawText);
+    const slug = customId ?? slugify(text);
+    out.push({ level, text, slug, line: i });
+  }
+  return out;
+}
+
+// src/core/vault/index.ts
+var MD_EXTENSIONS = /* @__PURE__ */ new Set(["md", "markdown"]);
+function createEmptyIndex(srcDir = "", base = "/", cleanUrls = false) {
+  return {
+    files: /* @__PURE__ */ new Map(),
+    assets: /* @__PURE__ */ new Map(),
+    byBasename: /* @__PURE__ */ new Map(),
+    byBasenameLower: /* @__PURE__ */ new Map(),
+    byAlias: /* @__PURE__ */ new Map(),
+    byRelativePath: /* @__PURE__ */ new Map(),
+    byUrl: /* @__PURE__ */ new Map(),
+    assetsByBasename: /* @__PURE__ */ new Map(),
+    assetsByBasenameLower: /* @__PURE__ */ new Map(),
+    assetsByRelativePath: /* @__PURE__ */ new Map(),
+    tags: /* @__PURE__ */ new Map(),
+    backlinks: /* @__PURE__ */ new Map(),
+    headings: /* @__PURE__ */ new Map(),
+    srcDir,
+    base,
+    cleanUrls,
+    scannedAt: Date.now(),
+    warnings: []
+  };
+}
+function scanVault(options) {
+  const srcDir = toPosix(nodePath4.resolve(options.srcDir));
+  const index = createEmptyIndex(srcDir, options.base, options.cleanUrls);
+  const isIgnored = buildIgnorer(
+    srcDir,
+    options.scan.exclude,
+    options.scan.respectGitignore
+  );
+  const assetExtSet = new Set(
+    options.scan.assetExtensions.map((e) => e.toLowerCase())
+  );
+  const entries = walk(srcDir, isIgnored, options.scan.followSymlinks);
+  for (const ent of entries) {
+    const ext = ent.extension;
+    if (MD_EXTENSIONS.has(ext)) {
+      ingestMarkdown(index, ent.absolutePath, ent.size, ent.mtime, options);
+    } else if (assetExtSet.has(ext)) {
+      ingestAsset(index, ent.absolutePath, ent.size, ent.mtime, ext);
+    }
+  }
+  index.scannedAt = Date.now();
+  return index;
+}
+function ingestMarkdown(index, absPath, size, mtime, options) {
+  let raw;
+  try {
+    raw = fs3.readFileSync(absPath, "utf8");
+  } catch (err) {
+    index.warnings.push({
+      kind: "unreadable-file",
+      message: `\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6: ${absPath} (${err instanceof Error ? err.message : String(err)})`,
+      affected: [absPath]
+    });
+    return;
+  }
+  const { data, content, error } = parseFrontmatter(raw);
+  if (error) {
+    index.warnings.push({
+      kind: "invalid-frontmatter",
+      message: `frontmatter \u89E3\u6790\u5931\u8D25 (${absPath}): ${error}`,
+      affected: [absPath]
+    });
+  }
+  const aliases = normalizeAliases(data.aliases);
+  const tags = normalizeTags(data.tags);
+  const headings = collectHeadings(content, options.slugify);
+  const rel = relative(index.srcDir, absPath);
+  const base = basename(absPath, true);
+  const ext = extname(absPath);
+  const url = computeUrl(rel, options);
+  const entry = {
+    absolutePath: absPath,
+    relativePath: rel,
+    basename: base,
+    extension: ext,
+    url,
+    frontmatter: data,
+    aliases,
+    tags,
+    headings,
+    mtime,
+    size,
+    content
+  };
+  registerFileEntry(index, entry, options);
+}
+function ingestAsset(index, absPath, size, mtime, ext) {
+  const rel = relative(index.srcDir, absPath);
+  const base = basename(absPath);
+  const entry = {
+    absolutePath: absPath,
+    relativePath: rel,
+    basename: base,
+    extension: ext,
+    mtime,
+    size,
+    referencedBy: /* @__PURE__ */ new Set()
+  };
+  index.assets.set(absPath, entry);
+  index.assetsByRelativePath.set(rel, entry);
+  pushToArrayMap(index.assetsByBasename, base, entry);
+  pushToArrayMap(index.assetsByBasenameLower, base.toLowerCase(), entry);
+}
+function registerFileEntry(index, entry, options) {
+  index.files.set(entry.absolutePath, entry);
+  index.byRelativePath.set(entry.relativePath, entry);
+  const existingAtUrl = index.byUrl.get(entry.url);
+  if (existingAtUrl && existingAtUrl.absolutePath !== entry.absolutePath) {
+    index.warnings.push({
+      kind: "unknown",
+      message: `URL \u51B2\u7A81:\u6587\u4EF6 "${entry.relativePath}" \u548C "${existingAtUrl.relativePath}" \u90FD\u8DEF\u7531\u5230 "${entry.url}"\u3002VitePress \u4F1A\u8BA9\u5176\u4E2D\u4E00\u4E2A 404\u3002\u5EFA\u8BAE\u5728 .vitepress/config \u52A0 srcExclude: ['${entry.relativePath}'](\u6216\u53E6\u4E00\u4E2A)\u3002`,
+      affected: [existingAtUrl.absolutePath, entry.absolutePath]
+    });
+  }
+  index.byUrl.set(entry.url, entry);
+  index.headings.set(entry.absolutePath, entry.headings);
+  pushToArrayMap(index.byBasename, entry.basename, entry);
+  pushToArrayMap(index.byBasenameLower, entry.basename.toLowerCase(), entry);
+  for (const alias of entry.aliases) {
+    const key = options.caseSensitive ? alias : alias.toLowerCase();
+    if (index.byAlias.has(key)) {
+      index.warnings.push({
+        kind: "duplicate-alias",
+        message: `alias "${alias}" \u540C\u65F6\u88AB\u591A\u4E2A\u6587\u4EF6\u58F0\u660E,\u6309 onAliasConflict='${options.onAliasConflict}' \u5904\u7406`,
+        affected: [index.byAlias.get(key).absolutePath, entry.absolutePath]
+      });
+      if (options.onAliasConflict === "first") continue;
+    }
+    index.byAlias.set(key, entry);
+  }
+  for (const tag of entry.tags) {
+    pushToArrayMap(index.tags, tag, entry);
+  }
+}
+function computeUrl(rel, options) {
+  const noExt = rel.replace(/\.(md|markdown)$/i, "");
+  const isIndex = /(^|\/)(index|README)$/i.test(noExt);
+  const pathPart = isIndex ? noExt.replace(/(^|\/)(index|README)$/i, "$1") : noExt;
+  const segments = pathPart.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return options.base;
+  }
+  const last = segments[segments.length - 1];
+  if (!isIndex) {
+    segments[segments.length - 1] = applyCleanUrls(last, options.cleanUrls);
+  } else if (!options.cleanUrls) {
+    segments.push("index.html");
+  }
+  return buildUrl(options.base, segments);
+}
+function pushToArrayMap(m, k, v) {
+  const arr = m.get(k);
+  if (arr) arr.push(v);
+  else m.set(k, [v]);
+}
+function updateFile(index, absPath, options) {
+  const posix = toPosix(absPath);
+  removeFile(index, posix, options);
+  let stat;
+  try {
+    stat = fs3.statSync(posix);
+  } catch {
+    return;
+  }
+  const ext = extname(posix);
+  if (MD_EXTENSIONS.has(ext)) {
+    ingestMarkdown(index, posix, stat.size, stat.mtimeMs, options);
+  } else if (new Set(options.scan.assetExtensions.map((e) => e.toLowerCase())).has(ext)) {
+    ingestAsset(index, posix, stat.size, stat.mtimeMs, ext);
+  }
+}
+function removeFile(index, absPath, options) {
+  const posix = toPosix(absPath);
+  const file = index.files.get(posix);
+  if (file) {
+    index.files.delete(posix);
+    index.byRelativePath.delete(file.relativePath);
+    index.byUrl.delete(file.url);
+    index.headings.delete(posix);
+    removeFromArrayMap(index.byBasename, file.basename, file);
+    removeFromArrayMap(
+      index.byBasenameLower,
+      file.basename.toLowerCase(),
+      file
+    );
+    for (const alias of file.aliases) {
+      const key = options.caseSensitive ? alias : alias.toLowerCase();
+      if (index.byAlias.get(key) === file) index.byAlias.delete(key);
+    }
+    for (const tag of file.tags) {
+      removeFromArrayMap(index.tags, tag, file);
+    }
+    return;
+  }
+  const asset = index.assets.get(posix);
+  if (asset) {
+    index.assets.delete(posix);
+    index.assetsByRelativePath.delete(asset.relativePath);
+    removeFromArrayMap(index.assetsByBasename, asset.basename, asset);
+    removeFromArrayMap(
+      index.assetsByBasenameLower,
+      asset.basename.toLowerCase(),
+      asset
+    );
+  }
+}
+function removeFromArrayMap(m, k, v) {
+  const arr = m.get(k);
+  if (!arr) return;
+  const idx = arr.indexOf(v);
+  if (idx >= 0) arr.splice(idx, 1);
+  if (arr.length === 0) m.delete(k);
+}
+function sortByShortestPath(items) {
+  return [...items].sort((a, b) => {
+    const da = pathDepth(a.relativePath);
+    const db = pathDepth(b.relativePath);
+    if (da !== db) return da - db;
+    return a.relativePath.localeCompare(b.relativePath);
+  });
+}
+
+// src/core/resolver.ts
+function resolveWikilink(rawTarget, index, options, kind = "page") {
+  let target = toPosix(rawTarget).trim();
+  const hashIdx = target.indexOf("#");
+  let headingPart = "";
+  if (hashIdx >= 0) {
+    headingPart = target.slice(hashIdx + 1).trim();
+    target = target.slice(0, hashIdx).trim();
+  }
+  target = stripMarkdownExt(target);
+  const entry = lookupEntry(target, index, options);
+  if (!entry) {
+    return {
+      url: buildDeadUrl(rawTarget, options),
+      defaultLabel: defaultLabel(target, headingPart, void 0, options),
+      isDead: true,
+      hasUnmatchedAnchor: false,
+      kind
+    };
+  }
+  let url = entry.url;
+  let hasUnmatchedAnchor = false;
+  if (headingPart) {
+    const heading = entry.headings.find(
+      (h) => h.text === headingPart || h.slug === headingPart || h.slug === options.slugify(headingPart)
+    );
+    if (heading) {
+      url = entry.url + "#" + heading.slug;
+    } else {
+      hasUnmatchedAnchor = true;
+      url = entry.url + "#" + encodeURIComponent(headingPart);
+    }
+  }
+  return {
+    url,
+    defaultLabel: defaultLabel(target, headingPart, entry, options),
+    isDead: false,
+    hasUnmatchedAnchor,
+    target: entry,
+    kind
+  };
+}
+function lookupEntry(target, index, options) {
+  if (!target) return void 0;
+  if (target.includes("/")) {
+    const variants = [
+      target,
+      target + ".md",
+      target + ".markdown",
+      target + "/index.md",
+      target + "/index.markdown"
+    ];
+    for (const v of variants) {
+      const e = index.byRelativePath.get(v);
+      if (e) return e;
+    }
+    return void 0;
+  }
+  const aliasKey = options.caseSensitive ? target : target.toLowerCase();
+  const aliased = index.byAlias.get(aliasKey);
+  if (aliased) return aliased;
+  const bnMap = options.caseSensitive ? index.byBasename : index.byBasenameLower;
+  const bnKey = options.caseSensitive ? target : target.toLowerCase();
+  const candidates = bnMap.get(bnKey);
+  if (!candidates || candidates.length === 0) return void 0;
+  if (candidates.length === 1) return candidates[0];
+  switch (options.onConflict) {
+    case "shortest": {
+      const sorted = sortByShortestPath(candidates);
+      return sorted[0];
+    }
+    case "first":
+      return candidates[0];
+    case "error":
+      return void 0;
+  }
+}
+function buildDeadUrl(rawTarget, options) {
+  const safe = encodeURIComponent(stripMarkdownExt(rawTarget).split("#")[0]);
+  return options.base + safe;
+}
+function defaultLabel(target, headingPart, entry, options) {
+  const lt = options.wikilinks.linkText;
+  let base;
+  if (typeof lt === "function") {
+    if (entry) {
+      base = lt(entry, target);
+    } else {
+      base = basename(target);
+    }
+  } else if (lt === "fullPath") {
+    base = entry ? entry.relativePath.replace(/\.(md|markdown)$/i, "") : target;
+  } else {
+    base = entry ? entry.basename : basename(target);
+  }
+  if (headingPart) {
+    return `${base} > ${headingPart}`;
+  }
+  return base;
+}
+function resolveAsset(rawTarget, index, options) {
+  const target = toPosix(rawTarget).trim();
+  if (target.includes("/")) {
+    return {
+      asset: index.assetsByRelativePath.get(target),
+      rawBasename: basename(target)
+    };
+  }
+  const bn = options.caseSensitive ? target : target.toLowerCase();
+  const map = options.caseSensitive ? index.assetsByBasename : index.assetsByBasenameLower;
+  const candidates = map.get(bn);
+  if (!candidates || candidates.length === 0) {
+    return { asset: void 0, rawBasename: target };
+  }
+  if (candidates.length === 1) {
+    return { asset: candidates[0], rawBasename: target };
+  }
+  switch (options.onConflict) {
+    case "shortest": {
+      const sorted = sortByShortestPath(candidates);
+      return { asset: sorted[0], rawBasename: target };
+    }
+    case "first":
+      return { asset: candidates[0], rawBasename: target };
+    case "error":
+      return { asset: void 0, rawBasename: target };
+  }
+}
+
+// src/modules/wikilinks/render.ts
+function renderPageLink(state, result, label, env) {
+  const open = state.push("link_open", "a", 1);
+  const classes = ["wikilink"];
+  if (result.hasUnmatchedAnchor) classes.push("wikilink--unmatched-anchor");
+  const baseAttrs = {
+    href: result.url,
+    class: classes.join(" "),
+    "data-wikilink-target": result.target ? result.target.relativePath : ""
+  };
+  const extra = resolveExtraAttrs(env.options.wikilinks.htmlAttributes, {
+    originalHref: result.url,
+    label,
+    target: result.target,
+    isDead: result.isDead,
+    hasUnmatchedAnchor: result.hasUnmatchedAnchor
+  });
+  applyAttrs(open, baseAttrs, extra);
+  emitLabel(state, label, env);
+  state.push("link_close", "a", -1);
+  return true;
+}
+function renderDeadLink(state, url, label, rawTarget, env) {
+  const open = state.push("link_open", "a", 1);
+  const baseAttrs = {
+    href: url,
+    class: "wikilink wikilink--dead",
+    "data-wikilink-target": rawTarget,
+    title: `\u6B7B\u94FE:\u627E\u4E0D\u5230 [[${rawTarget}]]`
+  };
+  const extra = resolveExtraAttrs(env.options.wikilinks.htmlAttributes, {
+    originalHref: url,
+    label,
+    target: void 0,
+    isDead: true,
+    hasUnmatchedAnchor: false
+  });
+  applyAttrs(open, baseAttrs, extra);
+  emitLabel(state, label, env);
+  state.push("link_close", "a", -1);
+  return true;
+}
+function emitLabel(state, label, env) {
+  if (env.options.wikilinks.allowLinkLabelFormatting) {
+    const depth = env._labelDepth ?? 0;
+    if (depth < 3) {
+      ;
+      env._labelDepth = depth + 1;
+      const md = state.md;
+      const html = md.renderInline(label, env);
+      const token = state.push("html_inline", "", 0);
+      token.content = html;
+      env._labelDepth = depth;
+      return;
+    }
+  }
+  const t = state.push("text", "", 0);
+  t.content = label;
+}
+function resolveExtraAttrs(htmlAttrs, ctx) {
+  if (typeof htmlAttrs === "function") return htmlAttrs(ctx);
+  return htmlAttrs ?? {};
+}
+function applyAttrs(token, base, extra) {
+  const merged = { ...base };
+  for (const [k, v] of Object.entries(extra)) {
+    if (k === "class" && merged.class) {
+      merged.class = merged.class + " " + v;
+    } else {
+      merged[k] = v;
+    }
+  }
+  for (const [k, v] of Object.entries(merged)) {
+    token.attrSet(k, v);
+  }
+}
+
+// src/utils/escape.ts
+var HTML_ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var HTML_ESCAPE_RE = /[&<>"']/g;
+function escapeHtml(s) {
+  return s.replace(HTML_ESCAPE_RE, (c) => HTML_ESCAPE_MAP[c]);
+}
+
+// src/core/asset-pipeline/build-emit.ts
+var ASSET_PLACEHOLDER_PREFIX = "/__ayn_asset__/";
+function buildPlaceholderUrl(asset, options) {
+  const id = encodeURI(asset.relativePath);
+  return options.base + ASSET_PLACEHOLDER_PREFIX.slice(1) + id;
+}
+
+// src/modules/embeds/image.ts
+function renderImageHtml(rawTarget, aliasParts, env) {
+  const { index, options } = env;
+  const { altText, dim } = parseAltAndDim(aliasParts);
+  const processedTarget = options.embeds.postProcessImageTarget(rawTarget);
+  const { asset } = resolveAsset(processedTarget, index, options);
+  let src;
+  if (asset) {
+    asset.referencedBy.add(env.currentPath ?? "<unknown>");
+    env.referencedAssets?.add(asset);
+    src = buildPlaceholderUrl(asset, options) + options.embeds.uriSuffix;
+  } else {
+    src = options.base + encodeURIComponent(basename(processedTarget)) + options.embeds.uriSuffix;
+  }
+  const finalAlt = determineAlt(altText, processedTarget, options);
+  const attrs = {
+    src,
+    alt: finalAlt ?? ""
+  };
+  if (dim.width !== void 0) attrs.width = String(dim.width);
+  if (dim.height !== void 0) attrs.height = String(dim.height);
+  const extra = resolveExtra(options.embeds.htmlAttributes, {
+    originalHref: src,
+    altText: finalAlt,
+    dimensions: dim.raw,
+    embedType: "image"
+  });
+  for (const [k, v] of Object.entries(extra)) {
+    if (k === "class" && attrs.class) {
+      attrs.class = attrs.class + " " + v;
+    } else {
+      attrs[k] = v;
+    }
+  }
+  return "<img " + Object.entries(attrs).map(([k, v]) => `${escapeAttrName(k)}="${escapeHtml(v)}"`).join(" ") + " />";
+}
+function handleImageEmbed(state, rawTarget, aliasParts, env) {
+  const html = renderImageHtml(rawTarget, aliasParts, env);
+  const token = state.push("html_inline", "", 0);
+  token.content = html;
+  return true;
+}
+function parseAltAndDim(parts) {
+  if (parts.length === 0) return { altText: "", dim: { raw: "" } };
+  const last = parts[parts.length - 1];
+  const parsedLast = tryParseDimension(last);
+  if (parsedLast) {
+    const alt = parts.slice(0, -1).join("|").trim();
+    return { altText: alt, dim: { ...parsedLast, raw: last } };
+  }
+  return { altText: parts.join("|").trim(), dim: { raw: "" } };
+}
+function tryParseDimension(s) {
+  const trimmed = s.trim().toLowerCase();
+  if (!trimmed) return void 0;
+  if (trimmed.includes("x")) {
+    const [w, h] = trimmed.split("x");
+    const wOk = w === "" || /^\d+$/.test(w);
+    const hOk = h === "" || /^\d+$/.test(h);
+    if (!wOk || !hOk) return void 0;
+    if (w === "" && h === "") return void 0;
+    return {
+      width: w === "" ? void 0 : Number(w),
+      height: h === "" ? void 0 : Number(h)
+    };
+  }
+  if (/^\d+$/.test(trimmed)) {
+    return { width: Number(trimmed) };
+  }
+  return void 0;
+}
+function determineAlt(rawAlt, target, options) {
+  if (rawAlt && rawAlt !== "") {
+    return options.embeds.postProcessAltText(rawAlt);
+  }
+  const def = options.embeds.defaultAltText;
+  if (def === false) return void 0;
+  if (def === true) {
+    const bn = basename(target);
+    const dot = bn.lastIndexOf(".");
+    const noExt = dot > 0 ? bn.slice(0, dot) : bn;
+    return options.embeds.postProcessAltText(noExt);
+  }
+  if (typeof def === "string") {
+    return def === "" ? "" : options.embeds.postProcessAltText(def);
+  }
+  return options.embeds.postProcessAltText(basename(target));
+}
+function resolveExtra(attrs, ctx) {
+  if (typeof attrs === "function") return attrs(ctx);
+  return attrs ?? {};
+}
+function escapeAttrName(k) {
+  return k.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+
+// src/modules/embeds/transclusion.ts
+function renderTransclusionHtml(md, rawTarget, aliasParts, env) {
+  const { index, options } = env;
+  const result = resolveWikilink(rawTarget, index, options, "transclusion");
+  if (result.isDead || !result.target) {
+    return `<div class="transclusion transclusion--dead" data-target="${escapeHtml(
+      rawTarget
+    )}">\u26A0\uFE0F \u627E\u4E0D\u5230\u7B14\u8BB0 <code>${escapeHtml(rawTarget)}</code></div>`;
+  }
+  const target = result.target;
+  const arr = index.backlinks.get(target.absolutePath) ?? [];
+  if (env.currentPath) {
+    arr.push({
+      fromPath: env.currentPath,
+      fromUrl: index.files.get(env.currentPath)?.url ?? "",
+      context: "",
+      isEmbed: true,
+      line: -1
+    });
+  }
+  index.backlinks.set(target.absolutePath, arr);
+  const stack = env.transclusionStack ?? [];
+  if (stack.includes(target.absolutePath)) {
+    return `<div class="transclusion transclusion--cycle" data-target="${escapeHtml(
+      rawTarget
+    )}">\u26A0\uFE0F \u5FAA\u73AF\u5F15\u7528:<code>${escapeHtml(
+      rawTarget
+    )}</code> \u5DF2\u5728 transclusion \u94FE\u4E0A</div>`;
+  }
+  const depth = env.transclusionDepth ?? 0;
+  if (depth >= options.embeds.transclusionMaxDepth) {
+    return `<div class="transclusion transclusion--too-deep" data-target="${escapeHtml(
+      rawTarget
+    )}">\u26A0\uFE0F transclusion \u5D4C\u5957\u8FC7\u6DF1(&gt; ${options.embeds.transclusionMaxDepth})</div>`;
+  }
+  const headingPart = extractHeading(rawTarget);
+  const fragment = headingPart ? sliceByHeading(target, headingPart, options.slugify) : target.content;
+  if (fragment == null) {
+    return `<div class="transclusion transclusion--unmatched-anchor" data-target="${escapeHtml(
+      rawTarget
+    )}">\u26A0\uFE0F \u627E\u4E0D\u5230\u7AE0\u8282 <code>#${escapeHtml(
+      headingPart
+    )}</code></div>`;
+  }
+  const cacheKey = `${target.absolutePath}::${headingPart ?? ""}`;
+  const cache = getCache(env);
+  let inner;
+  const cached = cache.get(cacheKey);
+  if (cached) {
+    inner = cached.html;
+  } else {
+    const childEnv = {
+      index: env.index,
+      options: env.options,
+      currentPath: target.absolutePath,
+      transclusionStack: [...stack, target.absolutePath],
+      transclusionDepth: depth + 1,
+      // 跨递归共享:asset 引用集合(build 时要 emit 所有被引用 asset)
+      referencedAssets: env.referencedAssets
+    };
+    childEnv._transclusionCache = env._transclusionCache;
+    inner = md.render(fragment, childEnv);
+    cache.set(cacheKey, { html: inner });
+  }
+  const sourceUrl = headingPart ? `${target.url}#${escapeHtml(options.slugify(headingPart))}` : target.url;
+  const aliasData = aliasParts.length ? ` data-caption="${escapeHtml(aliasParts.join("|"))}"` : "";
+  return `<div class="transclusion" data-source="${escapeHtml(
+    target.relativePath
+  )}" data-source-url="${escapeHtml(sourceUrl)}"${aliasData}>${inner}</div>`;
+}
+function handleTransclusion(state, rawTarget, aliasParts, env) {
+  if (env.options.deadLink !== "silent") {
+    console.warn(
+      `vitepress-allyouneed: ![[${rawTarget}]] \u5728\u6BB5\u843D\u4E2D\u65E0\u6CD5 transclude(\u4F1A\u4EA7\u751F\u4E0D\u5408\u6CD5 HTML),\u5DF2\u964D\u7EA7\u4E3A\u94FE\u63A5\u3002\u8BF7\u5355\u72EC\u653E\u4E00\u884C\u3002`
+    );
+  }
+  const { index, options } = env;
+  const result = resolveWikilink(rawTarget, index, options, "page");
+  const url = result.url;
+  const label = aliasParts.length ? aliasParts.join("|").trim() : result.defaultLabel;
+  const html = `<a class="wikilink wikilink--inline-transclusion-degraded" href="${escapeHtml(url)}" data-wikilink-target="${escapeHtml(rawTarget)}" title="\u884C\u5185 transclusion \u5DF2\u964D\u7EA7,\u89C1\u63A7\u5236\u53F0">${escapeHtml(label)}</a>`;
+  const token = state.push("html_inline", "", 0);
+  token.content = html;
+  return true;
+}
+function extractHeading(raw) {
+  const hashIdx = raw.indexOf("#");
+  if (hashIdx < 0) return "";
+  return raw.slice(hashIdx + 1).trim();
+}
+function sliceByHeading(target, headingPart, slugify) {
+  const matched = target.headings.find(
+    (h) => h.text === headingPart || h.slug === headingPart || h.slug === slugify(headingPart)
+  );
+  if (!matched) return void 0;
+  const lines = target.content.split(/\r?\n/);
+  const startLine = matched.line + 1;
+  let endLine = lines.length;
+  for (let i = startLine; i < lines.length; i++) {
+    const l = lines[i];
+    const m = l.match(/^(#{1,6})\s+/);
+    if (m && m[1].length <= matched.level) {
+      endLine = i;
+      break;
+    }
+  }
+  return lines.slice(startLine, endLine).join("\n").trim();
+}
+function getCache(env) {
+  const e = env;
+  if (!e._transclusionCache) e._transclusionCache = /* @__PURE__ */ new Map();
+  return e._transclusionCache;
+}
+
+// src/modules/wikilinks/rule.ts
+function makeWikilinkRule(scope) {
+  return function wikilinkRule(state, silent) {
+    const src = state.src;
+    const start = state.pos;
+    const max = state.posMax;
+    let isEmbed = false;
+    let inner;
+    if (src.charCodeAt(start) === 33 && src.charCodeAt(start + 1) === 91 && src.charCodeAt(start + 2) === 91) {
+      if (scope === "wikilinks-only") return false;
+      isEmbed = true;
+    } else if (src.charCodeAt(start) === 91 && src.charCodeAt(start + 1) === 91) {
+      if (scope === "embeds-only") return false;
+    } else {
+      return false;
+    }
+    const innerStart = start + (isEmbed ? 3 : 2);
+    const closeIdx = src.indexOf("]]", innerStart);
+    if (closeIdx < 0 || closeIdx >= max) return false;
+    inner = src.slice(innerStart, closeIdx);
+    if (inner.includes("\n")) return false;
+    if (!inner.trim()) return false;
+    if (silent) return true;
+    const env = state.env;
+    if (!env || !env.index || !env.options) {
+      return false;
+    }
+    state.pos = closeIdx + 2;
+    const parts = inner.split("|").map((p) => p.trim());
+    const rawTarget = parts[0];
+    const aliasParts = parts.slice(1);
+    if (isEmbed) {
+      const ext = extractExt(rawTarget);
+      const isImage = ext && env.options.embeds.imageFileExt.includes(ext.toLowerCase());
+      if (isImage) {
+        return handleImageEmbed(state, rawTarget, aliasParts, env);
+      }
+      return handleTransclusion(state, rawTarget, aliasParts, env);
+    }
+    return emitPageLink(state, rawTarget, aliasParts, env);
+  };
+}
+function extractExt(target) {
+  const cleaned = target.split("#")[0];
+  const dot = cleaned.lastIndexOf(".");
+  if (dot <= 0) return "";
+  return cleaned.slice(dot + 1).toLowerCase();
+}
+function emitPageLink(state, rawTarget, aliasParts, env) {
+  const { index, options } = env;
+  const userAlias = aliasParts.length > 0 ? aliasParts.join("|").trim() : "";
+  const processed = options.wikilinks.postProcessLinkTarget(rawTarget);
+  const result = resolveWikilink(processed, index, options, "page");
+  const label = userAlias ? options.wikilinks.postProcessLinkLabel(userAlias) : result.defaultLabel;
+  registerBacklink(env, result.target?.absolutePath, false);
+  if (result.isDead) {
+    handleDeadLink(env, rawTarget);
+    return renderDeadLink(state, result.url, label, rawTarget, env);
+  }
+  return renderPageLink(state, result, label, env);
+}
+function registerBacklink(env, targetPath, isEmbed) {
+  if (!targetPath || !env.currentPath) return;
+  const arr = env.index.backlinks.get(targetPath) ?? [];
+  arr.push({
+    fromPath: env.currentPath,
+    fromUrl: env.index.files.get(env.currentPath)?.url ?? "",
+    context: "",
+    isEmbed,
+    line: -1
+  });
+  env.index.backlinks.set(targetPath, arr);
+}
+function handleDeadLink(env, rawTarget) {
+  const { options } = env;
+  const msg = `vitepress-allyouneed: \u6B7B\u94FE [[${rawTarget}]]${env.currentPath ? ` (in ${env.currentPath})` : ""}`;
+  if (options.deadLink === "silent") return;
+  if (options.deadLink === "warn") {
+    console.warn(msg);
+    return;
+  }
+  env.index.warnings.push({
+    kind: "unknown",
+    message: msg,
+    affected: env.currentPath ? [env.currentPath] : []
+  });
+}
+
+// src/modules/wikilinks/index.ts
+function registerWikilinks(md, scope) {
+  md.inline.ruler.before(
+    "link",
+    "allyouneed_wikilinks",
+    makeWikilinkRule(scope)
+  );
+}
+
+// src/modules/embeds/block-rule.ts
+var LINE_RE = /^!\[\[([^\n\]]+)\]\]\s*$/;
+function registerEmbedBlockRule(md) {
+  md.block.ruler.before(
+    "paragraph",
+    "allyouneed_embed_block",
+    makeRule(md),
+    { alt: ["paragraph"] }
+  );
+}
+function makeRule(md) {
+  return function embedBlockRule(state, startLine, _endLine, silent) {
+    const start = state.bMarks[startLine] + state.tShift[startLine];
+    const max = state.eMarks[startLine];
+    const lineText = state.src.slice(start, max);
+    const m = lineText.match(LINE_RE);
+    if (!m) return false;
+    if (silent) return true;
+    const env = state.env;
+    if (!env || !env.index || !env.options) return false;
+    const inner = m[1];
+    const parts = inner.split("|").map((p) => p.trim());
+    const rawTarget = parts[0];
+    const aliasParts = parts.slice(1);
+    const ext = extractExt2(rawTarget);
+    const isImage = !!ext && env.options.embeds.imageFileExt.includes(ext.toLowerCase());
+    let html;
+    if (isImage) {
+      html = renderImageHtml(rawTarget, aliasParts, env);
+    } else {
+      html = renderTransclusionHtml(md, rawTarget, aliasParts, env);
+    }
+    const token = state.push("html_block", "", 0);
+    token.content = html + "\n";
+    token.map = [startLine, startLine + 1];
+    state.line = startLine + 1;
+    return true;
+  };
+}
+function extractExt2(target) {
+  const cleaned = target.split("#")[0];
+  const dot = cleaned.lastIndexOf(".");
+  if (dot <= 0) return "";
+  return cleaned.slice(dot + 1).toLowerCase();
+}
+
+// src/modules/embeds/index.ts
+function registerEmbedsOnly(md) {
+  md.inline.ruler.before(
+    "link",
+    "allyouneed_embeds",
+    makeWikilinkRule("embeds-only")
+  );
+  registerEmbedBlockRule(md);
+}
+
+// src/markdown-it.ts
+function allYouNeedMarkdownIt(md, options) {
+  const resolved = options && isResolved(options) ? options : resolveOptions(options);
+  const { wikilinks: wlOn, embeds: emOn } = resolved.modules;
+  if (wlOn && emOn) {
+    registerWikilinks(md, "both");
+    registerEmbedBlockRule(md);
+  } else if (wlOn) {
+    registerWikilinks(md, "wikilinks-only");
+  } else if (emOn) {
+    registerEmbedsOnly(md);
+  }
+}
+function isResolved(o) {
+  return typeof o.slugify === "function" && typeof o.srcDir === "string" && typeof o.modules === "object" && o.modules !== null;
+}
+var markdown_it_default = allYouNeedMarkdownIt;
+
+// src/vite.ts
+import fs5 from "fs";
+import nodePath6 from "path";
+
+// src/core/asset-pipeline/dev-middleware.ts
+import fs4 from "fs";
+import nodePath5 from "path";
+function createDevMiddleware(index, options) {
+  return (req, res, next) => {
+    if (!req.url) return next();
+    const cleanPath = req.url.split("?")[0].split("#")[0];
+    let inSiteUrl = cleanPath;
+    if (options.base !== "/" && cleanPath.startsWith(options.base)) {
+      inSiteUrl = "/" + cleanPath.slice(options.base.length);
+    }
+    let decoded;
+    try {
+      decoded = decodeURIComponent(inSiteUrl);
+    } catch {
+      return next();
+    }
+    if (!/\.[a-zA-Z0-9]+$/.test(decoded)) return next();
+    const relCandidate = decoded.replace(/^\/+/, "");
+    let asset = index.assetsByRelativePath.get(relCandidate);
+    if (!asset) {
+      const bn = basename(decoded);
+      const map = options.caseSensitive ? index.assetsByBasename : index.assetsByBasenameLower;
+      const key = options.caseSensitive ? bn : bn.toLowerCase();
+      const candidates = map.get(key);
+      if (candidates && candidates.length > 0) asset = candidates[0];
+    }
+    if (!asset) return next();
+    let stat;
+    try {
+      stat = fs4.statSync(asset.absolutePath);
+    } catch {
+      return next();
+    }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", guessMime(asset.extension));
+    res.setHeader("Content-Length", String(stat.size));
+    res.setHeader("Cache-Control", "no-cache");
+    fs4.createReadStream(asset.absolutePath).on("error", () => next()).pipe(res);
+  };
+}
+var MIME = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  bmp: "image/bmp",
+  avif: "image/avif",
+  ico: "image/x-icon",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  m4v: "video/x-m4v",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  m4a: "audio/mp4",
+  flac: "audio/flac",
+  pdf: "application/pdf",
+  canvas: "application/json",
+  excalidraw: "application/json"
+};
+function guessMime(ext) {
+  return MIME[ext.toLowerCase()] ?? "application/octet-stream";
+}
+
+// src/vite.ts
+function stripQueryAndHash(id) {
+  return id.split("?")[0].split("#")[0];
+}
+function viteAllYouNeed(userOptions = {}) {
+  let resolved;
+  let index;
+  let viteConfig;
+  const plugin = {
+    name: "vitepress-allyouneed",
+    /**
+     * 在 Vite 配置定型前扩 server.fs.allow,让我们的 vault srcDir 可被 Vite
+     * 服务(即便 srcDir 不在项目根下)。
+     */
+    config(_userViteConfig, _envCtx) {
+      const srcDirOpt = userOptions.srcDir;
+      if (!srcDirOpt) return void 0;
+      const abs = toPosix(nodePath6.resolve(srcDirOpt));
+      return {
+        server: {
+          fs: {
+            allow: [abs]
+          }
+        }
+      };
+    },
+    configResolved(cfg) {
+      viteConfig = cfg;
+      resolved = resolveOptions(userOptions, {
+        srcDir: userOptions.srcDir ?? cfg.root,
+        base: userOptions.base ?? cfg.base,
+        cleanUrls: userOptions.cleanUrls
+      });
+      try {
+        index = scanVault(resolved);
+        if (index.warnings.length > 0) {
+          const top = index.warnings.slice(0, 10);
+          for (const w of top) {
+            cfg.logger.warn(`[vitepress-allyouneed] ${w.message}`);
+          }
+          if (index.warnings.length > top.length) {
+            cfg.logger.warn(
+              `[vitepress-allyouneed] (...\u8FD8\u6709 ${index.warnings.length - top.length} \u6761\u544A\u8B66)`
+            );
+          }
+        }
+      } catch (err) {
+        cfg.logger.error(
+          `[vitepress-allyouneed] vault \u626B\u63CF\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`
+        );
+        index = void 0;
+      }
+    },
+    configureServer(server) {
+      if (!index) return;
+      const mw = createDevMiddleware(index, resolved);
+      return () => {
+        server.middlewares.use(mw);
+      };
+    },
+    handleHotUpdate(ctx) {
+      if (!index) return;
+      try {
+        const stat = fs5.statSync(ctx.file);
+        if (stat.isFile()) {
+          updateFile(index, ctx.file, resolved);
+        } else if (!fs5.existsSync(ctx.file)) {
+          removeFile(index, ctx.file, resolved);
+        }
+      } catch {
+        removeFile(index, ctx.file, resolved);
+      }
+    },
+    /**
+     * 拦截占位符 URL,**返回真实绝对文件路径**(POSIX 风格)。
+     *
+     * Vite 拿到文件路径会:
+     *   - dev:按文件系统服务,id 经 transform 后变成 `export default '<url>'`
+     *   - build:emit asset、Rollup 自动加 hash,导出最终 URL
+     */
+    resolveId(id) {
+      if (!index) return null;
+      const stripped = stripQueryAndHash(id);
+      const ph = ASSET_PLACEHOLDER_PREFIX;
+      const phIdx = stripped.indexOf(ph);
+      if (phIdx < 0) return null;
+      const encoded = stripped.slice(phIdx + ph.length);
+      let relPath;
+      try {
+        relPath = decodeURI(encoded);
+      } catch {
+        return null;
+      }
+      const asset = index.assetsByRelativePath.get(relPath);
+      if (!asset) return null;
+      const query = id.slice(stripped.length);
+      return asset.absolutePath + query;
+    },
+    /**
+     * 给 vitepress.ts wrapper 用。
+     */
+    __getOptions() {
+      return resolved;
+    },
+    __getIndex() {
+      return index;
+    }
+  };
+  void viteConfig;
+  return plugin;
+}
+
+// src/vitepress.ts
+function defineConfigWithAllYouNeed(config, pluginOptions = {}) {
+  const vpExclude = Array.isArray(config.srcExclude) ? config.srcExclude : [];
+  const mergedOptions = {
+    ...pluginOptions,
+    srcDir: pluginOptions.srcDir ?? config.srcDir,
+    base: pluginOptions.base ?? config.base,
+    cleanUrls: pluginOptions.cleanUrls ?? config.cleanUrls,
+    scan: {
+      ...pluginOptions.scan,
+      exclude: [
+        ...pluginOptions.scan?.exclude ?? [],
+        ...vpExclude
+      ]
+    }
+  };
+  const vitePlugin = viteAllYouNeed(mergedOptions);
+  const existingVite = typeof config.vite === "object" && config.vite !== null ? config.vite : {};
+  const existingPlugins = Array.isArray(existingVite.plugins) ? existingVite.plugins : [];
+  const newVite = {
+    ...existingVite,
+    plugins: [...existingPlugins, vitePlugin]
+  };
+  const existingMarkdown = config.markdown ?? {};
+  const existingConfig = existingMarkdown.config;
+  const newMarkdownConfig = (md) => {
+    markdown_it_default(md, mergedOptions);
+    md.core.ruler.before(
+      "normalize",
+      "allyouneed_env_inject",
+      makeEnvInjector(vitePlugin)
+    );
+    if (typeof existingConfig === "function") {
+      existingConfig(md);
+    }
+  };
+  return {
+    ...config,
+    vite: newVite,
+    markdown: {
+      ...existingMarkdown,
+      config: newMarkdownConfig
+    }
+  };
+}
+function makeEnvInjector(vitePlugin) {
+  return (state) => {
+    const env = state.env;
+    if (!env) return;
+    if (env.index && env.options) return;
+    const index = vitePlugin.__getIndex();
+    const options = vitePlugin.__getOptions();
+    if (!index || !options) return;
+    env.index = index;
+    env.options = options;
+    if (!env.currentPath) {
+      env.currentPath = typeof env.realPath === "string" ? env.realPath : typeof env.path === "string" ? env.path : void 0;
+    }
+    if (!env.referencedAssets) env.referencedAssets = /* @__PURE__ */ new Set();
+  };
+}
+export {
+  allYouNeedMarkdownIt,
+  createEmptyIndex,
+  markdown_it_default as default,
+  defaultSlugify,
+  defineConfigWithAllYouNeed,
+  extractCustomId,
+  removeFile,
+  resolveAsset,
+  resolveOptions,
+  resolveWikilink,
+  scanVault,
+  updateFile,
+  viteAllYouNeed
+};
+//# sourceMappingURL=index.js.map