website

import Prism from "prismjs";
import loadPrismLanguage from "prismjs/components/index.js";

// Avoid "Language does not exist" console noise for extensions we don't
// have a mapping for — those just fall back to plain, unhighlighted text.
loadPrismLanguage.silent = true;

// File-extension -> Prism language name, for the cases where they don't
// already match (or where Prism has no component at all, mapped to null
// so we skip straight to plain text instead of a failed load attempt).
const EXT_TO_LANG = {
  h: "c",
  html: "markup",
  jsonc: "json",
  kt: "kotlin",
  lock: "toml",
  md: "markdown",
  mdx: "markdown",
  mjs: "javascript",
  plist: "markup",
  rs: "rust",
  scm: "scheme",
  sh: "bash",
  ts: "typescript",
  mi: null,
  nu: null,
  plum: null,
  txt: null,
  typ: null,
};

// Fenced-code-block language identifiers (the "rust" in ```rust) mostly
// already match Prism's own component ids, unlike file extensions —
// except for a handful of common short forms people actually type in
// READMEs, which need the same kind of aliasing EXT_TO_LANG does above.
const FENCE_LANG_ALIASES = {
  js: "javascript",
  sh: "bash",
  rs: "rust",
  ts: "typescript",
  yml: "yaml",
  html: "markup",
  htm: "markup",
};

const grammarCache = new Map();

/** Load (and cache) a Prism grammar by its canonical component id. */
const loadGrammar = (lang) => {
  if (grammarCache.has(lang)) return grammarCache.get(lang);
  if (!Prism.languages[lang]) loadPrismLanguage(lang);
  const grammar = Prism.languages[lang] ?? null;
  const result = grammar ? { lang, grammar } : null;
  grammarCache.set(lang, result);
  return result;
};

const getLanguage = (ext) => {
  const lang = Object.prototype.hasOwnProperty.call(EXT_TO_LANG, ext) ? EXT_TO_LANG[ext] : ext;
  return lang ? loadGrammar(lang) : null;
};

/**
 * Highlight source text for a given file extension using Prism, at build
 * time — no client-side highlighter ships to the browser. Falls back to
 * (still-escaped) plain text when there's no Prism grammar for the
 * extension.
 *
 * @returns {{ html: string, lang: string }}
 */
export const highlightCode = (text, ext) => {
  const found = getLanguage(ext);
  if (!found) {
    return { html: escapeHtml(text), lang: ext || "text" };
  }
  return { html: Prism.highlight(text, found.grammar, found.lang), lang: found.lang };
};

/**
 * Highlight a fenced markdown code block by its declared language (the
 * "rust" in ```rust), for markdown-it's `highlight` option — used for
 * repo READMEs, which render through a separate MarkdownIt instance
 * rather than highlightCode()'s extension-keyed lookup. markdown-it
 * wraps whatever this returns in <pre><code class="language-{lang}">,
 * matching the shared pre/code styling and .token.* colors in
 * shared.css. Falls back to plain escaped text, same as highlightCode.
 *
 * @returns {string} inner HTML for markdown-it's fence renderer
 */
export const highlightFenceCode = (text, lang) => {
  const normalized = lang ? (FENCE_LANG_ALIASES[lang.toLowerCase()] ?? lang.toLowerCase()) : null;
  const found = normalized ? loadGrammar(normalized) : null;
  return found ? Prism.highlight(text, found.grammar, found.lang) : escapeHtml(text);
};

const escapeHtml = (str) =>
  String(str).replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);