Konfiguration

Ardos CLI liest optionale Einstellungen aus ardo.config.ts. Meist brauchst du keine Vite-Konfiguration: ardo dev, ardo build und ardo preview liefern die Integration. Die Oberfläche konfigurierst du in React über ArdoRoot, Props für Kopfzeile, Seitenleiste und Fußzeile, Komponentenüberschreibungen und Runtime-Hooks.

Diese Seite beschreibt Website- und Build-Optionen sowie die React-Komponenten und Hooks. Bestehende Vite-Projekte können während der Migration weiter ardo() nutzen. Eine Übersicht einschließlich geplanter Funktionen findest du unter Releases.

Grundkonfiguration

import { defineArdoConfig } from "ardo/config"

export default defineArdoConfig({
  title: "My Documentation",
  description: "My awesome docs",
})

defineArdoConfig() akzeptiert dieselben Ardo-Optionen wie das Vite-Plugin. Ergänze vite.config.ts nur für weitere Plugins oder Vite-Einstellungen; die CLI bindet Ardos Plugins automatisch ein.

So konfigurierst du etwa den Entwicklungsserver ohne zusätzlichen ardo()-Aufruf:

import { defineConfig } from "ardo/vite"

export default defineConfig({
  server: { port: 4000 },
})

Ardo exportiert defineConfig weiter. Eine direkte Vite-Abhängigkeit ist deshalb unnötig.

Beide Dateien können ein Objekt, ein Promise oder einen Callback mit Vites Konfigurationsumgebung exportieren. Änderungen an vorhandenen Dateien starten den Entwicklungsserver neu. Nach dem Anlegen oder Entfernen einer Datei musst du ardo dev neu starten.

Verschiebe bei einer Migration die Optionen aus ardo({...}) nach ardo.config.ts, bevor du das Plugin entfernst. Ardo meldet einen Fehler, wenn beide Varianten im selben Projekt aktiv bleiben.

Website-Einstellungen

Diese Optionen bestimmen Identität und Grundverhalten deiner Dokumentationswebsite.

title

• Typ:string
• Standard: das Feld name aus package.json, sonst "Ardo"

Titel der Website für das Standard-<title> und die Kopfzeile. Setze ihn in ardo.config.ts, wenn der Paketname nicht der Titel ist, den Leser sehen sollen.

defineArdoConfig({
  title: "My Documentation",
})

description

• Typ:string
• Standard:""

Beschreibung der Website für die Standard-Metatags.

defineArdoConfig({
  title: "My Docs",
  description: "A comprehensive guide to my library",
})

titleSeparator

• Typ:string
• Standard:" | "

Trennzeichen zwischen Seiten- und Website-Titel im <title>. Die Seite „Getting Started“ ergibt beispielsweise Getting Started | My Docs.

defineArdoConfig({
  title: "My Docs",
  titleSeparator: " - ",
})

base

• Typ:string
• Standard:"/"

Basispfad der Website. Setze ihn, wenn die Dokumentation unter einem Unterpfad liegt.

defineArdoConfig({
  title: "My Docs",
  base: "/docs/",
})

siteUrl

• Typ:string
• Standard:""

Absolute öffentliche Website-URL. Ardo erzeugt damit kanonische URLs, og:url und absolute URLs für Social-Media-Bilder auf Markdown-Routen.

defineArdoConfig({
  title: "My Docs",
  siteUrl: "https://example.com",
})

Konfiguriere für Unterpfade zusätzlich base. Ardo kombiniert siteUrl, base und den Routenpfad zu kanonischen URLs.

metadata

• Typ:{ image?: string; ogType?: string; twitterCard?: "summary_large_image" | "summary"; twitterSite?: string }
• Standard:{}

Websiteweite Standardwerte für Markdown-Metadaten. Frontmatter kann sie je Seite überschreiben.

defineArdoConfig({
  title: "My Docs",
  siteUrl: "https://example.com",
  metadata: {
    image: "/social.png",
    ogType: "website",
    twitterCard: "summary_large_image",
    twitterSite: "@example",
  },
})

seo.llms

• Typ:boolean | { indexFileName?: string; fullFileName?: string; includeFull?: boolean; title?: string; description?: string }
• Standard:true

Erzeugt LLM-freundliche Textdateien neben den übrigen Build-Artefakten:

