vitepress-allyouneed 0.1.0

package/dist/markdown-it.js

@@ -0,0 +1,763 @@
+// src/core/slugify.ts
+import { slugify as mditVueSlugify } from "@mdit-vue/shared";
+function defaultSlugify(text) {
+  return mditVueSlugify(text);
+}
+
+// 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 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 splitPath(p) {
+  return toPosix(p).split("/").filter(Boolean);
+}
+function pathDepth(relPath) {
+  return splitPath(relPath).length;
+}
+
+// src/core/vault/scan.ts
+import fs from "fs";
+import nodePath2 from "path";
+
+// src/core/vault/ignore.ts
+import fs2 from "fs";
+import nodePath3 from "path";
+import picomatch from "picomatch";
+
+// src/core/vault/frontmatter.ts
+import matter from "gray-matter";
+
+// src/core/vault/index.ts
+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;
+export {
+  allYouNeedMarkdownIt,
+  markdown_it_default as default
+};
+//# sourceMappingURL=markdown-it.js.map