hexo-theme-gnix 8.0.0 → 10.0.0

package/include/hexo/i18n.js

@@ -0,0 +1,183 @@
+const { extname } = require("node:path");
+const createPostProcessor = require("hexo/dist/plugins/processor/post");
+const { isHiddenFile, isMatch, isTmpFile } = require("hexo/dist/plugins/processor/common");
+const {
+  getI18nKey,
+  getLanguageBasePath,
+  getLanguage,
+  getLanguageKeys,
+  getPageLanguageKey,
+  inferI18nKeyFromSource,
+  isI18nEnabled,
+  localizePath,
+  trimSlashes,
+} = require("../util/i18n");
+
+function getConfig(hexo, locals = {}) {
+  return Object.assign({}, hexo.config, hexo.config.theme_config, hexo.theme.config, locals.theme);
+}
+
+function getLocalizedPostParams(hexo, sourcePath) {
+  const config = getConfig(hexo);
+  if (!isI18nEnabled(config) || isTmpFile(sourcePath)) return null;
+
+  const match = sourcePath.replace(/\\/g, "/").match(/^([^/]+)\/(_posts|_drafts)\/(.+)$/);
+  if (!match) return null;
+
+  const langKey = match[1];
+  if (!getLanguageKeys(config).includes(langKey)) return null;
+
+  const postPath = match[3];
+  if (isHiddenFile(postPath)) return null;
+
+  let renderable = hexo.render.isRenderable(sourcePath) && !isMatch(sourcePath, hexo.config.skip_render);
+  if (renderable && hexo.config.post_asset_folder) {
+    renderable = extname(hexo.config.new_post_name) === extname(sourcePath);
+  }
+
+  return {
+    i18n_lang: langKey,
+    path: postPath,
+    published: match[2] === "_posts",
+    renderable,
+  };
+}
+
+function getLocalizedPageParams(hexo, sourcePath) {
+  const config = getConfig(hexo);
+  if (!isI18nEnabled(config) || isTmpFile(sourcePath)) return null;
+
+  const normalized = sourcePath.replace(/\\/g, "/");
+  const match = normalized.match(/^([^/]+)\/(.+)$/);
+  if (!match) return null;
+
+  const langKey = match[1];
+  if (!getLanguageKeys(config).includes(langKey)) return null;
+
+  const pagePath = match[2];
+  if (pagePath.startsWith("_posts/") || pagePath.startsWith("_drafts/") || isHiddenFile(pagePath)) return null;
+
+  const renderable = hexo.render.isRenderable(sourcePath) && !isMatch(sourcePath, hexo.config.skip_render);
+  if (!renderable) return null;
+
+  return {
+    i18n_lang: langKey,
+  };
+}
+
+function buildPostI18nUpdate(post, langKey, config) {
+  const language = getLanguage(config, langKey);
+  const update = {
+    i18n_path: getLanguageBasePath(config, langKey),
+    i18n_lang: langKey,
+    lang: language.locale,
+    language: language.locale,
+  };
+
+  if (!post.i18n_key) {
+    update.i18n_key = getI18nKey(post) || inferI18nKeyFromSource(post.source);
+  }
+
+  return { $set: update };
+}
+
+function getLocalizedPagePath(page, langKey, config) {
+  const sourcePrefix = `${trimSlashes(langKey)}/`;
+  let route = page.path || "";
+
+  if (route.startsWith(sourcePrefix)) {
+    route = route.slice(sourcePrefix.length);
+  }
+
+  return trimSlashes(localizePath(`/${route}`, langKey, config));
+}
+
+function buildPageI18nUpdate(page, langKey, config) {
+  const language = getLanguage(config, langKey);
+  const update = {
+    i18n_path: getLanguageBasePath(config, langKey),
+    i18n_lang: langKey,
+    lang: language.locale,
+    language: language.locale,
+    path: getLocalizedPagePath(page, langKey, config),
+  };
+
+  if (!page.i18n_key) {
+    update.i18n_key = getI18nKey(page) || inferI18nKeyFromSource(page.source);
+  }
+
+  return { $set: update };
+}
+
+module.exports = (hexo) => {
+  const defaultPostProcessor = createPostProcessor(hexo);
+
+  hexo.extend.processor.register(
+    (sourcePath) => getLocalizedPostParams(hexo, sourcePath),
+    (file) =>
+      Promise.resolve(defaultPostProcessor.process(file)).then(() => {
+        if (!isI18nEnabled(getConfig(hexo))) return null;
+        if (!file.params.renderable) return null;
+
+        const post = hexo.model("Post").findOne({ source: file.path });
+        if (!post) return null;
+
+        return post.update(buildPostI18nUpdate(post, file.params.i18n_lang, getConfig(hexo)));
+      }),
+  );
+
+  hexo.extend.processor.register(
+    (sourcePath) => getLocalizedPageParams(hexo, sourcePath),
+    (file) => {
+      if (!isI18nEnabled(getConfig(hexo))) return null;
+      if (file.type === "delete") return null;
+
+      const page = hexo.model("Page").findOne({ source: file.path });
+      if (!page) return null;
+
+      return page.update(buildPageI18nUpdate(page, file.params.i18n_lang, getConfig(hexo)));
+    },
+  );
+
+  hexo.extend.filter.register(
+    "post_permalink",
+    (post) => {
+      if (!post || typeof post !== "object") return post;
+      const activeConfig = getConfig(hexo);
+      if (!isI18nEnabled(activeConfig)) return post;
+
+      const langKey = getPageLanguageKey(post, activeConfig);
+      const language = getLanguage(activeConfig, langKey);
+
+      post.i18n_lang = post.i18n_lang || langKey;
+      post.i18n_path = getLanguageBasePath(activeConfig, langKey);
+      post.lang = language.locale;
+      post.language = language.locale;
+      post.i18n_key = post.i18n_key || getI18nKey(post) || inferI18nKeyFromSource(post.source);
+
+      return post;
+    },
+    5,
+  );
+
+  hexo.extend.filter.register(
+    "template_locals",
+    (locals) => {
+      const page = locals.page;
+      const activeConfig = getConfig(hexo, locals);
+      if (!page || !isI18nEnabled(activeConfig)) return locals;
+
+      const langKey = getPageLanguageKey(page, activeConfig);
+      const language = getLanguage(activeConfig, langKey);
+
+      page.i18n_lang = page.i18n_lang || langKey;
+      page.i18n_path = getLanguageBasePath(activeConfig, langKey);
+      page.lang = language.locale;
+      page.language = language.locale;
+      page.i18n_key = page.i18n_key || getI18nKey(page) || inferI18nKeyFromSource(page.source);
+
+      return locals;
+    },
+    5,
+  );
+};

