@actagent/diffs 2026.6.2

package/src/render.ts

@@ -0,0 +1,622 @@
+// Diffs plugin module implements render behavior.
+import type { FileContents, FileDiffMetadata, SupportedLanguages } from "@pierre/diffs";
+import { parsePatchFiles } from "@pierre/diffs";
+import { preloadFileDiff, preloadMultiFileDiff } from "@pierre/diffs/ssr";
+import { normalizeDiffFontSize, normalizeDiffLineSpacing } from "./config.js";
+import {
+  collectDiffPayloadLanguageHints,
+  isBaseDiffViewerLanguage,
+  normalizeDiffViewerPayloadLanguages,
+  normalizeSupportedLanguageHint,
+} from "./language-hints.js";
+import { ensurePierreThemesRegistered } from "./pierre-themes.js";
+import type {
+  DiffInput,
+  DiffRenderOptions,
+  DiffRenderTarget,
+  DiffViewerOptions,
+  DiffViewerPayload,
+  RenderedDiffDocument,
+} from "./types.js";
+
+const DEFAULT_FILE_NAME = "diff.txt";
+const MAX_PATCH_FILE_COUNT = 128;
+const MAX_PATCH_TOTAL_LINES = 120_000;
+const VIEWER_LOADER_DOCUMENT_PATH = "../../assets/viewer.js";
+const LANGUAGE_PACK_VIEWER_LOADER_DOCUMENT_PATH = "../../../diffs-language-pack/assets/viewer.js";
+
+function escapeCssString(value: string): string {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+function escapeJsonScript(value: unknown): string {
+  return JSON.stringify(value).replaceAll("<", "\\u003c");
+}
+
+function buildDiffTitle(input: DiffInput): string {
+  if (input.title?.trim()) {
+    return input.title.trim();
+  }
+  if (input.kind === "before_after") {
+    return input.path?.trim() || "Text diff";
+  }
+  return "Patch diff";
+}
+
+function resolveBeforeAfterFileName(params: {
+  input: Extract<DiffInput, { kind: "before_after" }>;
+  lang?: SupportedLanguages;
+}): string {
+  const { input, lang } = params;
+  if (input.path?.trim()) {
+    return input.path.trim();
+  }
+  if (lang && lang !== "text") {
+    return `diff.${lang.replace(/^\.+/, "")}`;
+  }
+  return DEFAULT_FILE_NAME;
+}
+
+function buildDiffOptions(options: DiffRenderOptions): DiffViewerOptions {
+  const fontFamily = escapeCssString(options.presentation.fontFamily);
+  const fontSize = normalizeDiffFontSize(options.presentation.fontSize);
+  const lineSpacing = normalizeDiffLineSpacing(options.presentation.lineSpacing);
+  const lineHeight = Math.max(20, Math.round(fontSize * lineSpacing));
+  return {
+    theme: {
+      light: "pierre-light",
+      dark: "pierre-dark",
+    },
+    diffStyle: options.presentation.layout,
+    diffIndicators: options.presentation.diffIndicators,
+    disableLineNumbers: !options.presentation.showLineNumbers,
+    expandUnchanged: options.expandUnchanged,
+    themeType: options.presentation.theme,
+    backgroundEnabled: options.presentation.background,
+    overflow: options.presentation.wordWrap ? "wrap" : "scroll",
+    unsafeCSS: `
+      :host {
+        --diffs-font-family: "${fontFamily}", "SF Mono", Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+        --diffs-header-font-family: "${fontFamily}", "SF Mono", Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+        --diffs-font-size: ${fontSize}px;
+        --diffs-line-height: ${lineHeight}px;
+      }
+
+      [data-diffs-header] {
+        min-height: 64px;
+        padding-inline: 18px 14px;
+      }
+
+      [data-header-content] {
+        gap: 10px;
+      }
+
+      [data-metadata] {
+        gap: 10px;
+      }
+
+      .oc-diff-toolbar {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+        margin-inline-start: 6px;
+        flex: 0 0 auto;
+      }
+
+      .oc-diff-toolbar-button {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        width: 24px;
+        height: 24px;
+        padding: 0;
+        margin: 0;
+        border: 0;
+        border-radius: 0;
+        background: transparent;
+        color: inherit;
+        cursor: pointer;
+        opacity: 0.6;
+        line-height: 0;
+        overflow: visible;
+        transition: opacity 120ms ease;
+        flex: 0 0 auto;
+      }
+
+      .oc-diff-toolbar-button:hover {
+        opacity: 1;
+      }
+
+      .oc-diff-toolbar-button[data-active="true"] {
+        opacity: 0.92;
+      }
+
+      .oc-diff-toolbar-button svg {
+        display: block;
+        width: 16px;
+        height: 16px;
+        min-width: 16px;
+        min-height: 16px;
+        overflow: visible;
+        flex: 0 0 auto;
+        color: inherit;
+        fill: currentColor;
+        pointer-events: none;
+      }
+    `,
+  };
+}
+
+function buildImageRenderOptions(options: DiffRenderOptions): DiffRenderOptions {
+  return {
+    ...options,
+    presentation: {
+      ...options.presentation,
+      fontSize: Math.max(16, normalizeDiffFontSize(options.presentation.fontSize)),
+    },
+  };
+}
+
+function shouldRenderViewer(target: DiffRenderTarget): boolean {
+  return target === "viewer" || target === "both";
+}
+
+function shouldRenderImage(target: DiffRenderTarget): boolean {
+  return target === "image" || target === "both";
+}
+
+function buildRenderVariants(params: { options: DiffRenderOptions; target: DiffRenderTarget }): {
+  viewerOptions?: DiffViewerOptions;
+  imageOptions?: DiffViewerOptions;
+} {
+  return {
+    ...(shouldRenderViewer(params.target)
+      ? { viewerOptions: buildDiffOptions(params.options) }
+      : {}),
+    ...(shouldRenderImage(params.target)
+      ? { imageOptions: buildDiffOptions(buildImageRenderOptions(params.options)) }
+      : {}),
+  };
+}
+
+function renderDiffCard(payload: DiffViewerPayload): string {
+  return `<section class="oc-diff-card">
+    <diffs-container class="oc-diff-host" data-actagent-diff-host>
+      <template shadowrootmode="open">${payload.prerenderedHTML}</template>
+    </diffs-container>
+    <script type="application/json" data-actagent-diff-payload>${escapeJsonScript(payload)}</script>
+  </section>`;
+}
+
+function buildHtmlDocument(params: {
+  title: string;
+  bodyHtml: string;
+  theme: DiffRenderOptions["presentation"]["theme"];
+  imageMaxWidth: number;
+  runtimeMode: "viewer" | "image";
+  viewerRuntime: "base" | "language-pack";
+}): string {
+  const viewerLoaderPath =
+    params.viewerRuntime === "language-pack"
+      ? LANGUAGE_PACK_VIEWER_LOADER_DOCUMENT_PATH
+      : VIEWER_LOADER_DOCUMENT_PATH;
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="color-scheme" content="dark light" />
+    <title>${escapeHtml(params.title)}</title>
+    <style>
+      * {
+        box-sizing: border-box;
+      }
+
+      html,
+      body {
+        min-height: 100%;
+      }
+
+      html {
+        background: #05070b;
+      }
+
+      body {
+        margin: 0;
+        min-height: 100vh;
+        padding: 22px;
+        font-family:
+          "Fira Code",
+          "SF Mono",
+          Monaco,
+          Consolas,
+          monospace;
+        background: #05070b;
+        color: #f8fafc;
+      }
+
+      body[data-theme="light"] {
+        background: #f3f5f8;
+        color: #0f172a;
+      }
+
+      .oc-frame {
+        max-width: 1560px;
+        margin: 0 auto;
+      }
+
+      .oc-frame[data-render-mode="image"] {
+        max-width: ${Math.max(640, Math.round(params.imageMaxWidth))}px;
+      }
+
+      [data-actagent-diff-root] {
+        display: grid;
+        gap: 18px;
+      }
+
+      .oc-diff-card {
+        overflow: hidden;
+        border-radius: 18px;
+        border: 1px solid rgba(148, 163, 184, 0.16);
+        background: rgba(15, 23, 42, 0.14);
+        box-shadow: 0 18px 48px rgba(2, 6, 23, 0.22);
+      }
+
+      body[data-theme="light"] .oc-diff-card {
+        border-color: rgba(148, 163, 184, 0.22);
+        background: rgba(255, 255, 255, 0.92);
+        box-shadow: 0 14px 32px rgba(15, 23, 42, 0.08);
+      }
+
+      .oc-diff-host {
+        display: block;
+      }
+
+      .oc-frame[data-render-mode="image"] .oc-diff-card {
+        min-height: 240px;
+      }
+
+      @media (max-width: 720px) {
+        body {
+          padding: 12px;
+        }
+
+        [data-actagent-diff-root] {
+          gap: 12px;
+        }
+      }
+    </style>
+  </head>
+  <body data-theme="${params.theme}">
+    <main class="oc-frame" data-render-mode="${params.runtimeMode}">
+      <div data-actagent-diff-root>
+        ${params.bodyHtml}
+      </div>
+    </main>
+    <script type="module" src="${viewerLoaderPath}"></script>
+  </body>
+</html>`;
+}
+
+type RenderedSection = {
+  viewer?: string;
+  image?: string;
+  usesLanguagePack?: boolean;
+};
+
+function payloadUsesLanguagePack(payload: DiffViewerPayload | undefined): boolean {
+  return payload?.langs.some((lang) => !isBaseDiffViewerLanguage(lang)) ?? false;
+}
+
+function buildRenderedSection(params: {
+  viewerPayload?: DiffViewerPayload;
+  imagePayload?: DiffViewerPayload;
+}): RenderedSection {
+  return {
+    ...(params.viewerPayload ? { viewer: renderDiffCard(params.viewerPayload) } : {}),
+    ...(params.imagePayload ? { image: renderDiffCard(params.imagePayload) } : {}),
+    usesLanguagePack:
+      payloadUsesLanguagePack(params.viewerPayload) || payloadUsesLanguagePack(params.imagePayload),
+  };
+}
+
+function buildRenderedBodies(sections: ReadonlyArray<RenderedSection>): {
+  viewerBodyHtml?: string;
+  imageBodyHtml?: string;
+} {
+  const viewerSections = sections.flatMap((section) => (section.viewer ? [section.viewer] : []));
+  const imageSections = sections.flatMap((section) => (section.image ? [section.image] : []));
+  return {
+    ...(viewerSections.length > 0 ? { viewerBodyHtml: viewerSections.join("\n") } : {}),
+    ...(imageSections.length > 0 ? { imageBodyHtml: imageSections.join("\n") } : {}),
+  };
+}
+
+async function renderBeforeAfterDiff(
+  input: Extract<DiffInput, { kind: "before_after" }>,
+  options: DiffRenderOptions,
+  target: DiffRenderTarget,
+): Promise<{
+  viewerBodyHtml?: string;
+  imageBodyHtml?: string;
+  fileCount: number;
+  usesLanguagePack: boolean;
+}> {
+  ensurePierreThemesRegistered();
+
+  const languagePackAvailable = options.languagePackAvailable === true;
+  const lang = await normalizeSupportedLanguageHint(input.lang, { languagePackAvailable });
+  const fileName = resolveBeforeAfterFileName({ input, lang });
+  const oldFile: FileContents = {
+    name: fileName,
+    contents: input.before,
+    ...(lang ? { lang } : {}),
+  };
+  const newFile: FileContents = {
+    name: fileName,
+    contents: input.after,
+    ...(lang ? { lang } : {}),
+  };
+  const { viewerOptions, imageOptions } = buildRenderVariants({ options, target });
+  const [viewerResult, imageResult] = await Promise.all([
+    viewerOptions
+      ? preloadMultiFileDiffWithFallback({
+          oldFile,
+          newFile,
+          options: viewerOptions,
+        })
+      : Promise.resolve(undefined),
+    imageOptions
+      ? preloadMultiFileDiffWithFallback({
+          oldFile,
+          newFile,
+          options: imageOptions,
+        })
+      : Promise.resolve(undefined),
+  ]);
+  const [viewerPayload, imagePayload] = await Promise.all([
+    viewerResult && viewerOptions
+      ? normalizeDiffViewerPayloadLanguages(
+          {
+            prerenderedHTML: viewerResult.prerenderedHTML,
+            oldFile: viewerResult.oldFile,
+            newFile: viewerResult.newFile,
+            options: viewerOptions,
+            langs: collectDiffPayloadLanguageHints({
+              oldFile: viewerResult.oldFile,
+              newFile: viewerResult.newFile,
+            }),
+          },
+          { languagePackAvailable },
+        )
+      : Promise.resolve(undefined),
+    imageResult && imageOptions
+      ? normalizeDiffViewerPayloadLanguages(
+          {
+            prerenderedHTML: imageResult.prerenderedHTML,
+            oldFile: imageResult.oldFile,
+            newFile: imageResult.newFile,
+            options: imageOptions,
+            langs: collectDiffPayloadLanguageHints({
+              oldFile: imageResult.oldFile,
+              newFile: imageResult.newFile,
+            }),
+          },
+          { languagePackAvailable },
+        )
+      : Promise.resolve(undefined),
+  ]);
+  const section = buildRenderedSection({
+    ...(viewerPayload ? { viewerPayload } : {}),
+    ...(imagePayload ? { imagePayload } : {}),
+  });
+
+  return {
+    ...buildRenderedBodies([section]),
+    fileCount: 1,
+    usesLanguagePack: section.usesLanguagePack === true,
+  };
+}
+
+async function renderPatchDiff(
+  input: Extract<DiffInput, { kind: "patch" }>,
+  options: DiffRenderOptions,
+  target: DiffRenderTarget,
+): Promise<{
+  viewerBodyHtml?: string;
+  imageBodyHtml?: string;
+  fileCount: number;
+  usesLanguagePack: boolean;
+}> {
+  ensurePierreThemesRegistered();
+
+  const languagePackAvailable = options.languagePackAvailable === true;
+  const files = await Promise.all(
+    parsePatchFiles(input.patch)
+      .flatMap((entry) => entry.files ?? [])
+      .map((fileDiff) => normalizePatchFileLanguage(fileDiff, { languagePackAvailable })),
+  );
+  if (files.length === 0) {
+    throw new Error("Patch input did not contain any file diffs.");
+  }
+  if (files.length > MAX_PATCH_FILE_COUNT) {
+    throw new Error(`Patch input contains too many files (max ${MAX_PATCH_FILE_COUNT}).`);
+  }
+  const totalLines = files.reduce((sum, fileDiff) => {
+    const splitLines = Number.isFinite(fileDiff.splitLineCount) ? fileDiff.splitLineCount : 0;
+    const unifiedLines = Number.isFinite(fileDiff.unifiedLineCount) ? fileDiff.unifiedLineCount : 0;
+    return sum + Math.max(splitLines, unifiedLines, 0);
+  }, 0);
+  if (totalLines > MAX_PATCH_TOTAL_LINES) {
+    throw new Error(`Patch input is too large to render (max ${MAX_PATCH_TOTAL_LINES} lines).`);
+  }
+
+  const { viewerOptions, imageOptions } = buildRenderVariants({ options, target });
+  const sections = await Promise.all(
+    files.map(async (fileDiff) => {
+      const [viewerResult, imageResult] = await Promise.all([
+        viewerOptions
+          ? preloadFileDiffWithFallback({
+              fileDiff,
+              options: viewerOptions,
+            })
+          : Promise.resolve(undefined),
+        imageOptions
+          ? preloadFileDiffWithFallback({
+              fileDiff,
+              options: imageOptions,
+            })
+          : Promise.resolve(undefined),
+      ]);
+
+      const [viewerPayload, imagePayload] = await Promise.all([
+        viewerResult && viewerOptions
+          ? normalizeDiffViewerPayloadLanguages(
+              {
+                prerenderedHTML: viewerResult.prerenderedHTML,
+                fileDiff: viewerResult.fileDiff,
+                options: viewerOptions,
+                langs: collectDiffPayloadLanguageHints({ fileDiff: viewerResult.fileDiff }),
+              },
+              { languagePackAvailable },
+            )
+          : Promise.resolve(undefined),
+        imageResult && imageOptions
+          ? normalizeDiffViewerPayloadLanguages(
+              {
+                prerenderedHTML: imageResult.prerenderedHTML,
+                fileDiff: imageResult.fileDiff,
+                options: imageOptions,
+                langs: collectDiffPayloadLanguageHints({ fileDiff: imageResult.fileDiff }),
+              },
+              { languagePackAvailable },
+            )
+          : Promise.resolve(undefined),
+      ]);
+
+      return buildRenderedSection({
+        ...(viewerPayload ? { viewerPayload } : {}),
+        ...(imagePayload ? { imagePayload } : {}),
+      });
+    }),
+  );
+
+  return {
+    ...buildRenderedBodies(sections),
+    fileCount: files.length,
+    usesLanguagePack: sections.some((section) => section.usesLanguagePack === true),
+  };
+}
+
+async function normalizePatchFileLanguage(
+  fileDiff: FileDiffMetadata,
+  options: { languagePackAvailable: boolean },
+): Promise<FileDiffMetadata> {
+  const lang = await normalizeSupportedLanguageHint(fileDiff.lang, options);
+  if (lang === fileDiff.lang) {
+    return fileDiff;
+  }
+  return {
+    ...fileDiff,
+    ...(lang ? { lang } : { lang: "text" }),
+  };
+}
+
+export async function renderDiffDocument(
+  input: DiffInput,
+  options: DiffRenderOptions,
+  target: DiffRenderTarget = "both",
+): Promise<RenderedDiffDocument> {
+  const title = buildDiffTitle(input);
+  const rendered =
+    input.kind === "before_after"
+      ? await renderBeforeAfterDiff(input, options, target)
+      : await renderPatchDiff(input, options, target);
+  const viewerRuntime = rendered.usesLanguagePack ? "language-pack" : "base";
+
+  return {
+    ...(rendered.viewerBodyHtml
+      ? {
+          html: buildHtmlDocument({
+            title,
+            bodyHtml: rendered.viewerBodyHtml,
+            theme: options.presentation.theme,
+            imageMaxWidth: options.image.maxWidth,
+            runtimeMode: "viewer",
+            viewerRuntime,
+          }),
+        }
+      : {}),
+    ...(rendered.imageBodyHtml
+      ? {
+          imageHtml: buildHtmlDocument({
+            title,
+            bodyHtml: rendered.imageBodyHtml,
+            theme: options.presentation.theme,
+            imageMaxWidth: options.image.maxWidth,
+            runtimeMode: "image",
+            viewerRuntime,
+          }),
+        }
+      : {}),
+    title,
+    fileCount: rendered.fileCount,
+    inputKind: input.kind,
+    viewerRuntime,
+  };
+}
+
+type PreloadedFileDiffResult = Awaited<ReturnType<typeof preloadFileDiff>>;
+type PreloadedMultiFileDiffResult = Awaited<ReturnType<typeof preloadMultiFileDiff>>;
+
+function shouldFallbackToClientHydration(error: unknown): boolean {
+  return (
+    error instanceof TypeError &&
+    error.message.includes('needs an import attribute of "type: json"')
+  );
+}
+
+async function preloadFileDiffWithFallback(params: {
+  fileDiff: FileDiffMetadata;
+  options: DiffViewerOptions;
+}): Promise<PreloadedFileDiffResult> {
+  try {
+    return await preloadFileDiff(params);
+  } catch (error) {
+    if (!shouldFallbackToClientHydration(error)) {
+      throw error;
+    }
+    return {
+      fileDiff: params.fileDiff,
+      prerenderedHTML: "",
+    };
+  }
+}
+
+async function preloadMultiFileDiffWithFallback(params: {
+  oldFile: FileContents;
+  newFile: FileContents;
+  options: DiffViewerOptions;
+}): Promise<PreloadedMultiFileDiffResult> {
+  try {
+    return await preloadMultiFileDiff(params);
+  } catch (error) {
+    if (!shouldFallbackToClientHydration(error)) {
+      throw error;
+    }
+    return {
+      oldFile: params.oldFile,
+      newFile: params.newFile,
+      prerenderedHTML: "",
+    };
+  }
+}

package/src/shiki-curated-languages.ts

@@ -0,0 +1,87 @@
+// Diffs plugin module implements shiki curated languages behavior.
+const javascript = () => import("@shikijs/langs/javascript");
+const typescript = () => import("@shikijs/langs/typescript");
+const tsx = () => import("@shikijs/langs/tsx");
+const jsx = () => import("@shikijs/langs/jsx");
+const json = () => import("@shikijs/langs/json");
+const markdown = () => import("@shikijs/langs/markdown");
+const yaml = () => import("@shikijs/langs/yaml");
+const css = () => import("@shikijs/langs/css");
+const html = () => import("@shikijs/langs/html");
+const sh = () => import("@shikijs/langs/sh");
+const python = () => import("@shikijs/langs/python");
+const go = () => import("@shikijs/langs/go");
+const rust = () => import("@shikijs/langs/rust");
+const java = () => import("@shikijs/langs/java");
+const c = () => import("@shikijs/langs/c");
+const cpp = () => import("@shikijs/langs/cpp");
+const csharp = () => import("@shikijs/langs/csharp");
+const php = () => import("@shikijs/langs/php");
+const sql = () => import("@shikijs/langs/sql");
+const docker = () => import("@shikijs/langs/docker");
+const ruby = () => import("@shikijs/langs/ruby");
+const swift = () => import("@shikijs/langs/swift");
+const kotlin = () => import("@shikijs/langs/kotlin");
+const r = () => import("@shikijs/langs/r");
+const dart = () => import("@shikijs/langs/dart");
+const lua = () => import("@shikijs/langs/lua");
+const powershell = () => import("@shikijs/langs/powershell");
+const xml = () => import("@shikijs/langs/xml");
+const toml = () => import("@shikijs/langs/toml");
+
+type CuratedLanguageInfo = {
+  readonly id: string;
+  readonly name: string;
+  readonly aliases?: readonly string[];
+  readonly import: () => Promise<unknown>;
+};
+
+export const bundledLanguagesInfo = [
+  { id: "javascript", name: "JavaScript", aliases: ["js", "mjs", "cjs"], import: javascript },
+  { id: "typescript", name: "TypeScript", aliases: ["ts", "mts", "cts"], import: typescript },
+  { id: "tsx", name: "TSX", import: tsx },
+  { id: "jsx", name: "JSX", import: jsx },
+  { id: "json", name: "JSON", aliases: ["jsonc", "json5", "jsonl"], import: json },
+  { id: "markdown", name: "Markdown", aliases: ["md"], import: markdown },
+  { id: "yaml", name: "YAML", aliases: ["yml"], import: yaml },
+  { id: "css", name: "CSS", import: css },
+  { id: "html", name: "HTML", import: html },
+  { id: "sh", name: "Shell", aliases: ["bash", "shell", "shellscript", "zsh"], import: sh },
+  { id: "python", name: "Python", aliases: ["py"], import: python },
+  { id: "go", name: "Go", import: go },
+  { id: "rust", name: "Rust", aliases: ["rs"], import: rust },
+  { id: "java", name: "Java", import: java },
+  { id: "c", name: "C", import: c },
+  { id: "cpp", name: "C++", aliases: ["c++"], import: cpp },
+  { id: "csharp", name: "C#", aliases: ["c#", "cs"], import: csharp },
+  { id: "php", name: "PHP", import: php },
+  { id: "sql", name: "SQL", import: sql },
+  { id: "docker", name: "Docker", aliases: ["dockerfile"], import: docker },
+  { id: "ruby", name: "Ruby", aliases: ["rb"], import: ruby },
+  { id: "swift", name: "Swift", import: swift },
+  { id: "kotlin", name: "Kotlin", aliases: ["kt", "kts"], import: kotlin },
+  { id: "r", name: "R", import: r },
+  { id: "dart", name: "Dart", import: dart },
+  { id: "lua", name: "Lua", import: lua },
+  { id: "powershell", name: "PowerShell", aliases: ["ps", "ps1"], import: powershell },
+  { id: "xml", name: "XML", import: xml },
+  { id: "toml", name: "TOML", import: toml },
+] as const satisfies readonly CuratedLanguageInfo[];
+
+export const bundledLanguagesBase = Object.fromEntries(
+  bundledLanguagesInfo.map((language) => [language.id, language.import]),
+);
+export function getBundledLanguageAliases(
+  language: (typeof bundledLanguagesInfo)[number],
+): readonly string[] {
+  return "aliases" in language ? language.aliases : [];
+}
+export const bundledLanguagesAlias = Object.fromEntries(
+  bundledLanguagesInfo.flatMap((language) =>
+    getBundledLanguageAliases(language).map((alias) => [alias, language.import]),
+  ),
+);
+export const bundledLanguages = {
+  ...bundledLanguagesBase,
+  ...bundledLanguagesAlias,
+};