hexo-theme-gnix 12.0.0 → 14.0.0

package/include/hexo/shiki.js

@@ -0,0 +1,191 @@
+const { codeToHtml } = require("shiki");
+const t = require("@shikijs/transformers");
+const { transformerColorizedBrackets } = require("@shikijs/colorized-brackets");
+const { mkdir, writeFile } = require("node:fs/promises");
+const { dirname } = require("node:path");
+
+const THEMES = {
+  light: "catppuccin-latte",
+  dark: "catppuccin-mocha",
+  song: "everforest-light",
+  nord: "nord",
+  tokyo: "tokyo-night",
+  rose: "rose-pine",
+};
+
+const TRANSFORMERS = [
+  t.transformerCompactLineOptions(),
+  t.transformerMetaHighlight(),
+  t.transformerMetaWordHighlight(),
+  t.transformerNotationDiff(),
+  t.transformerNotationErrorLevel(),
+  t.transformerNotationFocus(),
+  t.transformerNotationHighlight(),
+  t.transformerNotationWordHighlight(),
+  t.transformerRemoveLineBreak(),
+  t.transformerRemoveNotationEscape(),
+  t.transformerRenderWhitespace(),
+  transformerColorizedBrackets(),
+];
+
+const SVG_WRAP =
+  '<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="toggle-wrap" title="Toggle Wrap"><path d="m16 16-3 3 3 3"/><path d="M3 12h14.5a1 1 0 0 1 0 7H13"/><path d="M3 19h6"/><path d="M3 5h18"/></svg>';
+const SVG_COPY =
+  '<div class="copy-notice"></div><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="copy-button"><rect width="8" height="4" x="8" y="2" rx="1" ry="1"/><path d="M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-2"/><path d="M16 4h2a2 2 0 0 1 2 2v4"/><path d="M21 14H11"/><path d="m15 10-4 4 4 4"/></svg>';
+const SVG_EXPAND =
+  '<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="expand-icon"><path d="M12 22v-6"/><path d="M12 8V2"/><path d="M4 12H2"/><path d="M10 12H8"/><path d="M16 12h-2"/><path d="M22 12h-2"/><path d="m15 19-3 3-3-3"/><path d="m15 5-3-3-3 3"/></svg>';
+const SVG_COLLAPSE =
+  '<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="collapse-icon"><path d="M12 22v-6"/><path d="M12 8V2"/><path d="M4 12H2"/><path d="M10 12H8"/><path d="M16 12h-2"/><path d="M22 12h-2"/><path d="m15 19-3-3-3 3"/><path d="m15 5 3 3-3 3"/></svg>';
+
+const RE_LINE = /<span class="line/g;
+
+function escapeHtml(code) {
+  return code.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+
+function createShikiTools(lang, title, { lang: showLang, title: showTitle, wrapToggle, copyButton }) {
+  let left = '<div class="left"><div class="traffic-lights"> <span class="traffic-light red"></span> <span class="traffic-light yellow"></span> <span class="traffic-light green"></span> </div>';
+  if (showLang) left += `<div class="code-lang">${lang.toUpperCase()}</div>`;
+  left += "</div>";
+
+  let center = '<div class="center">';
+  if (showTitle && title) center += `\n<div class="code-title">${title}</div>`;
+  center += "\n</div>";
+
+  let right = '<div class="right">';
+  if (wrapToggle) right += `\n${SVG_WRAP}`;
+  if (copyButton) right += `\n${SVG_COPY}`;
+  right += "\n</div>";
+
+  return `<div class="shiki-tools">${left}${center}${right}</div>`;
+}
+
+async function writeCssAsync(cssGetter, cssOutputPath) {
+  if (!cssGetter || !cssOutputPath) return;
+  const css = cssGetter();
+  await mkdir(dirname(cssOutputPath), { recursive: true });
+  await writeFile(cssOutputPath, css, "utf8");
+}
+
+function computeCollapseAttributes(cfg, codeHtml) {
+  const codeLines = (codeHtml.match(RE_LINE) || []).length;
+  const shouldCollapse = cfg.collapseConfig.enable && codeLines > cfg.collapseConfig.maxLines;
+  return {
+    expandButton: shouldCollapse ? `<div class="code-expand-btn">${SVG_EXPAND}${SVG_COLLAPSE}</div>` : "",
+    collapseAttrs: shouldCollapse ? ` data-collapsible="true" data-max-lines="${cfg.collapseConfig.maxLines}" data-total-lines="${codeLines}"` : "",
+  };
+}
+
+function parseConfig(renderOptions) {
+  const options = renderOptions || {};
+  const { toolbar_items: ti = {}, style_to_class: stc } = options;
+
+  let enabledTransformers;
+  if (!options.transformers || options.transformers.includes("all")) {
+    enabledTransformers = [...TRANSFORMERS];
+  } else {
+    enabledTransformers = options.transformers.map((name) => TRANSFORMERS.find((tr) => tr.name === name)).filter(Boolean);
+  }
+
+  let toClass = null;
+  if (stc && stc.enable) {
+    toClass = t.transformerStyleToClass({ classPrefix: stc.class_prefix || "_sk_" });
+    enabledTransformers.push(toClass);
+  }
+
+  const maxLines = options.code_collapse != null ? options.code_collapse : 30;
+
+  return {
+    themes: THEMES,
+    excludes: options.exclude_languages || ["mermaid"],
+    aliases: options.language_aliases || {},
+    collapseConfig: { enable: maxLines > 0, maxLines },
+    styleToClass: {
+      enable: !!(stc && stc.enable),
+      cssGetter: toClass ? toClass.getCSS : undefined,
+      css_output_path: stc ? stc.css_output_path : undefined,
+    },
+    transformers: enabledTransformers,
+    toolbarItems: {
+      lang: ti.lang != null ? ti.lang : true,
+      title: ti.title != null ? ti.title : true,
+      wrapToggle: ti.wrapToggle != null ? ti.wrapToggle : true,
+      copyButton: ti.copyButton != null ? ti.copyButton : true,
+    },
+  };
+}
+
+function renderCode(md, renderOptions) {
+  const cfg = parseConfig(renderOptions);
+
+  md.renderer.rules.fence = async (tokens, idx) => {
+    const token = tokens[idx];
+    if (!token) return "";
+
+    const code = token.content;
+    const lang = token.info.split(/\s+/)[0] || "";
+    const attrs = token.info.split(/\s+/).slice(1).join(" ");
+
+    if (cfg.excludes.includes(lang)) {
+      const escaped = escapeHtml(code);
+      return `<pre><code class="${lang}">${escaped}</code></pre>`;
+    }
+    const normalizedCode = code.replace(/\r?\n$/, "");
+    const mappedLang = cfg.aliases[lang] || lang;
+    let codeHtml;
+    try {
+      codeHtml = await codeToHtml(normalizedCode, {
+        lang: mappedLang,
+        themes: cfg.themes,
+        transformers: cfg.transformers,
+      });
+    } catch (err) {
+      console.warn(`[shiki] Language \`${mappedLang}\` is not supported, falling back to \`txt\`.`);
+      codeHtml = await codeToHtml(normalizedCode, {
+        lang: "txt",
+        themes: cfg.themes,
+        transformers: cfg.transformers,
+      });
+    }
+    await writeCssAsync(cfg.styleToClass.cssGetter, cfg.styleToClass.css_output_path);
+    codeHtml = codeHtml.replace(/<pre[^>]*>/, (match) => match.replace(/\s*style\s*=\s*"[^"]*"\s*tabindex="0"/, ""));
+
+    const title = attrs || "";
+    const shikiToolsHtml = createShikiTools(lang || "", title, cfg.toolbarItems);
+    const { expandButton, collapseAttrs } = computeCollapseAttributes(cfg, codeHtml);
+    return `<figure class="shiki" ${collapseAttrs}> ${shikiToolsHtml} ${codeHtml}${expandButton} </figure>`;
+  };
+
+  md.renderer.rules.code_inline = async (tokens, idx, _options, _env, self) => {
+    const token = tokens[idx];
+    if (!token) return "";
+
+    const content = token.content.trim();
+    const match = content.match(/^\{(\w+)\}\s+(.+)$/);
+    if (match === null) {
+      return `<code${self.renderAttrs(token)}>${escapeHtml(content)}</code>`;
+    }
+    const [, lang, code] = match;
+    if (!lang || !code) return `<code>${content}</code>`;
+    let highlighted;
+    try {
+      highlighted = await codeToHtml(code, {
+        lang: lang,
+        themes: cfg.themes,
+        structure: "inline",
+      });
+    } catch (err) {
+      console.warn(`[shiki] Language \`${lang}\` is not supported, falling back to \`txt\`.`);
+      highlighted = await codeToHtml(code, {
+        lang: "txt",
+        themes: cfg.themes,
+        structure: "inline",
+      });
+    }
+    return `<code${self.renderAttrs(token)}>${highlighted}</code>`;
+  };
+}
+
+module.exports = renderCode;
+module.exports.default = renderCode;
+

package/include/hexo/sitemap.js

@@ -0,0 +1,184 @@
+// Adapted from hexo-generator-sitemap (MIT, (c) Tommy Chen)
+// https://github.com/hexojs/hexo-generator-sitemap
+
+const { extname } = require("node:path");
+const { encodeURL, url_for } = require("hexo-util");
+
+const DEFAULT_CONFIG = {
+  path: ["sitemap.xml", "sitemap.txt"],
+  rel: false,
+  tags: true,
+  categories: true,
+};
+
+const DEFAULT_SKIP_PATTERNS = ["**/*.js", "**/*.css"];
+const REL_SITEMAP_RE = /rel=['|"]?sitemap['|"]?/i;
+const HEAD_RE = /<head>(?!<\/head>).+?<\/head>/s;
+const REGEX_ESCAPE_CHARS = "\\^$.+()[]{}|";
+
+function globToRegExp(pattern) {
+  let regex = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        regex += ".*";
+        i++;
+        if (pattern[i + 1] === "/") i++;
+      } else {
+        regex += "[^/]*";
+      }
+    } else if (ch === "?") {
+      regex += "[^/]";
+    } else if (REGEX_ESCAPE_CHARS.includes(ch)) {
+      regex += `\\${ch}`;
+    } else {
+      regex += ch;
+    }
+  }
+  return new RegExp(`^${regex}$`);
+}
+
+function buildMatcher(patterns) {
+  const compiled = patterns.map(globToRegExp);
+  return (value) => compiled.some((re) => re.test(value));
+}
+
+function normalizePaths(rawPath) {
+  const paths = Array.isArray(rawPath) ? rawPath : typeof rawPath === "string" ? [rawPath] : DEFAULT_CONFIG.path;
+  return paths.filter((p) => typeof p === "string" && p.trim()).map((p) => (extname(p) ? p : `${p}.xml`));
+}
+
+function formatDate(date) {
+  return date.toISOString().substring(0, 10);
+}
+
+function getLastMod(post) {
+  const value = post.updated || post.date;
+  if (!value) return null;
+  if (typeof value.toDate === "function") return value.toDate();
+  return value instanceof Date ? value : null;
+}
+
+function getSortKey(post) {
+  const value = post.updated;
+  if (!value) return 0;
+  if (typeof value.valueOf === "function") return value.valueOf();
+  return value instanceof Date ? value.getTime() : 0;
+}
+
+function renderXml({ posts, tags, categories, siteUrl, now }) {
+  const formattedNow = formatDate(now);
+
+  const postEntries = posts
+    .map((post) => {
+      const lastMod = getLastMod(post);
+      const lastModLine = lastMod ? `\n    <lastmod>${formatDate(lastMod)}</lastmod>` : "";
+      return `  <url>
+    <loc>${encodeURL(post.permalink)}</loc>${lastModLine}
+    <changefreq>monthly</changefreq>
+    <priority>0.6</priority>
+  </url>`;
+    })
+    .join("\n");
+
+  const taxonomyEntries = (items, freq, priority) =>
+    items
+      .map(
+        (item) => `  <url>
+    <loc>${encodeURL(item.permalink)}</loc>
+    <lastmod>${formattedNow}</lastmod>
+    <changefreq>${freq}</changefreq>
+    <priority>${priority}</priority>
+  </url>`,
+      )
+      .join("\n");
+
+  const sections = [
+    postEntries,
+    `  <url>
+    <loc>${encodeURL(siteUrl)}</loc>
+    <lastmod>${formattedNow}</lastmod>
+    <changefreq>daily</changefreq>
+    <priority>1.0</priority>
+  </url>`,
+    taxonomyEntries(tags, "weekly", "0.2"),
+    taxonomyEntries(categories, "weekly", "0.2"),
+  ].filter(Boolean);
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${sections.join("\n\n")}
+</urlset>
+`;
+}
+
+function renderTxt({ posts, tags, categories, siteUrl }) {
+  const lines = [
+    ...posts.map((post) => encodeURL(post.permalink)),
+    encodeURL(siteUrl),
+    ...tags.map((tag) => encodeURL(tag.permalink)),
+    ...categories.map((cat) => encodeURL(cat.permalink)),
+  ];
+  return `${lines.join("\n")}\n`;
+}
+
+const RENDERERS = {
+  ".xml": renderXml,
+  ".txt": renderTxt,
+};
+
+module.exports = (hexo) => {
+  const config = Object.assign({}, DEFAULT_CONFIG, hexo.config.sitemap);
+  config.path = normalizePaths(config.path);
+  hexo.config.sitemap = config;
+
+  hexo.extend.generator.register("sitemap", function (locals) {
+    const skipPatterns = [...DEFAULT_SKIP_PATTERNS];
+    const userSkip = this.config.skip_render;
+    if (Array.isArray(userSkip)) {
+      skipPatterns.push(...userSkip);
+    } else if (typeof userSkip === "string" && userSkip.length > 0) {
+      skipPatterns.push(userSkip);
+    }
+
+    const isSkipped = buildMatcher(skipPatterns);
+    const posts = []
+      .concat(locals.posts.toArray(), locals.pages.toArray())
+      .filter((post) => post.sitemap !== false && !isSkipped(post.source))
+      .sort((a, b) => getSortKey(b) - getSortKey(a));
+
+    if (posts.length === 0) {
+      config.rel = false;
+      return;
+    }
+
+    const context = {
+      posts,
+      tags: config.tags ? locals.tags.toArray() : [],
+      categories: config.categories ? locals.categories.toArray() : [],
+      siteUrl: this.config.url,
+      now: new Date(),
+    };
+
+    return config.path
+      .map((p) => {
+        const renderer = RENDERERS[extname(p)];
+        return renderer ? { path: p, data: renderer(context) } : null;
+      })
+      .filter(Boolean);
+  });
+
+  if (config.rel === true) {
+    hexo.extend.filter.register("after_render:html", function (data) {
+      const sitemapConfig = hexo.config.sitemap;
+      if (!sitemapConfig.rel || REL_SITEMAP_RE.test(data)) return data;
+
+      const xmlPath = sitemapConfig.path.find((p) => extname(p) === ".xml");
+      if (!xmlPath) return data;
+
+      const tag = `<link rel="sitemap" type="application/xml" title="Sitemap" href="${url_for.call(this, xmlPath)}">`;
+      return data.replace(HEAD_RE, (str) => str.replace("</head>", `${tag}</head>`));
+    });
+  }
+};

package/include/util/i18n.js

@@ -1,17 +1,6 @@
 const path = require("node:path");
 
-const DEFAULT_LANGUAGES = {
-  cn: {
-    label: "Chinese",
-    locale: "zh-CN",
-    prefix: "cn",
-  },
-  en: {
-    label: "English",
-    locale: "en",
-    prefix: "en",
-  },
-};
+// ─── 基础字符串工具 ────────────────────────────────────────────────
 
 function trimSlashes(value) {
   return String(value || "").replace(/^\/+|\/+$/g, "");
@@ -34,6 +23,8 @@ function isExternalUrl(value) {
   return /^(?:[a-z][a-z\d+.-]*:)?\/\//i.test(value) || /^(?:mailto|tel|data):/i.test(value) || value.startsWith("#");
 }
 
+// ─── i18n 配置解析（带缓存）─────────────────────────────────────────
+
 const i18nConfigCache = new WeakMap();
 
 function getI18nConfig(config = {}) {
@@ -41,27 +32,23 @@ function getI18nConfig(config = {}) {
     return i18nConfigCache.get(config);
   }
 
-  const configI18n = config.i18n || {};
-  const themeI18n = config.theme_config?.i18n || {};
-  const raw = configI18n.enabled === true || configI18n.languages ? configI18n : themeI18n.enabled === true || themeI18n.languages ? themeI18n : configI18n;
-  const rawLanguages = raw.languages || DEFAULT_LANGUAGES;
+  const raw = config.i18n || {};
+  const rawLanguages = raw.languages || {};
   const languages = {};
 
   Object.keys(rawLanguages).forEach((key) => {
     const normalizedKey = normalizeLanguageKey(key);
-    const value = typeof rawLanguages[key] === "string" ? { locale: rawLanguages[key] } : rawLanguages[key] || {};
-    const locale = normalizeLocale(value.locale || value.lang || value.language || normalizedKey);
-    const prefix = value.prefix ?? value.path ?? value.url_prefix;
+    const value = rawLanguages[key] || {};
     languages[normalizedKey] = {
       key: normalizedKey,
-      label: value.label || value.name || locale || normalizedKey,
-      locale,
-      prefix: normalizePrefix(prefix, normalizedKey),
+      label: value.label || normalizedKey,
+      locale: normalizeLocale(value.locale || normalizedKey),
+      prefix: normalizePrefix(value.prefix, normalizedKey),
     };
   });
 
   const keys = Object.keys(languages);
-  const configuredDefault = normalizeLanguageKey(raw.default || raw.default_language || raw.defaultLanguage || keys[0]);
+  const configuredDefault = normalizeLanguageKey(raw.default || keys[0]);
   const defaultLanguage = languages[configuredDefault] ? configuredDefault : keys[0];
 
   const result = {
@@ -92,22 +79,23 @@ function getLanguage(config = {}, key) {
   return i18n.languages[normalizedKey] || i18n.languages[i18n.defaultLanguage];
 }
 
-function getLanguageKeyFromLocale(config = {}, locale) {
-  const normalizedLocale = normalizeLocale(locale).toLowerCase();
-  if (!normalizedLocale) return null;
+function getLanguageBasePath(config, key) {
+  return getLanguage(config, key)?.prefix || "";
+}
+
+// ─── 语言键查询（私有辅助）─────────────────────────────────────────
+
+function getLanguageKeyFromLocale(config, locale) {
+  const normalized = normalizeLocale(locale).toLowerCase();
+  if (!normalized) return null;
 
   const i18n = getI18nConfig(config);
-  if (i18n.languages[normalizedLocale]) return normalizedLocale;
+  if (i18n.languages[normalized]) return normalized;
 
-  return (
-    Object.keys(i18n.languages).find((key) => {
-      const language = i18n.languages[key];
-      return language.locale.toLowerCase() === normalizedLocale;
-    }) || null
-  );
+  return Object.keys(i18n.languages).find((key) => i18n.languages[key].locale.toLowerCase() === normalized) || null;
 }
 
-function getLanguageKeyFromPath(value, config = {}) {
+function getLanguageKeyFromPath(value, config) {
   const normalized = trimSlashes(value);
   if (!normalized) return null;
 
@@ -120,30 +108,69 @@ function getLanguageKeyFromPath(value, config = {}) {
   );
 }
 
-function getLanguageKeyFromSource(value, config = {}) {
-  const normalized = trimSlashes(value).replace(/\\/g, "/");
-  if (!normalized) return null;
+// ─── 源路径解析：从文件名识别 __<lang> 后缀 ──────────────────────────
 
-  const firstSegment = normalized.split("/")[0];
-  const i18n = getI18nConfig(config);
-  return i18n.languages[firstSegment] ? firstSegment : null;
+function parseLocalizedSource(source) {
+  if (typeof source !== "string" || !source) {
+    return { langKey: null, baseSource: "" };
+  }
+
+  const normalized = source.replace(/\\/g, "/");
+  const lastSlash = normalized.lastIndexOf("/");
+  const dir = lastSlash >= 0 ? normalized.slice(0, lastSlash + 1) : "";
+  const filename = lastSlash >= 0 ? normalized.slice(lastSlash + 1) : normalized;
+  const ext = path.posix.extname(filename);
+  const stem = ext ? filename.slice(0, -ext.length) : filename;
+
+  const match = stem.match(/^(.+?)__([a-zA-Z][\w-]*)$/);
+  if (!match) return { langKey: null, baseSource: normalized };
+
+  return {
+    langKey: match[2],
+    baseSource: dir + match[1] + ext,
+  };
+}
+
+function inferI18nKeyFromSource(source) {
+  if (typeof source !== "string") return "";
+  const { baseSource } = parseLocalizedSource(source);
+  const normalized = trimSlashes(baseSource || source).replace(/\\/g, "/");
+  const ext = path.posix.extname(normalized);
+  const withoutExt = ext ? normalized.slice(0, -ext.length) : normalized;
+  const parts = withoutExt.split("/").filter(Boolean);
+  if (!parts.length) return "";
+
+  const last = parts[parts.length - 1];
+  if (last === "index" && parts.length >= 2) {
+    return parts[parts.length - 2];
+  }
+  return last;
+}
+
+function getI18nKey(item = {}) {
+  if (item.i18n_key) return item.i18n_key;
+
+  const fromSource = inferI18nKeyFromSource(item.source);
+  if (fromSource) return fromSource;
+
+  return item.slug || "";
 }
 
+// ─── 单个 post / page 的语言归属查询 ────────────────────────────────
+
 function getPageLanguageKey(page = {}, config = {}) {
   if (!isI18nEnabled(config)) {
-    const configuredLanguage = Array.isArray(config.language) ? config.language[0] : config.language;
-    return getLanguageKeyFromLocale(config, page.lang || page.language || configuredLanguage) || normalizeLanguageKey(page.lang || page.language || configuredLanguage) || getDefaultLanguageKey(config);
+    const fallback = Array.isArray(config.language) ? config.language[0] : config.language;
+    return getLanguageKeyFromLocale(config, page.lang || page.language || fallback) || getDefaultLanguageKey(config);
   }
 
-  const explicit = normalizeLanguageKey(page.i18n_lang || page.i18n?.lang || page.i18n?.language);
+  const explicit = normalizeLanguageKey(page.i18n_lang);
   if (explicit && getLanguage(config, explicit)?.key === explicit) return explicit;
 
-  const fromSource = getLanguageKeyFromSource(page.source || page.full_source || "", config);
+  const fromSource = parseLocalizedSource(page.source || page.full_source || "").langKey;
   if (fromSource) return fromSource;
 
-  const pathDescriptor = Object.getOwnPropertyDescriptor(page, "path");
-  const pathValue = pathDescriptor && typeof pathDescriptor.get !== "function" ? pathDescriptor.value : "";
-  const fromPath = getLanguageKeyFromPath(pathValue || page.canonical_path || "", config);
+  const fromPath = getLanguageKeyFromPath(page.path || page.canonical_path || "", config);
   if (fromPath) return fromPath;
 
   const fromLocale = getLanguageKeyFromLocale(config, page.lang || page.language);
@@ -154,30 +181,22 @@ function getPageLanguageKey(page = {}, config = {}) {
 
 function getPageLocale(page = {}, config = {}) {
   if (!isI18nEnabled(config)) {
-    const configuredLanguage = Array.isArray(config.language) ? config.language[0] : config.language;
-    return normalizeLocale(page.lang || page.language || configuredLanguage || "");
+    const fallback = Array.isArray(config.language) ? config.language[0] : config.language;
+    return normalizeLocale(page.lang || page.language || fallback || "");
   }
 
   const language = getLanguage(config, getPageLanguageKey(page, config));
   return language?.locale || normalizeLocale(page.lang || page.language) || "";
 }
 
-function getLanguageLabel(config = {}, keyOrLocale) {
-  const key = getLanguage(config, keyOrLocale)?.key === normalizeLanguageKey(keyOrLocale) ? normalizeLanguageKey(keyOrLocale) : getLanguageKeyFromLocale(config, keyOrLocale);
-  const language = getLanguage(config, key || getDefaultLanguageKey(config));
-  return language?.label || keyOrLocale;
-}
-
-function getLanguageBasePath(config = {}, key) {
-  return getLanguage(config, key)?.prefix || "";
-}
+// ─── 路径生成 ──────────────────────────────────────────────────────
 
 function joinRoute(...parts) {
   const joined = parts.map(trimSlashes).filter(Boolean).join("/");
   return joined ? `${joined}/` : "";
 }
 
-function stripLanguagePrefix(value, config = {}) {
+function stripLanguagePrefix(value, config) {
   const normalized = trimSlashes(value);
   const key = getLanguageKeyFromPath(normalized, config);
   if (!key) return normalized;
@@ -193,35 +212,12 @@ function localizePath(value, key, config = {}) {
 
   const [pathAndQuery, hash = ""] = value.split("#");
   const [pathname, query = ""] = pathAndQuery.split("?");
-  const route = stripLanguagePrefix(pathname, config);
+  const route = trimSlashes(stripLanguagePrefix(pathname, config));
   const base = trimSlashes(getLanguageBasePath(config, key || getDefaultLanguageKey(config)));
-  const normalizedRoute = trimSlashes(route);
-  const joined = [base, normalizedRoute].filter(Boolean).join("/");
-  const hasFileExtension = /\.[^/]+$/.test(normalizedRoute);
+  const joined = [base, route].filter(Boolean).join("/");
+  const hasFileExtension = /\.[^/]+$/.test(route);
   const localized = `/${joined}${joined && !hasFileExtension ? "/" : ""}`;
-  const queryPart = query ? `?${query}` : "";
-  const hashPart = hash ? `#${hash}` : "";
-  return `${localized}${queryPart}${hashPart}`;
-}
-
-function toArray(collection) {
-  if (!collection) return [];
-  if (typeof collection.toArray === "function") return collection.toArray();
-  if (Array.isArray(collection.data)) return collection.data;
-  if (Array.isArray(collection)) return collection;
-  return [];
-}
-
-function filterByLanguage(collection, key, config = {}) {
-  if (!isI18nEnabled(config)) return collection;
-  if (typeof collection?.filter === "function" && !Array.isArray(collection)) {
-    return collection.filter((item) => getPageLanguageKey(item, config) === key);
-  }
-  return toArray(collection).filter((item) => getPageLanguageKey(item, config) === key);
-}
-
-function getI18nKey(item = {}) {
-  return item.i18n_key || item.i18n?.key || item.translation_key || item.slug || inferI18nKeyFromSource(item.source);
+  return `${localized}${query ? `?${query}` : ""}${hash ? `#${hash}` : ""}`;
 }
 
 function getLocalizedTagPath(tag, key, config = {}) {
@@ -237,44 +233,34 @@ function getLocalizedTagPath(tag, key, config = {}) {
   return joinRoute(getLanguageBasePath(config, key), tagDir, slug);
 }
 
-function inferI18nKeyFromSource(source) {
-  if (typeof source !== "string") return "";
-  const normalized = trimSlashes(source).replace(/\\/g, "/");
-  const ext = path.posix.extname(normalized);
-  const withoutExt = ext ? normalized.slice(0, -ext.length) : normalized;
-  const parts = withoutExt.split("/").filter(Boolean);
-  if (!parts.length) return "";
+// ─── 集合按语言筛选 ────────────────────────────────────────────────
 
-  const last = parts[parts.length - 1];
-  if (last === "index" && parts.length >= 2) {
-    return parts[parts.length - 2];
+function filterByLanguage(collection, key, config = {}) {
+  if (!isI18nEnabled(config)) return collection;
+  // Hexo Query 对象：保留链式能力
+  if (typeof collection?.filter === "function" && !Array.isArray(collection)) {
+    return collection.filter((item) => getPageLanguageKey(item, config) === key);
   }
-
-  return last;
+  // 普通数组 / 含 toArray 的对象
+  const arr = Array.isArray(collection) ? collection : typeof collection?.toArray === "function" ? collection.toArray() : [];
+  return arr.filter((item) => getPageLanguageKey(item, config) === key);
 }
 
 module.exports = {
   filterByLanguage,
   getDefaultLanguageKey,
-  getI18nConfig,
   getI18nKey,
   getLanguage,
   getLanguageBasePath,
-  getLanguageKeyFromLocale,
-  getLanguageKeyFromPath,
-  getLanguageKeyFromSource,
   getLanguageKeys,
-  getLanguageLabel,
   getLocalizedTagPath,
   getPageLanguageKey,
   getPageLocale,
   inferI18nKeyFromSource,
   isExternalUrl,
   isI18nEnabled,
-  joinRoute,
   localizePath,
   normalizeLocale,
-  stripLanguagePrefix,
-  toArray,
+  parseLocalizedSource,
   trimSlashes,
 };