package/include/util/article_font.js

@@ -0,0 +1,132 @@
+const STORAGE_KEY = "gnix-article-font";
+
+const DEFAULT_SETTINGS = Object.freeze({
+  size: "medium",
+  type: "serif",
+  lineHeight: 1.7,
+  weight: "regular",
+});
+
+const SIZE_OPTIONS = Object.freeze(["small", "medium-small", "medium", "medium-large", "large"]);
+const FONT_OPTIONS = Object.freeze(["serif", "sans-serif", "mono", "handwriting"]);
+const WEIGHT_OPTIONS = Object.freeze(["light", "regular", "medium"]);
+const LINE_HEIGHT = Object.freeze({
+  min: 1.45,
+  max: 1.9,
+});
+
+const CUSTOM_FONT_FAMILY_OPTIONS = Object.freeze({
+  serif: "--font-serif",
+  "sans-serif": "--font-sans-serif",
+  mono: "--font-mono",
+  handwriting: "--font-handwriting",
+});
+
+const CUSTOM_FONT_IMPORT_LIMIT = 6;
+
+function getClientArticleFontConfig() {
+  return {
+    storageKey: STORAGE_KEY,
+    defaultSettings: DEFAULT_SETTINGS,
+    sizeOptions: SIZE_OPTIONS,
+    fontOptions: FONT_OPTIONS,
+    weightOptions: WEIGHT_OPTIONS,
+    lineHeight: LINE_HEIGHT,
+    customFonts: {
+      familyOptions: CUSTOM_FONT_FAMILY_OPTIONS,
+      importLimit: CUSTOM_FONT_IMPORT_LIMIT,
+    },
+  };
+}
+
+function stringifyForScript(value) {
+  return JSON.stringify(value)
+    .replace(/</g, "\\u003c")
+    .replace(/\u2028/g, "\\u2028")
+    .replace(/\u2029/g, "\\u2029");
+}
+
+function getArticleFontInitScript() {
+  const config = stringifyForScript(getClientArticleFontConfig());
+
+  return `
+(function() {
+  var config = ${config};
+  var defaults = config.defaultSettings || {};
+  var stored = null;
+  var parsed = {};
+  var utils = window.__GNIX_ARTICLE_FONT_UTILS__ || {};
+
+  window.__GNIX_ARTICLE_FONT_CONFIG__ = config;
+
+  try {
+    stored = localStorage.getItem(config.storageKey);
+  } catch (_) {}
+
+  if (stored) {
+    try {
+      parsed = JSON.parse(stored) || {};
+    } catch (_) {}
+  }
+
+  function hasOption(options, value) {
+    return Array.isArray(options) && options.indexOf(value) !== -1;
+  }
+
+  function normalizeLineHeight(value) {
+    if (value === "compact") return 1.55;
+    if (value === "normal") return 1.7;
+    if (value === "relaxed") return 1.85;
+
+    var parsedValue = Number(value);
+    var min = Number(config.lineHeight && config.lineHeight.min);
+    var max = Number(config.lineHeight && config.lineHeight.max);
+    var fallback = Number(defaults.lineHeight);
+
+    if (!Number.isFinite(parsedValue)) parsedValue = Number.isFinite(fallback) ? fallback : 1.7;
+    if (!Number.isFinite(min)) min = 1.45;
+    if (!Number.isFinite(max)) max = 1.9;
+
+    return Math.min(max, Math.max(min, parsedValue));
+  }
+
+  var candidate = Object.assign({}, defaults, parsed);
+  var customFonts = utils.normalizeCustomFonts
+    ? utils.normalizeCustomFonts(
+        candidate.customFonts,
+        config.customFonts && config.customFonts.familyOptions,
+        config.customFonts && config.customFonts.importLimit
+      )
+    : { imports: [], families: {} };
+  var settings = {
+    size: hasOption(config.sizeOptions, candidate.size) ? candidate.size : defaults.size,
+    type: hasOption(config.fontOptions, candidate.type) ? candidate.type : defaults.type,
+    lineHeight: normalizeLineHeight(candidate.lineHeight),
+    weight: hasOption(config.weightOptions, candidate.weight) ? candidate.weight : defaults.weight,
+    customFonts: customFonts
+  };
+  var html = document.documentElement;
+
+  if (utils.applyCustomFontImports) utils.applyCustomFontImports(settings.customFonts.imports);
+  if (utils.applyCustomFontFamilies) utils.applyCustomFontFamilies(html, settings.customFonts.families, config.customFonts && config.customFonts.familyOptions);
+  html.setAttribute("data-article-font-size", settings.size);
+  html.setAttribute("data-article-font-family", settings.type);
+  html.setAttribute("data-article-line-height", String(settings.lineHeight));
+  html.setAttribute("data-article-font-weight", settings.weight);
+  html.style.setProperty("--article-line-height", String(settings.lineHeight));
+})();
+`;
+}
+
+module.exports = {
+  CUSTOM_FONT_FAMILY_OPTIONS,
+  CUSTOM_FONT_IMPORT_LIMIT,
+  DEFAULT_SETTINGS,
+  FONT_OPTIONS,
+  LINE_HEIGHT,
+  SIZE_OPTIONS,
+  STORAGE_KEY,
+  WEIGHT_OPTIONS,
+  getArticleFontInitScript,
+  getClientArticleFontConfig,
+};

