vitepress-allyouneed 0.1.0

package/dist/vite.cjs

@@ -0,0 +1,783 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vite.ts
+var vite_exports = {};
+__export(vite_exports, {
+  default: () => vite_default,
+  viteAllYouNeed: () => viteAllYouNeed
+});
+module.exports = __toCommonJS(vite_exports);
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+
+// src/core/slugify.ts
+var import_shared = require("@mdit-vue/shared");
+function defaultSlugify(text) {
+  return (0, import_shared.slugify)(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
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+
+// src/utils/path.ts
+var import_node_path = __toESM(require("path"), 1);
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function relative(from, to) {
+  return toPosix(import_node_path.default.relative(from, to));
+}
+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();
+}
+
+// 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
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+function walk(srcDir, isIgnored, followSymlinks) {
+  const out = [];
+  const seenInodes = /* @__PURE__ */ new Set();
+  function visit(dir) {
+    let entries;
+    try {
+      entries = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = import_node_path2.default.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 = import_node_fs.default.statSync(full);
+          isDir = stat.isDirectory();
+          isFile = stat.isFile();
+        } catch {
+          continue;
+        }
+      }
+      if (isDir) {
+        if (followSymlinks) {
+          try {
+            const stat = import_node_fs.default.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 = import_node_fs.default.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
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_picomatch = __toESM(require("picomatch"), 1);
+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 = import_node_path3.default.join(srcDir, ".gitignore");
+    try {
+      const content = import_node_fs2.default.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) => (0, import_picomatch.default)(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
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+function parseFrontmatter(raw) {
+  try {
+    const { data, content } = (0, import_gray_matter.default)(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(import_node_path4.default.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 = import_node_fs3.default.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 = import_node_fs3.default.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);
+}
+
+// src/core/asset-pipeline/dev-middleware.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+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 = import_node_fs4.default.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");
+    import_node_fs4.default.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/core/asset-pipeline/build-emit.ts
+var ASSET_PLACEHOLDER_PREFIX = "/__ayn_asset__/";
+
+// 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(import_node_path6.default.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 = import_node_fs5.default.statSync(ctx.file);
+        if (stat.isFile()) {
+          updateFile(index, ctx.file, resolved);
+        } else if (!import_node_fs5.default.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;
+}
+var vite_default = viteAllYouNeed;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  viteAllYouNeed
+});
+//# sourceMappingURL=vite.cjs.map