boss-css 0.0.1 → 0.0.3

package/dist/fontsource/server.cjs

@@ -0,0 +1,291 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_directory = require('./directory.cjs');
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+
+//#region src/fontsource/server.ts
+var server_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	name: () => name,
+	onBoot: () => onBoot
+});
+const name = "fontsource";
+const API_BASE = "https://api.fontsource.org";
+const CDN_NPM_BASE = "https://cdn.jsdelivr.net/npm";
+const fontDirectoryEntries = require_directory.fontDirectory;
+const fontById = new Map(fontDirectoryEntries.map((entry) => [entry.id, entry]));
+const versionCache = /* @__PURE__ */ new Map();
+const cssCache = /* @__PURE__ */ new Map();
+const normalizeFontName = (value) => value.toLowerCase().replace(/["']/g, "").replace(/[_\s]+/g, "-").replace(/-+/g, "-").trim();
+const fontByFamily = new Map(fontDirectoryEntries.map((entry) => [normalizeFontName(entry.family), entry]));
+const ensureArray = (value) => {
+	if (value == null) return [];
+	return Array.isArray(value) ? Array.from(value) : [value];
+};
+const isVariableConfig = (font) => font.variable === true;
+const getFontEntry = (name) => {
+	if (!name) return null;
+	const normalized = normalizeFontName(name);
+	return fontById.get(normalized) || fontByFamily.get(normalized) || null;
+};
+const isValidNpmVersion = (value) => {
+	if (!value) return false;
+	if (value === "latest") return true;
+	return /^\d+\.\d+\.\d+/.test(value);
+};
+const fetchJson = async (url) => {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Fontsource request failed: ${response.status} ${response.statusText} (${url})`);
+	return response.json();
+};
+const resolveNpmVersion = async (id, variable, version) => {
+	if (isValidNpmVersion(version)) return version;
+	const cached = versionCache.get(id);
+	if (cached) return variable ? cached.latestVariable || cached.latest || "latest" : cached.latest || "latest";
+	const data = await fetchJson(`${API_BASE}/v1/version/${id}`);
+	versionCache.set(id, data);
+	return variable ? data.latestVariable || data.latest || "latest" : data.latest || "latest";
+};
+const resolveSubsets = (font, entry) => {
+	const subsets = ensureArray(font.subsets);
+	if (subsets.length) return subsets;
+	if (entry?.defSubset) return [entry.defSubset];
+	return entry?.subsets?.length ? Array.from(entry.subsets) : [];
+};
+const resolveWeights = (font, entry) => {
+	const weights = ensureArray(font.weights);
+	if (weights.length) return weights;
+	return entry?.weights?.length ? Array.from(entry.weights) : [];
+};
+const resolveStyles = (font, entry) => {
+	const styles = ensureArray(font.styles);
+	if (styles.length) return styles;
+	return entry?.styles?.length ? Array.from(entry.styles) : [];
+};
+const buildStaticCssFiles = (subsets, weights, styles) => {
+	const files = [];
+	const hasSubsets = subsets.length > 0;
+	const normalizedWeights = weights.length ? weights : ["400"];
+	const normalizedStyles = styles.length ? styles : ["normal"];
+	for (const weight of normalizedWeights) {
+		const weightValue = String(weight);
+		for (const style of normalizedStyles) {
+			const styleSuffix = style && style !== "normal" ? `-${style}` : "";
+			if (hasSubsets) for (const subset of subsets) files.push(`${subset}-${weightValue}${styleSuffix}.css`);
+			else files.push(`${weightValue}${styleSuffix}.css`);
+		}
+	}
+	return files;
+};
+const buildVariableCssFiles = (_font) => {
+	return ["index.css"];
+};
+const buildCssFiles = (font, entry) => {
+	if (isVariableConfig(font)) return buildVariableCssFiles(font);
+	return buildStaticCssFiles(resolveSubsets(font, entry), resolveWeights(font, entry), resolveStyles(font, entry));
+};
+const buildPackageName = (font, entry) => {
+	const id = entry?.id ?? normalizeFontName(font.name);
+	return font.variable ? `@fontsource-variable/${id}` : `@fontsource/${id}`;
+};
+const toVariationSettings = (axes) => {
+	if (!axes) return null;
+	const pairs = [];
+	for (const [axis, rawValue] of Object.entries(axes)) {
+		if (axis === "wght" || axis === "wdth" || axis === "ital") continue;
+		const value = Array.isArray(rawValue) ? rawValue[0] : rawValue;
+		if (value === void 0) continue;
+		pairs.push(`"${axis}" ${value}`);
+	}
+	return pairs.length ? pairs.join(", ") : null;
+};
+const updateDeclaration = (block, property, value) => {
+	const pattern = new RegExp(`${property}\\s*:[^;]*;`, "i");
+	if (pattern.test(block)) return block.replace(pattern, `${property}: ${value};`);
+	return block.replace(/}\s*$/, `  ${property}: ${value};\n}`);
+};
+const applyVariableAxes = (block, axes) => {
+	if (!axes) return block;
+	let next = block;
+	if (axes.wght !== void 0) {
+		const value = Array.isArray(axes.wght) ? `${axes.wght[0]} ${axes.wght[1]}` : `${axes.wght}`;
+		next = updateDeclaration(next, "font-weight", value);
+	}
+	if (axes.wdth !== void 0) {
+		const value = Array.isArray(axes.wdth) ? `${axes.wdth[0]}% ${axes.wdth[1]}%` : `${axes.wdth}%`;
+		next = updateDeclaration(next, "font-stretch", value);
+	}
+	if (axes.ital !== void 0) {
+		const value = axes.ital === 1 ? "italic" : "normal";
+		next = updateDeclaration(next, "font-style", value);
+	}
+	const variationSettings = toVariationSettings(axes);
+	if (variationSettings) next = updateDeclaration(next, "font-variation-settings", variationSettings);
+	return next;
+};
+const rewriteFontFace = (block, cssUrl, downloads, axes, fontFolder) => {
+	return applyVariableAxes(block.replace(/url\(([^)]+)\)/g, (match, rawUrl) => {
+		const cleaned = rawUrl.trim().replace(/^['"]|['"]$/g, "");
+		const resolvedUrl = new URL(cleaned, cssUrl);
+		const filename = node_path.default.basename(resolvedUrl.pathname);
+		const targetPath = fontFolder ? `${fontFolder}/${filename}` : filename;
+		downloads.set(resolvedUrl.href, targetPath);
+		return `url("./fonts/${targetPath}")`;
+	}), axes);
+};
+const fetchCss = async (url) => {
+	const cached = cssCache.get(url);
+	if (cached) return cached;
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Fontsource CSS fetch failed: ${response.status} ${response.statusText} (${url})`);
+	const text = await response.text();
+	cssCache.set(url, text);
+	return text;
+};
+const fetchFontFiles = async (downloads, fontsDir) => {
+	if (!downloads.size) return;
+	await node_fs_promises.default.mkdir(fontsDir, { recursive: true });
+	for (const [url, filename] of downloads.entries()) {
+		const filePath = node_path.default.join(fontsDir, filename);
+		try {
+			await node_fs_promises.default.access(filePath);
+			continue;
+		} catch {}
+		const response = await fetch(url);
+		if (!response.ok) throw new Error(`Fontsource download failed: ${response.status} ${response.statusText} (${url})`);
+		const buffer = Buffer.from(await response.arrayBuffer());
+		await node_fs_promises.default.writeFile(filePath, buffer);
+	}
+};
+const readTextIfExists = async (filePath) => {
+	try {
+		return await node_fs_promises.default.readFile(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+};
+const writeTextFile = async (filePath, text) => {
+	await node_fs_promises.default.mkdir(node_path.default.dirname(filePath), { recursive: true });
+	await node_fs_promises.default.writeFile(filePath, text);
+};
+const buildFontFolderName = (id, version, variable) => `${id}-${version}${variable ? "-variable" : ""}`;
+const parseVersionFromFolder = (id, folderName, variable) => {
+	const prefix = `${id}-`;
+	const suffix = variable ? "-variable" : "";
+	if (!folderName.startsWith(prefix)) return null;
+	if (suffix && !folderName.endsWith(suffix)) return null;
+	return folderName.slice(prefix.length, suffix ? -suffix.length : void 0) || null;
+};
+const compareSemver = (a, b) => {
+	const aParts = a.split(".").map((v) => Number(v));
+	const bParts = b.split(".").map((v) => Number(v));
+	const length = Math.max(aParts.length, bParts.length);
+	for (let i = 0; i < length; i += 1) {
+		const aVal = Number.isFinite(aParts[i]) ? aParts[i] : 0;
+		const bVal = Number.isFinite(bParts[i]) ? bParts[i] : 0;
+		if (aVal !== bVal) return aVal - bVal;
+	}
+	return 0;
+};
+const findCachedVersion = async (fontsDir, id, variable) => {
+	try {
+		const versions = (await node_fs_promises.default.readdir(fontsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => parseVersionFromFolder(id, entry.name, variable)).filter((value) => Boolean(value));
+		if (!versions.length) return null;
+		versions.sort(compareSemver);
+		return versions[versions.length - 1] ?? null;
+	} catch {
+		return null;
+	}
+};
+const mergeFontTokens = (api, tokens) => {
+	if (!tokens || Object.keys(tokens).length === 0) return;
+	const existing = api.tokens;
+	if (typeof existing === "function") {
+		api.tokens = (valueMap) => {
+			const base = existing(valueMap);
+			const font = {
+				...base?.font ?? {},
+				...tokens
+			};
+			return {
+				...base ?? {},
+				font
+			};
+		};
+		return;
+	}
+	const existingRecord = existing ?? {};
+	const existingFont = existingRecord.font ?? {};
+	api.tokens = {
+		...existingRecord,
+		font: {
+			...existingFont,
+			...tokens
+		}
+	};
+};
+const addFontFaceBlocks = (api, cssText, cssUrl, downloads, axes, fontFolder) => {
+	const blocks = cssText.match(/@font-face\s*{[^}]*}/g) || [];
+	for (const block of blocks) {
+		const next = rewriteFontFace(block, cssUrl, downloads, axes, fontFolder);
+		api.css.addRule(next.trim());
+	}
+};
+const onBoot = async (api) => {
+	if (api.runtime?.only) return;
+	const fonts = api.fonts;
+	if (!Array.isArray(fonts) || fonts.length === 0) return;
+	const importUrls = [];
+	const importSet = /* @__PURE__ */ new Set();
+	const downloads = /* @__PURE__ */ new Map();
+	const stylesDir = api.stylesheetPath ? node_path.default.dirname(api.stylesheetPath) : node_path.default.join(process.cwd(), api.folder ?? ".bo$$");
+	const fontsDir = node_path.default.join(stylesDir, "fonts");
+	const fontTokens = {};
+	for (const font of fonts) {
+		if (!font?.name) continue;
+		const entry = getFontEntry(font.name);
+		const id = entry?.id ?? normalizeFontName(font.name);
+		const packageName = buildPackageName(font, entry);
+		const isLocal = font.delivery === "local";
+		let npmVersion = isValidNpmVersion(font.version) ? font.version : null;
+		if (!npmVersion && isLocal) {
+			const cachedVersion = await findCachedVersion(fontsDir, id, font.variable === true);
+			if (isValidNpmVersion(cachedVersion)) npmVersion = cachedVersion;
+		}
+		if (!npmVersion) npmVersion = await resolveNpmVersion(id, font.variable === true, font.version);
+		const resolvedVersion = npmVersion ?? "latest";
+		const cssFiles = buildCssFiles(font, entry);
+		const axes = font.variable ? font.variableAxes : void 0;
+		const fontFolder = isLocal ? buildFontFolderName(id, resolvedVersion, font.variable === true) : null;
+		if (font.token) fontTokens[font.token] = entry?.family ?? font.name;
+		for (const file of cssFiles) {
+			const cssUrl = `${CDN_NPM_BASE}/${packageName}@${resolvedVersion}/${file}`;
+			if (isLocal) {
+				const cachePath = node_path.default.join(fontsDir, fontFolder ?? "", file);
+				let cssText = await readTextIfExists(cachePath);
+				if (!cssText) {
+					cssText = await fetchCss(cssUrl);
+					await writeTextFile(cachePath, cssText);
+				}
+				addFontFaceBlocks(api, cssText, cssUrl, downloads, axes, fontFolder ?? void 0);
+			} else if (!importSet.has(cssUrl)) {
+				importSet.add(cssUrl);
+				importUrls.push(cssUrl);
+			}
+		}
+	}
+	for (const url of importUrls) api.css.addImport(url);
+	mergeFontTokens(api, fontTokens);
+	await fetchFontFiles(downloads, fontsDir);
+};
+
+//#endregion
+exports.name = name;
+exports.onBoot = onBoot;
+Object.defineProperty(exports, 'server_exports', {
+  enumerable: true,
+  get: function () {
+    return server_exports;
+  }
+});

package/dist/fontsource/server.mjs

@@ -0,0 +1,282 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { fontDirectory } from "./directory.mjs";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+//#region src/fontsource/server.ts
+var server_exports = /* @__PURE__ */ __exportAll({
+	name: () => name,
+	onBoot: () => onBoot
+});
+const name = "fontsource";
+const API_BASE = "https://api.fontsource.org";
+const CDN_NPM_BASE = "https://cdn.jsdelivr.net/npm";
+const fontDirectoryEntries = fontDirectory;
+const fontById = new Map(fontDirectoryEntries.map((entry) => [entry.id, entry]));
+const versionCache = /* @__PURE__ */ new Map();
+const cssCache = /* @__PURE__ */ new Map();
+const normalizeFontName = (value) => value.toLowerCase().replace(/["']/g, "").replace(/[_\s]+/g, "-").replace(/-+/g, "-").trim();
+const fontByFamily = new Map(fontDirectoryEntries.map((entry) => [normalizeFontName(entry.family), entry]));
+const ensureArray = (value) => {
+	if (value == null) return [];
+	return Array.isArray(value) ? Array.from(value) : [value];
+};
+const isVariableConfig = (font) => font.variable === true;
+const getFontEntry = (name) => {
+	if (!name) return null;
+	const normalized = normalizeFontName(name);
+	return fontById.get(normalized) || fontByFamily.get(normalized) || null;
+};
+const isValidNpmVersion = (value) => {
+	if (!value) return false;
+	if (value === "latest") return true;
+	return /^\d+\.\d+\.\d+/.test(value);
+};
+const fetchJson = async (url) => {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Fontsource request failed: ${response.status} ${response.statusText} (${url})`);
+	return response.json();
+};
+const resolveNpmVersion = async (id, variable, version) => {
+	if (isValidNpmVersion(version)) return version;
+	const cached = versionCache.get(id);
+	if (cached) return variable ? cached.latestVariable || cached.latest || "latest" : cached.latest || "latest";
+	const data = await fetchJson(`${API_BASE}/v1/version/${id}`);
+	versionCache.set(id, data);
+	return variable ? data.latestVariable || data.latest || "latest" : data.latest || "latest";
+};
+const resolveSubsets = (font, entry) => {
+	const subsets = ensureArray(font.subsets);
+	if (subsets.length) return subsets;
+	if (entry?.defSubset) return [entry.defSubset];
+	return entry?.subsets?.length ? Array.from(entry.subsets) : [];
+};
+const resolveWeights = (font, entry) => {
+	const weights = ensureArray(font.weights);
+	if (weights.length) return weights;
+	return entry?.weights?.length ? Array.from(entry.weights) : [];
+};
+const resolveStyles = (font, entry) => {
+	const styles = ensureArray(font.styles);
+	if (styles.length) return styles;
+	return entry?.styles?.length ? Array.from(entry.styles) : [];
+};
+const buildStaticCssFiles = (subsets, weights, styles) => {
+	const files = [];
+	const hasSubsets = subsets.length > 0;
+	const normalizedWeights = weights.length ? weights : ["400"];
+	const normalizedStyles = styles.length ? styles : ["normal"];
+	for (const weight of normalizedWeights) {
+		const weightValue = String(weight);
+		for (const style of normalizedStyles) {
+			const styleSuffix = style && style !== "normal" ? `-${style}` : "";
+			if (hasSubsets) for (const subset of subsets) files.push(`${subset}-${weightValue}${styleSuffix}.css`);
+			else files.push(`${weightValue}${styleSuffix}.css`);
+		}
+	}
+	return files;
+};
+const buildVariableCssFiles = (_font) => {
+	return ["index.css"];
+};
+const buildCssFiles = (font, entry) => {
+	if (isVariableConfig(font)) return buildVariableCssFiles(font);
+	return buildStaticCssFiles(resolveSubsets(font, entry), resolveWeights(font, entry), resolveStyles(font, entry));
+};
+const buildPackageName = (font, entry) => {
+	const id = entry?.id ?? normalizeFontName(font.name);
+	return font.variable ? `@fontsource-variable/${id}` : `@fontsource/${id}`;
+};
+const toVariationSettings = (axes) => {
+	if (!axes) return null;
+	const pairs = [];
+	for (const [axis, rawValue] of Object.entries(axes)) {
+		if (axis === "wght" || axis === "wdth" || axis === "ital") continue;
+		const value = Array.isArray(rawValue) ? rawValue[0] : rawValue;
+		if (value === void 0) continue;
+		pairs.push(`"${axis}" ${value}`);
+	}
+	return pairs.length ? pairs.join(", ") : null;
+};
+const updateDeclaration = (block, property, value) => {
+	const pattern = new RegExp(`${property}\\s*:[^;]*;`, "i");
+	if (pattern.test(block)) return block.replace(pattern, `${property}: ${value};`);
+	return block.replace(/}\s*$/, `  ${property}: ${value};\n}`);
+};
+const applyVariableAxes = (block, axes) => {
+	if (!axes) return block;
+	let next = block;
+	if (axes.wght !== void 0) {
+		const value = Array.isArray(axes.wght) ? `${axes.wght[0]} ${axes.wght[1]}` : `${axes.wght}`;
+		next = updateDeclaration(next, "font-weight", value);
+	}
+	if (axes.wdth !== void 0) {
+		const value = Array.isArray(axes.wdth) ? `${axes.wdth[0]}% ${axes.wdth[1]}%` : `${axes.wdth}%`;
+		next = updateDeclaration(next, "font-stretch", value);
+	}
+	if (axes.ital !== void 0) {
+		const value = axes.ital === 1 ? "italic" : "normal";
+		next = updateDeclaration(next, "font-style", value);
+	}
+	const variationSettings = toVariationSettings(axes);
+	if (variationSettings) next = updateDeclaration(next, "font-variation-settings", variationSettings);
+	return next;
+};
+const rewriteFontFace = (block, cssUrl, downloads, axes, fontFolder) => {
+	return applyVariableAxes(block.replace(/url\(([^)]+)\)/g, (match, rawUrl) => {
+		const cleaned = rawUrl.trim().replace(/^['"]|['"]$/g, "");
+		const resolvedUrl = new URL(cleaned, cssUrl);
+		const filename = path.basename(resolvedUrl.pathname);
+		const targetPath = fontFolder ? `${fontFolder}/${filename}` : filename;
+		downloads.set(resolvedUrl.href, targetPath);
+		return `url("./fonts/${targetPath}")`;
+	}), axes);
+};
+const fetchCss = async (url) => {
+	const cached = cssCache.get(url);
+	if (cached) return cached;
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Fontsource CSS fetch failed: ${response.status} ${response.statusText} (${url})`);
+	const text = await response.text();
+	cssCache.set(url, text);
+	return text;
+};
+const fetchFontFiles = async (downloads, fontsDir) => {
+	if (!downloads.size) return;
+	await fs.mkdir(fontsDir, { recursive: true });
+	for (const [url, filename] of downloads.entries()) {
+		const filePath = path.join(fontsDir, filename);
+		try {
+			await fs.access(filePath);
+			continue;
+		} catch {}
+		const response = await fetch(url);
+		if (!response.ok) throw new Error(`Fontsource download failed: ${response.status} ${response.statusText} (${url})`);
+		const buffer = Buffer.from(await response.arrayBuffer());
+		await fs.writeFile(filePath, buffer);
+	}
+};
+const readTextIfExists = async (filePath) => {
+	try {
+		return await fs.readFile(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+};
+const writeTextFile = async (filePath, text) => {
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, text);
+};
+const buildFontFolderName = (id, version, variable) => `${id}-${version}${variable ? "-variable" : ""}`;
+const parseVersionFromFolder = (id, folderName, variable) => {
+	const prefix = `${id}-`;
+	const suffix = variable ? "-variable" : "";
+	if (!folderName.startsWith(prefix)) return null;
+	if (suffix && !folderName.endsWith(suffix)) return null;
+	return folderName.slice(prefix.length, suffix ? -suffix.length : void 0) || null;
+};
+const compareSemver = (a, b) => {
+	const aParts = a.split(".").map((v) => Number(v));
+	const bParts = b.split(".").map((v) => Number(v));
+	const length = Math.max(aParts.length, bParts.length);
+	for (let i = 0; i < length; i += 1) {
+		const aVal = Number.isFinite(aParts[i]) ? aParts[i] : 0;
+		const bVal = Number.isFinite(bParts[i]) ? bParts[i] : 0;
+		if (aVal !== bVal) return aVal - bVal;
+	}
+	return 0;
+};
+const findCachedVersion = async (fontsDir, id, variable) => {
+	try {
+		const versions = (await fs.readdir(fontsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => parseVersionFromFolder(id, entry.name, variable)).filter((value) => Boolean(value));
+		if (!versions.length) return null;
+		versions.sort(compareSemver);
+		return versions[versions.length - 1] ?? null;
+	} catch {
+		return null;
+	}
+};
+const mergeFontTokens = (api, tokens) => {
+	if (!tokens || Object.keys(tokens).length === 0) return;
+	const existing = api.tokens;
+	if (typeof existing === "function") {
+		api.tokens = (valueMap) => {
+			const base = existing(valueMap);
+			const font = {
+				...base?.font ?? {},
+				...tokens
+			};
+			return {
+				...base ?? {},
+				font
+			};
+		};
+		return;
+	}
+	const existingRecord = existing ?? {};
+	const existingFont = existingRecord.font ?? {};
+	api.tokens = {
+		...existingRecord,
+		font: {
+			...existingFont,
+			...tokens
+		}
+	};
+};
+const addFontFaceBlocks = (api, cssText, cssUrl, downloads, axes, fontFolder) => {
+	const blocks = cssText.match(/@font-face\s*{[^}]*}/g) || [];
+	for (const block of blocks) {
+		const next = rewriteFontFace(block, cssUrl, downloads, axes, fontFolder);
+		api.css.addRule(next.trim());
+	}
+};
+const onBoot = async (api) => {
+	if (api.runtime?.only) return;
+	const fonts = api.fonts;
+	if (!Array.isArray(fonts) || fonts.length === 0) return;
+	const importUrls = [];
+	const importSet = /* @__PURE__ */ new Set();
+	const downloads = /* @__PURE__ */ new Map();
+	const stylesDir = api.stylesheetPath ? path.dirname(api.stylesheetPath) : path.join(process.cwd(), api.folder ?? ".bo$$");
+	const fontsDir = path.join(stylesDir, "fonts");
+	const fontTokens = {};
+	for (const font of fonts) {
+		if (!font?.name) continue;
+		const entry = getFontEntry(font.name);
+		const id = entry?.id ?? normalizeFontName(font.name);
+		const packageName = buildPackageName(font, entry);
+		const isLocal = font.delivery === "local";
+		let npmVersion = isValidNpmVersion(font.version) ? font.version : null;
+		if (!npmVersion && isLocal) {
+			const cachedVersion = await findCachedVersion(fontsDir, id, font.variable === true);
+			if (isValidNpmVersion(cachedVersion)) npmVersion = cachedVersion;
+		}
+		if (!npmVersion) npmVersion = await resolveNpmVersion(id, font.variable === true, font.version);
+		const resolvedVersion = npmVersion ?? "latest";
+		const cssFiles = buildCssFiles(font, entry);
+		const axes = font.variable ? font.variableAxes : void 0;
+		const fontFolder = isLocal ? buildFontFolderName(id, resolvedVersion, font.variable === true) : null;
+		if (font.token) fontTokens[font.token] = entry?.family ?? font.name;
+		for (const file of cssFiles) {
+			const cssUrl = `${CDN_NPM_BASE}/${packageName}@${resolvedVersion}/${file}`;
+			if (isLocal) {
+				const cachePath = path.join(fontsDir, fontFolder ?? "", file);
+				let cssText = await readTextIfExists(cachePath);
+				if (!cssText) {
+					cssText = await fetchCss(cssUrl);
+					await writeTextFile(cachePath, cssText);
+				}
+				addFontFaceBlocks(api, cssText, cssUrl, downloads, axes, fontFolder ?? void 0);
+			} else if (!importSet.has(cssUrl)) {
+				importSet.add(cssUrl);
+				importUrls.push(cssUrl);
+			}
+		}
+	}
+	for (const url of importUrls) api.css.addImport(url);
+	mergeFontTokens(api, fontTokens);
+	await fetchFontFiles(downloads, fontsDir);
+};
+
+//#endregion
+export { name, onBoot, server_exports };

package/dist/index.cjs

@@ -0,0 +1,10 @@
+const require_build = require('./tasks/build.cjs');
+const require_watch = require('./tasks/watch.cjs');
+const require_compile = require('./tasks/compile.cjs');
+const require_postcss = require('./tasks/postcss.cjs');
+
+exports.resolveBuildConfig = require_build.resolveBuildConfig;
+exports.runBuild = require_build.runBuild;
+exports.runCompile = require_compile.runCompile;
+exports.runPostcss = require_postcss.runPostcss;
+exports.runWatch = require_watch.runWatch;

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { resolveBuildConfig, runBuild } from "./tasks/build.mjs";
+import { runWatch } from "./tasks/watch.mjs";
+import { runCompile } from "./tasks/compile.mjs";
+import { runPostcss } from "./tasks/postcss.mjs";
+
+export { resolveBuildConfig, runBuild, runCompile, runPostcss, runWatch };

package/dist/log/browser.cjs

@@ -0,0 +1,28 @@
+const require_debug = require('../shared/debug.cjs');
+
+//#region src/log/browser.ts
+const normalizeDebugValue = (debug) => debug === true ? "boss:*" : debug;
+const createLogger = (namespace, debug) => {
+	const matcher = require_debug.createDebugMatcher(normalizeDebugValue(debug));
+	const cache = /* @__PURE__ */ new Map();
+	const getLogger = (nextNamespace) => {
+		const existing = cache.get(nextNamespace);
+		if (existing) return existing;
+		const enabled = matcher(nextNamespace);
+		const logger = {
+			namespace: nextNamespace,
+			enabled,
+			log: (...args) => {
+				if (!enabled) return;
+				console.log(nextNamespace, ...args);
+			},
+			child: (name) => getLogger(`${nextNamespace}:${name}`)
+		};
+		cache.set(nextNamespace, logger);
+		return logger;
+	};
+	return getLogger(namespace);
+};
+
+//#endregion
+exports.createLogger = createLogger;

package/dist/log/browser.mjs

@@ -0,0 +1,28 @@
+import { createDebugMatcher } from "../shared/debug.mjs";
+
+//#region src/log/browser.ts
+const normalizeDebugValue = (debug) => debug === true ? "boss:*" : debug;
+const createLogger = (namespace, debug) => {
+	const matcher = createDebugMatcher(normalizeDebugValue(debug));
+	const cache = /* @__PURE__ */ new Map();
+	const getLogger = (nextNamespace) => {
+		const existing = cache.get(nextNamespace);
+		if (existing) return existing;
+		const enabled = matcher(nextNamespace);
+		const logger = {
+			namespace: nextNamespace,
+			enabled,
+			log: (...args) => {
+				if (!enabled) return;
+				console.log(nextNamespace, ...args);
+			},
+			child: (name) => getLogger(`${nextNamespace}:${name}`)
+		};
+		cache.set(nextNamespace, logger);
+		return logger;
+	};
+	return getLogger(namespace);
+};
+
+//#endregion
+export { createLogger };

package/dist/log/server.cjs

@@ -0,0 +1,32 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_debug = require('../shared/debug.cjs');
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+
+//#region src/log/server.ts
+const normalizeDebugValue = (debug$1) => debug$1 === true ? "boss:*" : debug$1;
+const createLogger = (namespace, debug$1) => {
+	const matcher = require_debug.createDebugMatcher(normalizeDebugValue(debug$1));
+	const cache = /* @__PURE__ */ new Map();
+	const getLogger = (nextNamespace) => {
+		const existing = cache.get(nextNamespace);
+		if (existing) return existing;
+		const instance = (0, debug.default)(nextNamespace);
+		instance.enabled = matcher(nextNamespace);
+		const logger = {
+			namespace: nextNamespace,
+			enabled: instance.enabled,
+			log: (...args) => {
+				if (!instance.enabled) return;
+				instance(...args);
+			},
+			child: (name) => getLogger(`${nextNamespace}:${name}`)
+		};
+		cache.set(nextNamespace, logger);
+		return logger;
+	};
+	return getLogger(namespace);
+};
+
+//#endregion
+exports.createLogger = createLogger;