• /llms.txt ist ein knapper Markdown-Index der Markdown- und MDX-Routen. Er folgt der Seitenleiste: Abschnitte in Tab-Reihenfolge, Seiten nach order, damit Agenten das Handbuch vor der Referenz lesen. Generierte API- und OpenAPI-Referenzen erscheinen jeweils als ein Link zum Index.
• /llms-full.txt enthält alle Seiten in derselben Reihenfolge als eine Markdown-Datei. Jede Seite beginnt mit einem ##-Titel; ihre eigenen Überschriften rücken eine Ebene tiefer.

Mit Versionierung entstehen beide Dateien auch unter der aktuellen Version, etwa /v6/llms.txt und /v6/llms-full.txt. Der versionierte Index verlinkt seine Volltextdatei. Bewahre beide mit älteren HTML-Snapshots auf; die Dateien im Stamm bleiben Aliase der aktuellen Version.

Ardo verwendet Titel und Beschreibungen aus dem Frontmatter, überspringt TSX-Routen und entfernt MDX-Imports, Exports und JSX-Komponententags aus dem Volltext. llms: false im Frontmatter schließt eine Markdown-Seite aus beiden Dateien aus.

defineArdoConfig({
  title: "My Docs",
  siteUrl: "https://example.com",
  seo: {
    llms: {
      title: "My Docs",
      description: "Developer documentation for my package.",
      includeFull: true,
    },
  },
})

Mit seo.llms: false verwaltest du diese Dateien selbst unter public/.

seo.sitemap

• Typ:boolean | { changefreq?: "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never"; priority?: number; exclude?: string[] }
• Standard:true

Erzeugt /sitemap.xml aus Markdown-, MDX- und TSX-Routen. Ardo kombiniert siteUrl, base und den Routenpfad für absolute URLs auch unter Unterpfaden.

defineArdoConfig({
  title: "My Docs",
  siteUrl: "https://example.com",
  base: "/docs/",
  seo: {
    sitemap: {
      changefreq: "weekly",
      priority: 0.7,
      exclude: ["/kit"],
    },
  },
})

seo.sitemap: false deaktiviert die Sitemap. sitemap: false im Frontmatter schließt eine einzelne Markdown-Route aus. seo.sitemap.exclude nimmt Routenpräfixe einschließlich TSX an: /kit schließt /kit und /kit/buttons aus, aber nicht /kitchen. Ein abschließender Slash ist optional. Präfixe gelten vor Deployment-, Versions- und Sprachpräfixen. Das betrifft nur die Sitemap; für noindex setzt du die Robots-Metadaten der Seite separat.

seo.robots

• Typ:boolean | { allow?: string[]; disallow?: string[] }
• Standard:true

Erzeugt /robots.txt. Standardmäßig erlaubt Ardo alle Crawler und verweist bei gesetzter siteUrl auf die Sitemap.

defineArdoConfig({
  title: "My Docs",
  siteUrl: "https://example.com",
  seo: {
    robots: {
      allow: ["/"],
      disallow: ["/drafts/"],
    },
  },
})

Mit seo.robots: false lieferst du eine eigene robots.txt aus public/.

linkCheck

• Typ:{ enabled?: boolean; checkAnchors?: boolean; exclude?: string[]; level?: "warn" | "error" }
• Standard:{ enabled: true, checkAnchors: true, level: "warn" }

Prüft interne Links im fertigen Build mit ferrolink. Nachdem ardo build alle Seiten geschrieben hat, prüft Ardo jeden internen Link, jedes Bild, Skript, Stylesheet, jeden srcset-Kandidaten und jede Meta-Weiterleitung, unabhängig davon, ob sie aus Markdown, Komponenten oder generierten Seiten stammen. Es prüft auch Weiterleitungsziele in _redirects und vercel.json sowie Versionspfade in versions.json. Standardmäßig muss jedes #fragment zu einer Element-ID der Zielseite passen. Weiterleitungsquellen sind gültige Ziele, weil Ardo ihre Seiten schreibt.

Externe Links bleiben außen vor, da ihre Erreichbarkeit von fremden Servern abhängt. Andere Versionen in versioning gelten als vorhanden, weil jede separat bereitgestellt wird. Ein Link außerhalb der Deployment-Basis, etwa /guide/ auf einer unter /docs/ bereitgestellten Website, wird gemeldet. Jede Meldung nennt Datei und Zeile.

