yaakdoc 0.1.0 → 0.2.0

package/dist/site-X7q76qYf.js

@@ -0,0 +1,609 @@
+import { builtinSnippets, generateExamples } from "@yaakdoc/snippets";
+import { copyFile, mkdir, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { loadConfig } from "@yaakdoc/config/node";
+import { absoluteUrl, findWorkspace, isUrl, normalize, prepareDocument, sanitizeExport, selectEnvironment, summarize } from "@yaakdoc/core";
+import { detectExport, readExport } from "@yaakdoc/core/node";
+import { folderToMarkdown, indexToMarkdown, llmsFullTxt, llmsTxt, requestToMarkdown } from "@yaakdoc/markdown";
+import rehypeShikiFromHighlighter from "@shikijs/rehype/core";
+import { createJiti } from "jiti";
+import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
+import rehypeStringify from "rehype-stringify";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { bundledLanguages, createHighlighter } from "shiki";
+import { unified } from "unified";
+//#region src/node/render.ts
+const PRELOADED_LANGUAGES = [
+	"bash",
+	"javascript",
+	"typescript",
+	"python",
+	"go",
+	"json",
+	"graphql",
+	"xml",
+	"html",
+	"yaml",
+	"http"
+];
+/** Highlights a delimited region as GraphQL (opening captures: prefix tokens, then the delimiter). */
+const embeddedGraphql = (begin, end, prefixScopes) => ({
+	begin,
+	beginCaptures: Object.fromEntries(prefixScopes.map((name, index) => [index + 1, { name }])),
+	end,
+	endCaptures: { 0: { name: prefixScopes.at(-1) } },
+	contentName: "meta.embedded.block.graphql",
+	patterns: [{ include: "source.graphql" }]
+});
+/**
+* Injection grammar highlighting GraphQL inside code examples (like VS Code's GraphQL extension):
+* `/* GraphQL *\/ \`...\`` and `gql\`...\`` in JavaScript, `query = """..."""` in Python and
+* `query := \`...\`` in Go.
+*/
+const GRAPHQL_INJECTION = {
+	name: "yaakdoc-graphql-injection",
+	scopeName: "inline.graphql.yaakdoc",
+	injectTo: [
+		"source.js",
+		"source.ts",
+		"source.python",
+		"source.go"
+	],
+	injectionSelector: "L:source -comment -string",
+	embeddedLangs: ["graphql"],
+	patterns: [
+		embeddedGraphql("(/\\*\\s*GraphQL\\s*\\*/)\\s*(`)", "`", ["comment.block.js", "punctuation.definition.string.template.begin.js"]),
+		embeddedGraphql("\\b(gql|graphql)(`)", "`", ["entity.name.function.tagged-template.js", "punctuation.definition.string.template.begin.js"]),
+		embeddedGraphql("\\b(query)\\s*(=)\\s*(\"\"\")", "\"\"\"", [
+			"variable.other.python",
+			"keyword.operator.assignment.python",
+			"punctuation.definition.string.begin.python"
+		]),
+		embeddedGraphql("\\b(query)\\s*(:=)\\s*(`)", "`", [
+			"variable.other.go",
+			"keyword.operator.assignment.go",
+			"punctuation.definition.string.begin.go"
+		])
+	]
+};
+const highlighters = /* @__PURE__ */ new Map();
+function getHighlighter(themes) {
+	const key = `${themes.light}|${themes.dark}`;
+	let highlighter = highlighters.get(key);
+	if (!highlighter) {
+		highlighter = createHighlighter({
+			themes: [themes.light, themes.dark],
+			langs: [...PRELOADED_LANGUAGES, GRAPHQL_INJECTION]
+		});
+		highlighters.set(key, highlighter);
+	}
+	return highlighter;
+}
+const LANGUAGE_ALIASES = {
+	shell: "bash",
+	sh: "bash",
+	js: "javascript",
+	ts: "typescript",
+	text: "text",
+	plain: "text"
+};
+async function ensureLanguage(highlighter, language) {
+	const lang = LANGUAGE_ALIASES[language] ?? language;
+	if (lang === "text" || highlighter.getLoadedLanguages().includes(lang)) return lang;
+	if (lang in bundledLanguages) {
+		await highlighter.loadLanguage(lang);
+		return lang;
+	}
+	return "text";
+}
+const sanitizeSchema = {
+	...defaultSchema,
+	attributes: {
+		...defaultSchema.attributes,
+		code: [...defaultSchema.attributes?.code ?? [], ["className", /^language-./]]
+	}
+};
+/**
+* Creates the Markdown/code renderer: GFM, sanitized HTML (descriptions come from exports that may
+* be shared by others), and Shiki highlighting with dual light/dark themes via CSS variables.
+*/
+async function createRenderer(themes) {
+	const highlighter = await getHighlighter(themes);
+	const shikiOptions = {
+		themes,
+		defaultColor: false
+	};
+	const processor = unified().use(remarkParse).use(remarkGfm).use(remarkRehype).use(rehypeSanitize, sanitizeSchema).use(rehypeShikiFromHighlighter, highlighter, {
+		...shikiOptions,
+		fallbackLanguage: "text",
+		lazy: true
+	}).use(rehypeStringify);
+	return {
+		markdown: async (source) => String(await processor.process(source)),
+		highlight: async (code, language) => highlighter.codeToHtml(code, {
+			...shikiOptions,
+			lang: await ensureLanguage(highlighter, language)
+		})
+	};
+}
+/** Loads snippet generators by built-in id or module path/package (default export or `snippet`). */
+async function loadSnippets(ids, root) {
+	const jiti = createJiti(`${root}/`, { interopDefault: true });
+	const snippets = [];
+	for (const id of ids) {
+		const builtin = builtinSnippets[id];
+		if (builtin) {
+			snippets.push(builtin);
+			continue;
+		}
+		if (!existsSync(id) && !id.includes("/") && !id.startsWith("@")) throw new Error(`Unknown snippet "${id}". Built-in snippets: ${Object.keys(builtinSnippets).join(", ")}.`);
+		const mod = await jiti.import(id);
+		const loaded = "default" in mod ? mod.default : mod;
+		for (const snippet of Array.isArray(loaded) ? loaded : [loaded]) {
+			if (!snippet || typeof snippet.generate !== "function") throw new Error(`Snippet module "${id}" must export a snippet created with defineSnippet().`);
+			snippets.push(snippet);
+		}
+	}
+	return snippets;
+}
+//#endregion
+//#region src/node/resolve.ts
+/**
+* Directory of the installed `yaakdoc` package. When yaakdoc is bundled into CommonJS (the Yaak
+* plugin), `import.meta.url` is not available and the bundle's own location is used.
+*/
+const ENGINE_DIR = (() => {
+	const start = typeof __filename === "string" ? dirname(__filename) : dirname(fileURLToPath(import.meta.url));
+	let dir = start;
+	while (!existsSync(join(dir, "package.json"))) {
+		if (dirname(dir) === dir) return start;
+		dir = dirname(dir);
+	}
+	return dir;
+})();
+/** A file inside the engine package, used as importer for fallback resolution. */
+const ENGINE_ANCHOR = join(ENGINE_DIR, "package.json");
+/**
+* Resolves an ESM specifier as if imported from `fromFile`. Returns an absolute path or null.
+*/
+function resolveFrom(specifier, fromFile) {
+	try {
+		const resolved = createJiti(fromFile).esmResolve(specifier, { try: true });
+		return resolved ? resolved.startsWith("file:") ? fileURLToPath(resolved) : resolved : null;
+	} catch {
+		return null;
+	}
+}
+/** Resolves a package directory (the folder containing its package.json). */
+function resolvePackageDir(name, fromFile) {
+	const entry = resolveFrom(`${name}/package.json`, fromFile);
+	if (entry) return dirname(entry);
+	const main = resolveFrom(name, fromFile);
+	if (!main) return null;
+	let dir = dirname(main);
+	while (dir !== dirname(dir)) {
+		if (existsSync(join(dir, "package.json")) && dir.endsWith(name.split("/").at(-1))) return dir;
+		dir = dirname(dir);
+	}
+	return null;
+}
+//#endregion
+//#region src/node/theme.ts
+var ThemeError = class extends Error {
+	name = "ThemeError";
+};
+const MANIFEST_NAMES = [
+	"theme.ts",
+	"theme.mts",
+	"theme.js",
+	"theme.mjs",
+	"index.ts",
+	"index.js"
+];
+/** Candidate package names for a theme spec: `kiseki` → `@yaakdoc/theme-kiseki`, `yaakdoc-theme-kiseki`. */
+function themePackageCandidates(spec) {
+	if (spec.startsWith("@") || spec.includes("/") || spec.startsWith("yaakdoc-theme-")) return [spec];
+	return [
+		`@yaakdoc/theme-${spec}`,
+		`yaakdoc-theme-${spec}`,
+		spec
+	];
+}
+const isLocal = (spec) => spec.startsWith(".") || isAbsolute(spec);
+function findManifest(path) {
+	if (existsSync(path) && statSync(path).isFile()) return path;
+	for (const name of MANIFEST_NAMES) {
+		const candidate = join(path, name);
+		if (existsSync(candidate)) return candidate;
+	}
+	throw new ThemeError(`No theme manifest (${MANIFEST_NAMES.join(", ")}) found in ${path}`);
+}
+/** Built-in theme package directories, used to resolve dependencies of ejected themes. */
+function builtinFallbacks() {
+	const kiseki = resolvePackageDir("@yaakdoc/theme-kiseki", ENGINE_ANCHOR);
+	return [ENGINE_ANCHOR, ...kiseki ? [join(kiseki, "package.json")] : []];
+}
+/** Loads and validates a theme from a short name, package name or local path. */
+async function resolveTheme(spec, options) {
+	const userAnchor = join(options.root, "package.json");
+	let manifest = null;
+	let packageName = null;
+	if (isLocal(spec)) manifest = findManifest(resolve(options.root, spec));
+	else {
+		for (const candidate of themePackageCandidates(spec)) {
+			const resolved = resolveFrom(candidate, userAnchor) ?? resolveFrom(candidate, ENGINE_ANCHOR);
+			if (resolved) {
+				manifest = resolved;
+				packageName = candidate;
+				break;
+			}
+		}
+		if (!manifest) throw new ThemeError(`Theme "${spec}" not found. Install it (e.g. npm i -D ${themePackageCandidates(spec)[0]}) or use a local path.`);
+	}
+	const fallbackImporters = builtinFallbacks();
+	const alias = buildAliases(manifest, fallbackImporters);
+	const jiti = createJiti(manifest, {
+		alias,
+		moduleCache: false,
+		interopDefault: true
+	});
+	let definition;
+	try {
+		definition = await jiti.import(manifest, { default: true });
+	} catch (error) {
+		throw new ThemeError(`Failed to load theme ${manifest}: ${error.message}`);
+	}
+	if (!definition || typeof definition !== "object" || !definition.entry) throw new ThemeError(`Theme ${manifest} must default-export defineTheme({ name, entry, ... }).`);
+	return themeFromDefinition(definition, {
+		manifest,
+		packageName,
+		themeOptions: options.themeOptions,
+		fallbackImporters
+	});
+}
+/**
+* Validates the options of an already loaded theme definition. `resolveTheme` loads the definition
+* from a manifest; bundled engines (the Yaak plugin) pass a definition they import themselves.
+*/
+function themeFromDefinition(definition, options) {
+	const root = dirname(options.manifest);
+	const abs = (path) => resolve(root, path);
+	let themeOptions = options.themeOptions;
+	if (definition.options) try {
+		themeOptions = definition.options.parse(options.themeOptions);
+	} catch (error) {
+		throw new ThemeError(`Invalid themeOptions for theme "${definition.name}":\n${error.message}`);
+	}
+	return {
+		name: definition.name,
+		definition,
+		root,
+		manifest: options.manifest,
+		entry: abs(definition.entry),
+		client: definition.client ? abs(definition.client) : null,
+		styles: (definition.styles ?? []).map(abs),
+		options: themeOptions,
+		packageName: options.packageName ?? null,
+		fallbackImporters: options.fallbackImporters ?? [],
+		highlight: definition.highlight ?? {
+			light: "github-light",
+			dark: "github-dark"
+		}
+	};
+}
+/**
+* jiti aliases so a theme manifest (e.g. an ejected theme in a project without dependencies) can
+* import `@yaakdoc/react/theme` and the built-in themes' dependencies.
+*/
+function buildAliases(manifest, fallbacks) {
+	const specs = /* @__PURE__ */ new Set(["@yaakdoc/react/theme", "@yaakdoc/react"]);
+	for (const fallback of fallbacks) try {
+		const pkg = JSON.parse(readFileSync(fallback, "utf8"));
+		for (const name of Object.keys(pkg.dependencies ?? {})) specs.add(name);
+	} catch {}
+	const alias = {};
+	for (const spec of specs) {
+		if (resolveFrom(spec, manifest)) continue;
+		for (const fallback of fallbacks) {
+			const resolved = resolveFrom(spec, fallback);
+			if (resolved) {
+				alias[spec] = resolved;
+				break;
+			}
+		}
+	}
+	return alias;
+}
+//#endregion
+//#region src/node/version.ts
+/** The yaakdoc version: inlined by the build, read from package.json when running from source. */
+const VERSION = "0.2.0";
+//#endregion
+//#region src/node/context.ts
+/** Loads config, export and theme, and prepares everything needed to render the site. */
+async function resolveContext(options = {}) {
+	const cwd = resolve(options.cwd ?? process.cwd());
+	const { config, configFile, root } = await loadConfig({
+		cwd,
+		...options.configFile ? { configFile: options.configFile } : {},
+		...options.overrides ? { overrides: options.overrides } : {}
+	});
+	const exportPath = options.exportData === void 0 ? config.export ?? await detectExport(root) : null;
+	const rawExport = exportPath ? await readExport(exportPath) : options.exportData;
+	const source = normalize(rawExport);
+	const workspace = findWorkspace(source, config.workspace);
+	const environments = config.environments === "public" ? workspace.environments.filter((env) => env.public) : (config.environments ?? []).map((name) => selectEnvironment(workspace, name));
+	const environment = config.environment === false ? null : config.environment === void 0 && environments[0] ? environments[0] : selectEnvironment(workspace, config.environment);
+	const theme = await (options.resolveTheme ?? resolveTheme)(config.theme, {
+		root,
+		themeOptions: config.themeOptions
+	});
+	const renderer = await createRenderer(theme.highlight);
+	const snippets = await loadSnippets(config.snippets, root);
+	const document = await prepareDocument({
+		workspace,
+		environment,
+		environments,
+		pages: config.pages,
+		base: config.base,
+		variables: config.variables,
+		filter: config.filter,
+		renderMarkdown: renderer.markdown,
+		highlight: renderer.highlight,
+		examples: (request) => generateExamples(request, snippets),
+		meta: {
+			yaakVersion: source.yaakVersion,
+			exportedAt: source.exportedAt
+		}
+	});
+	const assets = /* @__PURE__ */ new Map();
+	const asset = (path) => publicAsset(path, config.base, assets);
+	const site = await createSiteData(config, document, theme, asset, renderer.markdown);
+	const { routes, notFound } = createRoutes(document, site);
+	const markdownOptions = {
+		title: site.title,
+		description: site.description,
+		base: config.base,
+		...site.url ? { siteUrl: site.url } : {}
+	};
+	const textFiles = /* @__PURE__ */ new Map();
+	if (config.llms.enabled) {
+		textFiles.set(`${config.base}index.md`, config.pages === "single" ? llmsFullTxt(document, markdownOptions) : indexToMarkdown(document, markdownOptions));
+		for (const folder of Object.values(document.folders)) textFiles.set(folder.markdownUrl, folderToMarkdown(document, folder, markdownOptions));
+		for (const request of Object.values(document.requests)) textFiles.set(request.markdownUrl, requestToMarkdown(request, markdownOptions));
+		textFiles.set(`${config.base}llms.txt`, llmsTxt(document, {
+			...markdownOptions,
+			...config.llms.full ? { fullTextUrl: `${config.base}llms-full.txt` } : {}
+		}));
+		if (config.llms.full) textFiles.set(`${config.base}llms-full.txt`, llmsFullTxt(document, markdownOptions));
+	}
+	const externalExport = typeof config.runInYaak === "object" && config.runInYaak.url;
+	if (site.runInYaak && !externalExport) {
+		const shared = shareableExport(rawExport, workspace, document, config.variables.hide);
+		textFiles.set(site.runInYaak.dataUrl, JSON.stringify(shared, null, 2));
+	}
+	return {
+		cwd,
+		root,
+		configFile,
+		config,
+		exportPath,
+		source,
+		theme,
+		document,
+		site,
+		routes,
+		notFound,
+		textFiles,
+		assets,
+		watchFiles: [
+			...exportPath ? [exportPath] : [],
+			...configFile ? [configFile] : [],
+			...assets.values()
+		]
+	};
+}
+/** The export restricted to what the docs show, safe to publish for "Run in Yaak". */
+function shareableExport(raw, workspace, document, hide) {
+	const environmentIds = new Set(document.environments.map((env) => env.id));
+	if (document.environment) environmentIds.add(document.environment.id);
+	if (workspace.baseEnvironment) environmentIds.add(workspace.baseEnvironment.id);
+	for (const folderId of Object.keys(document.folders)) for (const env of workspace.folderEnvironments[folderId] ?? []) environmentIds.add(env.id);
+	return sanitizeExport(raw, {
+		workspaceId: workspace.id,
+		folderIds: new Set(Object.keys(document.folders)),
+		requestIds: new Set(Object.keys(document.requests)),
+		environmentIds,
+		hide
+	});
+}
+/**
+* Maps a local asset (logo, favicon) to a public URL under `<base>_yaakdoc/`, registering it in
+* `assets` so it's copied into the site. URLs and site-root paths that don't exist on disk (e.g.
+* `/logo.svg` served from `public/`) are kept as is.
+*/
+function publicAsset(path, base, assets) {
+	if (!path) return null;
+	if (isUrl(path) || !existsSync(path)) return path;
+	const hash = createHash("sha256").update(path).digest("hex").slice(0, 8);
+	const url = `${base}_yaakdoc/${basename(path, extname(path))}-${hash}${extname(path)}`;
+	assets.set(url, path);
+	return url;
+}
+async function createSiteData(config, document, theme, asset, markdown) {
+	const { branding } = config;
+	const title = branding.title ?? document.workspace.name;
+	let logo = null;
+	if (typeof branding.logo === "string") logo = {
+		light: asset(branding.logo) ?? void 0,
+		alt: title,
+		href: config.base
+	};
+	else if (branding.logo) logo = {
+		...branding.logo.light ? { light: asset(branding.logo.light) } : {},
+		...branding.logo.dark ? { dark: asset(branding.logo.dark) } : {},
+		alt: branding.logo.alt ?? title,
+		href: branding.logo.href ?? config.base,
+		...branding.logo.width ? { width: branding.logo.width } : {},
+		...branding.logo.height ? { height: branding.logo.height } : {}
+	};
+	return {
+		title,
+		description: branding.description ?? summarize(document.workspace.description, 200),
+		url: branding.url ?? null,
+		base: config.base,
+		pages: config.pages,
+		logo,
+		favicon: asset(branding.favicon),
+		colors: branding.colors ?? {},
+		fonts: branding.fonts ?? {},
+		links: branding.links,
+		footerHtml: branding.footer ? await markdown(branding.footer) : null,
+		defaultColorMode: branding.defaultColorMode,
+		colorModeToggle: branding.colorModeToggle,
+		llms: {
+			...config.llms,
+			txtUrl: config.llms.enabled ? `${config.base}llms.txt` : null,
+			fullTxtUrl: config.llms.enabled && config.llms.full ? `${config.base}llms-full.txt` : null
+		},
+		showVariables: config.variables.show,
+		runInYaak: config.runInYaak ? {
+			name: typeof config.runInYaak === "object" && config.runInYaak.name || title,
+			dataUrl: typeof config.runInYaak === "object" && config.runInYaak.url || `${config.base}yaak.json`
+		} : null,
+		head: config.head,
+		themeOptions: theme.options,
+		generator: `yaakdoc ${VERSION}`
+	};
+}
+function createRoutes(document, site) {
+	const { base } = site;
+	const llms = site.llms.enabled;
+	const routes = [{
+		path: base,
+		file: "index.html",
+		page: {
+			kind: "index",
+			id: null,
+			path: base,
+			title: "",
+			description: site.description,
+			markdownUrl: llms ? `${base}index.md` : null
+		}
+	}];
+	if (site.pages === "per-request") {
+		for (const folder of Object.values(document.folders)) routes.push({
+			path: folder.href,
+			file: `${folder.slug}/index.html`,
+			page: {
+				kind: "folder",
+				id: folder.id,
+				path: folder.href,
+				title: folder.name,
+				description: folder.summary,
+				markdownUrl: llms ? folder.markdownUrl : null
+			}
+		});
+		for (const request of Object.values(document.requests)) routes.push({
+			path: request.href,
+			file: `${request.slug}/index.html`,
+			page: {
+				kind: "request",
+				id: request.id,
+				path: request.href,
+				title: request.name,
+				description: request.summary,
+				markdownUrl: llms ? request.markdownUrl : null
+			}
+		});
+	}
+	return {
+		routes,
+		notFound: {
+			path: `${base}404.html`,
+			file: "404.html",
+			page: {
+				kind: "not-found",
+				id: null,
+				path: `${base}404.html`,
+				title: "Page not found",
+				description: "",
+				markdownUrl: null
+			}
+		}
+	};
+}
+/** Finds the route for a URL path (ignoring query/hash; `/x` matches `/x/`). */
+function matchRoute(context, pathname) {
+	const path = decodeURIComponent(pathname.split(/[?#]/)[0] ?? "/");
+	const normalized = path.endsWith("/") || path.endsWith(".html") ? path : `${path}/`;
+	return context.routes.find((route) => route.path === normalized || `${route.path}index.html` === path) ?? null;
+}
+//#endregion
+//#region src/node/site.ts
+/** Prefixes the client asset paths (relative to the output directory) with the site's base. */
+function withBase(assets, base) {
+	const prefix = (path) => base + path;
+	return {
+		styles: assets.styles.map(prefix),
+		scripts: assets.scripts.map(prefix),
+		inlineStyles: assets.inlineStyles,
+		modulePreloads: assets.modulePreloads.map(prefix)
+	};
+}
+/** Refuses to empty the project directory (or a parent of it). */
+function assertSafeOutDir(outDir, root) {
+	const rel = relative(resolve(outDir), resolve(root));
+	if (rel === "" || !rel.startsWith("..") && !rel.startsWith(sep) && !rel.includes(":")) throw new Error(`Refusing to use ${outDir} as outDir: it contains the project directory and would be emptied.`);
+}
+/** Empties (or creates) the output directory, after checking that it's safe to. */
+async function emptyOutDir(outDir, root) {
+	assertSafeOutDir(outDir, root);
+	await rm(outDir, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(outDir, { recursive: true });
+}
+/**
+* Writes the site into `context.config.outDir`, next to the client assets that are already there:
+* every route prerendered with `render`, the Markdown twins and llms.txt, branding assets and the
+* sitemap. Returns the written files, relative to the output directory.
+*/
+async function writeSite(context, { render, assets }) {
+	const outDir = context.config.outDir;
+	const files = [];
+	const write = async (file, content) => {
+		const target = join(outDir, file);
+		await mkdir(dirname(target), { recursive: true });
+		await writeFile(target, content);
+		files.push(file);
+	};
+	for (const route of [...context.routes, context.notFound]) await write(route.file, await render({
+		document: context.document,
+		site: context.site,
+		page: route.page,
+		assets
+	}));
+	for (const [url, content] of context.textFiles) await write(stripBase(url, context.config.base), content);
+	for (const [url, source] of context.assets) {
+		const file = stripBase(url, context.config.base);
+		await mkdir(dirname(join(outDir, file)), { recursive: true });
+		await copyFile(source, join(outDir, file));
+		files.push(file);
+	}
+	if (context.site.url) await write("sitemap.xml", sitemap(context));
+	await write(".nojekyll", "");
+	return files;
+}
+const stripBase = (url, base) => url.startsWith(base) ? url.slice(base.length) : url.replace(/^\//, "");
+function sitemap(context) {
+	return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${context.routes.map((route) => absoluteUrl(context.site.url, context.config.base, route.path)).map((url) => `  <url><loc>${url}</loc></url>`).join("\n")}\n</urlset>\n`;
+}
+//#endregion
+export { matchRoute as a, VERSION as c, themeFromDefinition as d, themePackageCandidates as f, resolveFrom as h, writeSite as i, ThemeError as l, ENGINE_DIR as m, emptyOutDir as n, publicAsset as o, ENGINE_ANCHOR as p, withBase as r, resolveContext as s, assertSafeOutDir as t, resolveTheme as u };

package/dist/static.d.ts

@@ -0,0 +1,2 @@
+import { a as withBase, c as Route, d as publicAsset, f as resolveContext, g as themeFromDefinition, i as emptyOutDir, l as YaakdocOptions, m as ThemeError, n as RenderEntry, o as writeSite, p as ResolvedTheme, r as assertSafeOutDir, s as Context, t as VERSION, u as matchRoute } from "./version-Bwv0ibuY.js";
+export { type Context, type RenderEntry, type ResolvedTheme, type Route, ThemeError, VERSION, type YaakdocOptions, assertSafeOutDir, emptyOutDir, matchRoute, publicAsset, resolveContext, themeFromDefinition, withBase, writeSite };

package/dist/static.js

@@ -0,0 +1 @@
+export { l as ThemeError, c as VERSION, t as assertSafeOutDir, n as emptyOutDir, a as matchRoute, o as publicAsset, s as resolveContext, d as themeFromDefinition, r as withBase, i as writeSite } from "./site-X7q76qYf.js";