package/include/util/i18n.js

@@ -0,0 +1,280 @@
+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, "");
+}
+
+function normalizeLanguageKey(value) {
+  return trimSlashes(value).trim();
+}
+
+function normalizePrefix(value, fallback) {
+  const prefix = trimSlashes(value == null ? fallback : value);
+  return prefix ? `${prefix}/` : "";
+}
+
+function normalizeLocale(value) {
+  return String(value || "").replace(/_/g, "-");
+}
+
+function isExternalUrl(value) {
+  return /^(?:[a-z][a-z\d+.-]*:)?\/\//i.test(value) || /^(?:mailto|tel|data):/i.test(value) || value.startsWith("#");
+}
+
+const i18nConfigCache = new WeakMap();
+
+function getI18nConfig(config = {}) {
+  if (i18nConfigCache.has(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 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;
+    languages[normalizedKey] = {
+      key: normalizedKey,
+      label: value.label || value.name || locale || normalizedKey,
+      locale,
+      prefix: normalizePrefix(prefix, normalizedKey),
+    };
+  });
+
+  const keys = Object.keys(languages);
+  const configuredDefault = normalizeLanguageKey(raw.default || raw.default_language || raw.defaultLanguage || keys[0]);
+  const defaultLanguage = languages[configuredDefault] ? configuredDefault : keys[0];
+
+  const result = {
+    enabled: raw.enabled === true,
+    defaultLanguage,
+    languages,
+  };
+
+  i18nConfigCache.set(config, result);
+  return result;
+}
+
+function isI18nEnabled(config = {}) {
+  return getI18nConfig(config).enabled;
+}
+
+function getLanguageKeys(config = {}) {
+  return Object.keys(getI18nConfig(config).languages);
+}
+
+function getDefaultLanguageKey(config = {}) {
+  return getI18nConfig(config).defaultLanguage;
+}
+
+function getLanguage(config = {}, key) {
+  const i18n = getI18nConfig(config);
+  const normalizedKey = normalizeLanguageKey(key);
+  return i18n.languages[normalizedKey] || i18n.languages[i18n.defaultLanguage];
+}
+
+function getLanguageKeyFromLocale(config = {}, locale) {
+  const normalizedLocale = normalizeLocale(locale).toLowerCase();
+  if (!normalizedLocale) return null;
+
+  const i18n = getI18nConfig(config);
+  if (i18n.languages[normalizedLocale]) return normalizedLocale;
+
+  return (
+    Object.keys(i18n.languages).find((key) => {
+      const language = i18n.languages[key];
+      return language.locale.toLowerCase() === normalizedLocale;
+    }) || null
+  );
+}
+
+function getLanguageKeyFromPath(value, config = {}) {
+  const normalized = trimSlashes(value);
+  if (!normalized) return null;
+
+  const i18n = getI18nConfig(config);
+  return (
+    Object.keys(i18n.languages).find((key) => {
+      const prefix = trimSlashes(i18n.languages[key].prefix);
+      return prefix && (normalized === prefix || normalized.startsWith(`${prefix}/`));
+    }) || null
+  );
+}
+
+function getLanguageKeyFromSource(value, config = {}) {
+  const normalized = trimSlashes(value).replace(/\\/g, "/");
+  if (!normalized) return null;
+
+  const firstSegment = normalized.split("/")[0];
+  const i18n = getI18nConfig(config);
+  return i18n.languages[firstSegment] ? firstSegment : null;
+}
+
+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 explicit = normalizeLanguageKey(page.i18n_lang || page.i18n?.lang || page.i18n?.language);
+  if (explicit && getLanguage(config, explicit)?.key === explicit) return explicit;
+
+  const fromSource = getLanguageKeyFromSource(page.source || page.full_source || "", config);
+  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);
+  if (fromPath) return fromPath;
+
+  const fromLocale = getLanguageKeyFromLocale(config, page.lang || page.language);
+  if (fromLocale) return fromLocale;
+
+  return getDefaultLanguageKey(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 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 = {}) {
+  const normalized = trimSlashes(value);
+  const key = getLanguageKeyFromPath(normalized, config);
+  if (!key) return normalized;
+
+  const prefix = trimSlashes(getLanguageBasePath(config, key));
+  return normalized.slice(prefix.length).replace(/^\/+/, "");
+}
+
+function localizePath(value, key, config = {}) {
+  if (!isI18nEnabled(config) || typeof value !== "string" || !value.trim() || isExternalUrl(value)) {
+    return value;
+  }
+
+  const [pathAndQuery, hash = ""] = value.split("#");
+  const [pathname, query = ""] = pathAndQuery.split("?");
+  const route = 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 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);
+}
+
+function getLocalizedTagPath(tag, key, config = {}) {
+  const tagDir = config.tag_dir || "tags";
+  const tagPath = typeof tag === "string" ? tag : tag?.path || tag?.slug || tag?.name || "";
+  let slug = trimSlashes(tagPath);
+  const tagDirPrefix = `${trimSlashes(tagDir)}/`;
+
+  if (slug.startsWith(tagDirPrefix)) {
+    slug = slug.slice(tagDirPrefix.length);
+  }
+
+  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];
+  }
+
+  return last;
+}
+
+module.exports = {
+  filterByLanguage,
+  getDefaultLanguageKey,
+  getI18nConfig,
+  getI18nKey,
+  getLanguage,
+  getLanguageBasePath,
+  getLanguageKeyFromLocale,
+  getLanguageKeyFromPath,
+  getLanguageKeyFromSource,
+  getLanguageKeys,
+  getLanguageLabel,
+  getLocalizedTagPath,
+  getPageLanguageKey,
+  getPageLocale,
+  inferI18nKeyFromSource,
+  isExternalUrl,
+  isI18nEnabled,
+  joinRoute,
+  localizePath,
+  normalizeLocale,
+  stripLanguagePrefix,
+  toArray,
+  trimSlashes,
+};