exclude enthält Glob-Muster für übersprungene Ziele. Mit führendem / gilt der vollständige URL-Pfad einschließlich Basis, etwa /generated/** oder /blog/** für eine andere Anwendung auf demselben Host. Andere Muster gelten relativ zur Deployment-Basis. Ausgenommene Ziele werden weder als fehlend noch wegen fehlender Anker gemeldet.

defineArdoConfig({
  title: "My Docs",
  linkCheck: {
    level: "error",
    exclude: ["/generated/**"],
  },
})

Setze checkAnchors: false, wenn ein anderes Werkzeug Überschriften-IDs nach dem Einlesen des Manifests umschreibt. Nutze enabled: false nur, wenn ein anderer Linkprüfer den Build absichert.

validation

• Typ:{ frontmatter?: { invalid?: "warn" | "error" | "ignore"; unknown?: "warn" | "error" | "ignore" } }
• Standard: ungültige dokumentierte Felder warnen; unbekannte Felder werden aus Kompatibilitätsgründen ignoriert.

Ardo validiert dokumentierte Frontmatter-Felder einmal beim Einlesen der Routen. Diagnosen nennen die Quelldatei; ungültige Werte gelangen nicht in Seitenleiste, Suche, Sitemap, Weiterleitungen oder LLM-Ausgabe. Aktiviere strikte Prüfung, wenn Tippfehler CI fehlschlagen lassen sollen:

defineArdoConfig({
  title: "My Docs",
  validation: {
    frontmatter: {
      invalid: "error",
      unknown: "error",
    },
  },
})

Nutze bei bestehenden Dokumentationen zunächst unknown: "warn". Lass den Standard nur bestehen, wenn ein anderes Werkzeug eigene Frontmatter-Felder verwaltet.

redirects

• Typ:Array<{ from: string; to: string }>
• Standard:[]

Erzeugt statische Weiterleitungsdateien für konfigurierte alte Pfade:

• _redirects für Netlify-kompatible Hosts
• Weiterleitungseinträge invercel.json
• HTML-Weiterleitungen für reine Datei-Hosts

defineArdoConfig({
  title: "My Docs",
  redirects: [
    { from: "/old-guide", to: "/guide/getting-started" },
    { from: "/v1/config", to: "/guide/configuration" },
  ],
})

Nutze redirectFrom im Frontmatter, wenn die Weiterleitung zu einer bestimmten Seite gehört.

versioning

• Typ:false | { current: string; versions: Array<{ id: string; label?: string; path: string; locales?: string[] }>; rootRedirect?: boolean }
• Standard:false

Aktiviert Dokumentation nach Hauptversionen. Ardo baut unter dem aktuellen Versionspfad, stellt die Versionen im Umschalter bereit, schreibt /versions.json und erzeugt standardmäßig eine /index.html-Weiterleitung zur aktuellen Version.

Pro Version ist locales optional: ohne Angabe bleibt die Sprache erhalten, [] kennzeichnet ein Archiv ohne Sprachpräfix, und eine Liste begrenzt die unterstützten Sprachen. Ist die aktuelle Sprache nicht verfügbar, wird die erste gewählt. Der Umschalter steht unten in der Seitenleiste, auf freien Seiten in der Fußzeile und auf schmalen Bildschirmen im Menü. Sortiere neueste Versionen zuerst. Alle anderen zeigen einen Banner mit Link zur gleichen Seite der neuesten Version.

defineArdoConfig({
  title: "My Docs",
  siteUrl: "https://docs.example.com",
  versioning: {
    current: "v3",
    versions: [
      { id: "v3", label: "3.x", path: "/v3/" },
      { id: "v2", label: "2.x", path: "/v2/" },
    ],
  },
})

Mit base hängt Ardo den Versionspfad an die Deployment-Wurzel: base: "/my-project/" und path: "/v3/" ergeben /my-project/v3/. Die Sitemap enthält nur den aktuellen Build. Ältere Hauptversionen können als statische Ordner bestehen bleiben, ohne als aktueller doppelter Inhalt aufzutauchen.

rootRedirect: false lässt Platz für eine eigene Startseite oder eine Weiterleitung beim Host. Auf statischen Hosts wie GitHub Pages besteht Ardos Weiterleitung aus HTML mit Meta-Refresh und JavaScript. Echte HTTP-Weiterleitungen eines CDN oder Hosts konfigurierst du außerhalb von Ardo.

i18n

• Typ:false | { defaultLocale: string; locales: Array<{ id: string; label?: string }>; redirectUnlocalized?: boolean }
• Standard:false

Ardo baut jede Sprache als eigenen statischen Routenbaum und zeigt bei mehreren Sprachen einen Umschalter. Lege Übersetzungen unter app/routes/<locale>/ ab, beispielsweise app/routes/en/guide/getting-started.mdx und app/routes/de/guide/getting-started.mdx.

Jede sichtbare Route muss in jeder konfigurierten Sprache vorhanden sein. Fehlende Übersetzungen und Seiten außerhalb der Sprachordner lassen den Build fehlschlagen. Es gibt keinen Laufzeit-Fallback. Die Suche lädt nur die aktive Sprache. Mit siteUrl erzeugt Ardo kanonische URLs und Sprachalternativen. Übersetze UI-Texte über ArdoRoot und lies die Sprache mit useArdoLocale(). Internationalisierung zeigt das vollständige Palamedes-Beispiel.

Ardo nimmt die Sprache immer in die kanonischen öffentlichen URLs auf. Bei Versionierung steht die Version zuerst:

defineArdoConfig({
  title: "My Docs",
  versioning: {
    current: "v3",
    versions: [{ id: "v3", label: "3.x", path: "/v3/" }],
  },
  i18n: {
    defaultLocale: "en",
    locales: [
      { id: "en", label: "English" },
      { id: "de", label: "Deutsch" },
    ],
  },
})

Das ergibt URLs wie /v3/en/guide/getting-started. Die Wurzel leitet zur aktuellen Version und Standardsprache, die Versionswurzel zur Standardsprache. Ihr Präfix wird nicht versteckt. Die Anwendungshülle ist app/root.tsx, kein Sprachdokument. redirectUnlocalized: true leitet bestehende Pfade ohne Sprachpräfix in Entwicklung und statischen Builds zur Standardsprache um.

outDir

• Typ:string
• Standard:"build"

Ausgabeordner relativ zum Projekt oder als absoluter Pfad. Die statische Website liegt unter <outDir>/client/, das Serverbundle für den Build unter <outDir>/server/. ardo preview verwendet denselben Clientordner.

defineArdoConfig({
  title: "My Docs",
  outDir: "release/docs",
})

Damit liegt die Website unter release/docs/client/. Veröffentliche diesen Ordner statt build/client/. Das Serverbundle wird nur beim Build benötigt.

Ardo leert standardmäßig beide Ausgabeordner. ardo build --no-emptyOutDir erhält vorhandene Dateien. build.emptyOutDir in vite.config.ts setzt dieselbe Regel; die umgebungsspezifischen Einstellungen unter environments.client.build.emptyOutDir oder environments.ssr.build.emptyOutDir haben Vorrang.

lang

• Typ:string
• Standard:"en"

Website-Sprache für das lang-Attribut auf <html>.

defineArdoConfig({
  title: "My Docs",
  lang: "de",
})

sidebar.sectionOrder

• Typ:string[]
• Standard:[]

Reihenfolge der obersten Abschnitte von ArdoGeneratedSidebar. Verwende Ordnernamen ohne führenden Slash. Aufgeführte Abschnitte stehen zuerst; übrige folgen in der generierten Standardreihenfolge.

defineArdoConfig({
  title: "Product Docs",
  sidebar: {
    sectionOrder: ["guide", "reference", "api", "quality", "architecture", "archive"],
  },
})

Unterseiten behalten die Reihenfolge aus order im Frontmatter und alphabetischer Ersatzsortierung.

head

• Typ:HeadConfig[]
• Status: Ignoriert

Ardo 6 rendert diese Tags nicht mehr. Exportiere stattdessen meta aus root.tsx oder einer Route mit dem Typ ArdoMetaFunction aus ardo/runtime.

vite

• Typ:Record<string, unknown>

Reserviert für Vite-nahe Integrationsdaten. Vite-Einstellungen gehören in eine optionale vite.config.ts, die Ardos CLI mit der eigenen Integration zusammenführt.

project

• Typ:{ name?: string; homepage?: string; repository?: string; version?: string; author?: string; license?: string }

Projektmetadaten aus virtual:ardo/config. Das Plugin erkennt sie nach Möglichkeit aus package.json.

Integrationsoptionen

Diese Optionen steuern Routen und Build-Integrationen in ardo.config.ts mit defineArdoConfig(). Bestehende Vite-Projekte können sie während der Migration weiter an ardo() übergeben.

routes

• Typ:ArdoRoutesPluginOptions | false
• Standard: automatisch

Einstellungen der automatischen Routengenerierung. false deaktiviert sie vollständig.

icons

• Typ:false
• Standard: generierte Eulenicons

Ardo erzeugt beim Build die Eulenicons /favicon.ico, /icon.svg und /apple-touch-icon.png und stellt sie auch in der Entwicklung bereit. Eigene Icons importierst du mit ArdoRoot, <ArdoRoot icon={icon} />, damit Vite sie mit Fingerprints versieht; siehe Theming. Gleichnamige Dateien unter public/ ersetzen die generierten Icons. Mit icons: false verwaltest du alle drei selbst.

content

• Typ:Array<{ from: string; to: string; frontmatter?: (file) => Record<string, string | number | boolean | string[] | undefined> }>
• Standard:[]

Überführt Markdown und MDX außerhalb des Routenordners in generierte Routen. So veröffentlichst du ADRs, CHANGELOG.md oder Paket-READMEs, ohne ihre kanonische Quelldatei zu verschieben.

defineArdoConfig({
  title: "My Docs",
  content: [
    {
      from: "./adr",
      to: "decisions",
      frontmatter: (file) => ({
        description: `Copied from ${file.relativePath}`,
      }),
    },
    {
      from: "./CHANGELOG.md",
      to: "changelog",
    },
  ],
})

Ardo schreibt unter routesDir/<to>/ und markiert den Ordner mit .ardo-generated. Nichtleere Zielordner ohne Marker werden nicht ersetzt. Fehlt Frontmatter, leitet Ardo title aus der ersten #-Überschrift oder dem Dateinamen und order aus einem numerischen Präfix wie 0001- ab.

Wenn from auf eine einzelne Datei zeigt, schreibt Ardo sie als routesDir/<to>/index.md oder routesDir/<to>/index.mdx. So wird to: "changelog" zur Route /changelog.

Content-Quellen ändern keine relativen Links und validieren kein Frontmatter. Nutze collections für Schemas und typisierte Datensätze.

collections

• Typ:Record<string, { from: string; to: string; schema?: (data) => T }>
• Standard:{}

Lokale Markdown- und MDX-Dateien werden wie bei content zu Routen und zusätzlich zu typisierten Datensätzen für eigene React-Seiten. schema validiert Frontmatter beim Build. getCollection aus virtual:ardo/collections liest die Daten.

import { defineArdoConfig } from "ardo/config"
import { defineCollection } from "ardo/vite"

const recipes = defineCollection<{ title: string }>({
  from: "./recipes",
  to: "recipes",
  schema: (data) => ({ title: String(data.title) }),
})

export default defineArdoConfig({ title: "My Docs", collections: { recipes } })

Content-Quellen beschreibt den gesamten Ablauf.

openapi

• Typ:{ spec: string; out?: string }
• Standard: keiner

Erzeugt statische Referenzseiten aus einer lokalen OpenAPI-3.0- oder -3.1-Datei in JSON oder YAML. out ist standardmäßig api. Details unter API-Dokumentation.

defineArdoConfig({
  title: "Pet API",
  openapi: { spec: "./openapi.yaml" },
})

routesDir

• Typ:string
• Standard:"./app/routes"

Ordner der Routendateien.

defineArdoConfig({
  title: "My Docs",
  routesDir: "./src/routes",
})

Markdown

Markdown-Optionen stehen unter markdown.

defineArdoConfig({
  title: "My Docs",
  markdown: {
    theme: { light: "github-light-default", dark: "github-dark-default" },
    lineNumbers: true,
  },
})

markdown.theme

• Typ: ThemeInput | { light: ThemeInput; dark: ThemeInput } aus@ferriki/core
• Standard:{ light: "github-light-default", dark: "github-dark-default" }

Theme der Syntaxhervorhebung. Ferriki akzeptiert einen Theme-Namen, eine eigene TextMate-Registrierung oder ein Hell-Dunkel-Paar. Standardthemes werden beim ersten Einsatz heruntergeladen und gecacht.

markdown: {
  theme: "one-dark-pro",
}

markdown.lineNumbers

• Typ:boolean
• Standard:false

Zeilennummern in Codeblöcken anzeigen.

markdown.anchor

• Typ:boolean
• Standard:true

Ankerlinks an Überschriften aktivieren.

markdown.toc

• Typ:{ level?: [number, number] }
• Standard:{ level: [2, 3] }

Einstellungen des Inhaltsverzeichnisses. level bestimmt minimale und maximale Überschriftenebene.

markdown: {
  toc: {
    level: [2, 4], // Include h2, h3, and h4
  },
}

markdown.passes

• Typ: NativePassOptions[] ausferromark
• Standard:[]

Führt Ferromarks native Transformationen in Array-Reihenfolge aus. Derselbe transformierte Überschriftentext gilt für Seite, Inhaltsverzeichnis, Suche und Linkprüfung.

markdown: {
  passes: [
    { kind: "typography", language: "en" },
    { kind: "emojiShortcodes" },
    { kind: "githubReferences", repository: "owner/repository" },
  ],
}

markdown.typography ist die Kurzform eines Typografie-Durchlaufs. Konfiguriere entweder typography oder passes; Ferromark lehnt die Kombination ab.

Native Markdown-Syntax

Ferromark-Syntax steht direkt unter markdown. GFM-Tabellen, Durchstreichungen, Aufgabenlisten, automatische Links, Fußnoten und Callouts sind aktiv. Optionale Erweiterungen: headingAttributes, imageAttributes, extendedAttributes, definitionLists, insertions, superscript, subscript, math und lineComments.

headingOffset verschiebt Überschriften und Inhaltsverzeichnis gemeinsam. headingIdPrefix setzt allen nativen IDs ein Präfix. Die Ferromark Node API beschreibt Semantik und Durchläufe.

Ardo verwaltet Dokumentformat, YAML-Frontmatter, React-Komponentenbindung und das Entfernen einer ersten Überschrift, die dem Seitentitel entspricht. Die früheren remark-, rehype- und recma-Pluginoptionen entfallen; siehe Upgrade auf Ardo 5.

API-Dokumentation

api generiert API-Dokumentation mit nativem TypeScript und OXC bei Build und Entwicklung. true nutzt src/index.ts und tsconfig.json; ein Objekt konfiguriert ein Projekt, ein Array mehrere. Objekte benötigen entryPoints und tsconfig; out hat den Standardwert api-reference und title den Wert API Reference. Ausgaben müssen unterschiedliche, nicht ineinander liegende Pfade haben.

API-Dokumentation beschreibt Installation, Konfiguration, programmatische Nutzung und Grenzen. typedoc und die alten Paketexports entfallen; siehe TypeDoc-Migration.

UI-Konfiguration

Navigation, Seitenleistenabschnitte, Fußzeile, editLink, lastUpdated und Suche konfigurierst du mit JSX und <ArdoRoot> in root.tsx. Layout und Navigation dokumentiert ArdoRoot, Kopfzeile, Fußzeile und Seitenleistenabschnitte.

Paketexports

Ardo trennt browsersichere Runtime-Imports von Node.js-Build-Imports:

Frontmatter

Seitenspezifische Einstellungen stehen im Frontmatter der MDX-Dateien. Alle Optionen beschreibt Frontmatter.

Kompatibilitätsbeispiel mit Vite-Plugin

Diese Form bleibt für direkt verwaltete Vite-Projekte unterstützt. Neue Websites sollten ardo.config.ts verwenden und Vite-Konfiguration nur bei Bedarf ergänzen. Nutze diese Form anstelle von ardo.config.ts und importiere defineConfig aus Ardo, um eine eigene Vite-Abhängigkeit zu vermeiden. API-Generierung ergänzt du wie unter API-Dokumentation.

import { defineConfig } from "ardo/vite"
import { ardo } from "ardo/vite"

export default defineConfig({
  plugins: [
    ardo({
      title: "My Library",
      description: "Comprehensive documentation for My Library",
      lang: "en",

      markdown: {
        theme: { light: "github-light-default", dark: "github-dark-default" },
        lineNumbers: false,
        toc: { level: [2, 3] },
      },
    }),
  ],
})