package/include/util/theme.js

@@ -0,0 +1,84 @@
+const STORAGE_KEY = "themePreference";
+const DEFAULT_THEME = "system";
+
+const SYSTEM_THEME = Object.freeze({
+  dark: "mocha",
+  light: "nord",
+});
+
+const THEME_OPTIONS = Object.freeze([
+  { label: "SYSTEM", name: "System", value: DEFAULT_THEME },
+  { label: "LATTE", name: "Catppuccin Latte", value: "latte", colorScheme: "light" },
+  { label: "NORD", name: "Nord Light", value: "nord", colorScheme: "light" },
+  { label: "SONG CI", name: "Song Porcelain", value: "song_ci", colorScheme: "light" },
+  { label: "NORD NIGHT", name: "Nord Night", value: "nord_night", colorScheme: "night" },
+  { label: "ROSE PINE", name: "Rosé Pine", value: "rose_pine", colorScheme: "night" },
+  { label: "MOCHA", name: "Catppuccin Mocha", value: "mocha", colorScheme: "night" },
+  { label: "TOKYO NIGHT", name: "Tokyo Night", value: "tokyo_night", colorScheme: "night" },
+]);
+
+function getConcreteThemeOptions() {
+  return THEME_OPTIONS.filter((theme) => theme.value !== DEFAULT_THEME);
+}
+
+function getThemeClassMap() {
+  return Object.fromEntries(getConcreteThemeOptions().map((theme) => [theme.value, theme.colorScheme]));
+}
+
+function getClientThemeConfig() {
+  return {
+    storageKey: STORAGE_KEY,
+    defaultTheme: DEFAULT_THEME,
+    systemTheme: SYSTEM_THEME,
+    themes: THEME_OPTIONS,
+    themeClassMap: getThemeClassMap(),
+  };
+}
+
+function stringifyForScript(value) {
+  return JSON.stringify(value)
+    .replace(/</g, "\\u003c")
+    .replace(/\u2028/g, "\\u2028")
+    .replace(/\u2029/g, "\\u2029");
+}
+
+function getThemeInitScript() {
+  const config = stringifyForScript(getClientThemeConfig());
+
+  return `
+(function() {
+  var config = ${config};
+  var themeClassMap = config.themeClassMap || {};
+  var stored = null;
+
+  window.__GNIX_THEME_CONFIG__ = config;
+
+  try {
+    stored = localStorage.getItem(config.storageKey);
+  } catch (_) {}
+
+  var theme = stored === config.defaultTheme || Object.prototype.hasOwnProperty.call(themeClassMap, stored)
+    ? stored
+    : config.defaultTheme;
+  var resolvedTheme = theme === config.defaultTheme
+    ? window.matchMedia("(prefers-color-scheme: dark)").matches ? config.systemTheme.dark : config.systemTheme.light
+    : theme;
+  var html = document.documentElement;
+  var themeClass = themeClassMap[resolvedTheme];
+
+  html.setAttribute("data-theme", resolvedTheme);
+  if (themeClass) html.classList.add(themeClass);
+})();
+`;
+}
+
+module.exports = {
+  DEFAULT_THEME,
+  STORAGE_KEY,
+  SYSTEM_THEME,
+  THEME_OPTIONS,
+  getClientThemeConfig,
+  getConcreteThemeOptions,
+  getThemeClassMap,
+  getThemeInitScript,
+};