fontmin-rs 0.1.0-beta.1

package/dist/compat-B1CHDyqO.mjs

@@ -0,0 +1,1257 @@
+import { css, deliverySlices, glyph, otf2ttf, svg2ttf, svgs2ttf, ttf2eot, ttf2svg, ttf2woff, ttf2woff2 } from "./plugins.mjs";
+import { createRequire } from "node:module";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parse } from "jsonc-parser";
+import { createHash } from "node:crypto";
+import { glob } from "tinyglobby";
+import { readFileSync } from "node:fs";
+//#region src/config.ts
+const DEFAULT_CONFIG_FILES = [
+	"fontmin.config.ts",
+	"fontmin.config.mts",
+	"fontmin.config.mjs",
+	"fontmin.config.cjs",
+	"fontmin.config.json",
+	"fontmin.config.jsonc"
+];
+function defineConfig(config) {
+	return config;
+}
+async function loadConfig(configPath) {
+	const resolvedPath = configPath === void 0 ? await findConfig() : resolve(configPath);
+	const extension = extname(resolvedPath);
+	const configDir = dirname(resolvedPath);
+	let config;
+	if (extension === ".json") {
+		const contents = await readFile(resolvedPath, "utf8");
+		config = JSON.parse(contents);
+	} else if (extension === ".jsonc") config = parse(await readFile(resolvedPath, "utf8"));
+	else {
+		const configModule = await import(pathToFileURL(resolvedPath).href);
+		const loadedConfig = configModule.default ?? configModule.config;
+		config = typeof loadedConfig === "function" ? await loadedConfig() : loadedConfig;
+	}
+	return defineConfig(withConfigDefaults(config, configDir));
+}
+async function findConfig(cwd = process.cwd()) {
+	for (const fileName of DEFAULT_CONFIG_FILES) {
+		const configPath = resolve(cwd, fileName);
+		if (await isFile(configPath)) return configPath;
+	}
+	throw new Error(`could not find fontmin config in ${cwd}`);
+}
+async function isFile(path) {
+	try {
+		return (await stat(path)).isFile();
+	} catch {
+		return false;
+	}
+}
+function withConfigDefaults(config, configDir) {
+	if (config.cwd !== void 0) return config;
+	return {
+		...config,
+		cwd: configDir
+	};
+}
+//#endregion
+//#region src/native-loader.ts
+const require$1 = createRequire(import.meta.url);
+let binding;
+var NativeBindingLoadError = class extends Error {
+	constructor(cause) {
+		super("fontmin-rs native binding is unavailable", { cause });
+		this.name = "NativeBindingLoadError";
+	}
+};
+function loadNativeBinding() {
+	if (binding !== void 0) return binding;
+	try {
+		binding = require$1("@fontmin-rs/binding");
+	} catch (error) {
+		throw new NativeBindingLoadError(error);
+	}
+	return binding;
+}
+//#endregion
+//#region src/wasm-fallback.ts
+const require = createRequire(import.meta.url);
+const wasmPackageName = "@fontmin-rs/wasm";
+let runtime;
+async function loadWasmRuntime() {
+	runtime ??= initializeWasmRuntime();
+	return runtime;
+}
+async function initializeWasmRuntime() {
+	try {
+		const bytes = await readFile(join(dirname(require.resolve(wasmPackageName)), "fontmin_wasm_core_bg.wasm"));
+		const wasm = await import(wasmPackageName);
+		await wasm.initWasm(bytes);
+		return wasm;
+	} catch (cause) {
+		throw new Error("fontmin-rs WASM runtime failed to initialize", { cause });
+	}
+}
+//#endregion
+//#region src/native.ts
+function assignDefined(target, key, value) {
+	if (value !== void 0) target[key] = value;
+}
+function assertAvailableWoff2Fallback(fallback) {
+	if (fallback === void 0 || fallback === "native" || fallback === "auto") return;
+	throw new Error(fallback === "wasm" ? "WOFF2 fallback `wasm` is asynchronous; use ttfToWoff2Async() instead." : unavailableWoff2Fallback(fallback).message);
+}
+function unavailableWoff2Fallback(fallback) {
+	return /* @__PURE__ */ new Error(`WOFF2 fallback \`${fallback}\` is not available in this build`);
+}
+function toNativeSvgIcon(input) {
+	const nativeInput = {
+		contents: input.contents,
+		name: input.name
+	};
+	assignDefined(nativeInput, "unicode", input.unicode);
+	return nativeInput;
+}
+function toNativeSvg2TtfOptions(options) {
+	const nativeOptions = {};
+	assignDefined(nativeOptions, "hinting", options.hinting);
+	assignDefined(nativeOptions, "normalize", options.normalize);
+	return nativeOptions;
+}
+function toNativeSvgs2TtfOptions(options) {
+	const nativeOptions = {};
+	assignDefined(nativeOptions, "fontName", options.fontName);
+	assignDefined(nativeOptions, "startUnicode", options.startUnicode);
+	assignDefined(nativeOptions, "ascent", options.ascent);
+	assignDefined(nativeOptions, "descent", options.descent);
+	assignDefined(nativeOptions, "normalize", options.normalize);
+	return nativeOptions;
+}
+function toNativeWoffOptions(options) {
+	const nativeOptions = {};
+	assignDefined(nativeOptions, "deflate", options.deflate);
+	assignDefined(nativeOptions, "compressionLevel", options.compressionLevel);
+	assignDefined(nativeOptions, "metadata", options.metadata);
+	if (options.privateData !== void 0) nativeOptions.privateData = Buffer.isBuffer(options.privateData) ? options.privateData : Buffer.from(options.privateData);
+	return nativeOptions;
+}
+function subsetTtf(input, options = {}) {
+	const nativeOptions = {};
+	const text = resolveSubsetText(options);
+	if (text !== void 0) nativeOptions.text = text;
+	if (options.unicodes !== void 0) nativeOptions.unicodes = options.unicodes;
+	if (options.unicodeRanges !== void 0) nativeOptions.unicodeRanges = options.unicodeRanges;
+	if (options.basicText !== void 0) nativeOptions.basicText = options.basicText;
+	if (options.trim !== void 0) nativeOptions.trim = options.trim;
+	if (options.keepNotdef !== void 0) nativeOptions.keepNotdef = options.keepNotdef;
+	if (options.keepLayout !== void 0) nativeOptions.keepLayout = options.keepLayout;
+	const preserveHinting = options.preserveHinting ?? options.hinting;
+	if (preserveHinting !== void 0) nativeOptions.preserveHinting = preserveHinting;
+	const inputBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+	return loadNativeBinding().subsetTtf(inputBuffer, nativeOptions);
+}
+function resolveSubsetText(options) {
+	if (options.textFile === void 0) return options.text;
+	const fileText = readFileSync(options.textFile, "utf8");
+	return options.text === void 0 ? fileText : `${options.text}${fileText}`;
+}
+function inspect(input) {
+	const inputBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+	return loadNativeBinding().inspectFont(inputBuffer);
+}
+function ttfToWoff(input, options = {}) {
+	const inputBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+	return loadNativeBinding().ttfToWoff(inputBuffer, toNativeWoffOptions(options));
+}
+function woffToTtf(input) {
+	const inputBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+	return loadNativeBinding().woffToTtf(inputBuffer);
+}
+function woff2ToTtf(input) {
+	const inputBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+	return loadNativeBinding().woff2ToTtf(inputBuffer);
+}
+function eotToTtf(input) {
+	const inputBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+	return loadNativeBinding().eotToTtf(inputBuffer);
+}
+function otfToTtf(input, options = {}) {
+	const nativeOptions = {};
+	assignDefined(nativeOptions, "preserveHinting", options.preserveHinting);
+	assignDefined(nativeOptions, "variationCoordinates", options.variationCoordinates);
+	const inputBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+	return loadNativeBinding().otfToTtf(inputBuffer, nativeOptions);
+}
+function ttfToWoff2(input, options = {}) {
+	const nativeOptions = {};
+	assertAvailableWoff2Fallback(options.fallback);
+	if (options.quality !== void 0) nativeOptions.quality = options.quality;
+	const inputBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+	return loadNativeBinding().ttfToWoff2(inputBuffer, nativeOptions);
+}
+async function ttfToWoff2Async(input, options = {}) {
+	if (options.fallback === "wasm") return ttfToWoff2WithWasm(input, options);
+	if (options.fallback === "js") throw unavailableWoff2Fallback("js");
+	try {
+		return ttfToWoff2(input, {
+			...options,
+			fallback: "native"
+		});
+	} catch (error) {
+		if (options.fallback === "native" || !(error instanceof NativeBindingLoadError)) throw error;
+		return ttfToWoff2WithWasm(input, options);
+	}
+}
+async function ttfToWoff2WithWasm(input, options) {
+	const wasm = await loadWasmRuntime();
+	const wasmOptions = options.quality === void 0 ? {} : { quality: options.quality };
+	try {
+		const output = await wasm.ttfToWoff2(input, wasmOptions);
+		return Buffer.from(output);
+	} catch (error) {
+		throw new Error("WOFF2 WASM fallback failed", { cause: error });
+	}
+}
+function validateWoff2(input) {
+	const inputBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+	loadNativeBinding().validateWoff2(inputBuffer);
+}
+function ttfToEot(input, options = {}) {
+	const nativeOptions = {};
+	if (options.version !== void 0) nativeOptions.version = options.version;
+	const inputBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+	return loadNativeBinding().ttfToEot(inputBuffer, nativeOptions);
+}
+function ttfToSvg(input, options = {}) {
+	const nativeOptions = {};
+	if (options.fontFamily !== void 0) nativeOptions.fontFamily = options.fontFamily;
+	const inputBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+	return loadNativeBinding().ttfToSvg(inputBuffer, nativeOptions);
+}
+function svgFontToTtf(input, options = {}) {
+	return loadNativeBinding().svgFontToTtf(input, toNativeSvg2TtfOptions(options));
+}
+function svgsToTtf(inputs, options = {}) {
+	return loadNativeBinding().svgsToTtf(inputs.map((input) => toNativeSvgIcon(input)), toNativeSvgs2TtfOptions(options));
+}
+function generateFontFaceCss(sources, options = {}) {
+	const nativeSources = sources.map((source) => toNativeCssFontSource(source));
+	const nativeOptions = {};
+	if (options.fontFamily !== void 0) nativeOptions.fontFamily = resolveCssFontFamily(sources, options.fontFamily);
+	if (options.fontPath !== void 0) nativeOptions.fontPath = options.fontPath;
+	if (options.base64 !== void 0) nativeOptions.base64 = options.base64;
+	if (options.glyph !== void 0) nativeOptions.glyph = options.glyph;
+	if (options.iconPrefix !== void 0) nativeOptions.iconPrefix = options.iconPrefix;
+	if (options.asFileName !== void 0) nativeOptions.asFileName = options.asFileName;
+	if (options.local !== void 0) nativeOptions.local = options.local;
+	if (options.fontDisplay !== void 0) nativeOptions.fontDisplay = options.fontDisplay;
+	if (options.target !== void 0) nativeOptions.target = options.target;
+	if (options.unicodeRanges !== void 0) nativeOptions.unicodeRanges = options.unicodeRanges;
+	return loadNativeBinding().generateFontFaceCss(nativeSources, nativeOptions);
+}
+function resolveCssFontFamily(sources, fontFamily) {
+	if (typeof fontFamily === "string") return fontFamily;
+	const source = sources.find((source) => source.contents !== void 0);
+	if (source?.contents === void 0) throw new Error("CSS fontFamily resolver requires source contents");
+	return fontFamily(inspect(source.contents));
+}
+function toNativeCssFontSource(source) {
+	const nativeSource = {
+		fileName: source.fileName,
+		format: source.format
+	};
+	if (source.contents !== void 0) nativeSource.contents = Buffer.isBuffer(source.contents) ? source.contents : Buffer.from(source.contents);
+	if (source.glyphs !== void 0) nativeSource.glyphs = source.glyphs;
+	if (source.unicodeRanges !== void 0) nativeSource.unicodeRanges = source.unicodeRanges;
+	return nativeSource;
+}
+//#endregion
+//#region src/optimize-runtime.ts
+function resolvePipelineRuntimeMode(configured, fallbacks) {
+	if (fallbacks.includes("js")) throw new Error("WOFF2 fallback `js` is not available in this build");
+	const legacy = [...new Set(fallbacks)];
+	if (legacy.length > 1) throw new Error(`conflicting WOFF2 fallback modes: ${legacy.join(", ")}`);
+	const fallback = legacy[0];
+	if (configured !== void 0 && fallback !== void 0 && configured !== fallback) throw new Error(`runtime \`${configured}\` conflicts with WOFF2 fallback \`${fallback}\``);
+	return configured ?? fallback ?? "native";
+}
+function createRuntimeSelector(requested, loaders = defaultRuntimeLoaders) {
+	let selected;
+	return {
+		requested,
+		resolve() {
+			selected ??= selectRuntime(requested, loaders);
+			return selected;
+		}
+	};
+}
+async function selectRuntime(requested, loaders) {
+	if (requested === "native") return loaders.loadNative();
+	if (requested === "wasm") return loaders.loadWasm();
+	try {
+		return loaders.loadNative();
+	} catch (error) {
+		if (!(error instanceof NativeBindingLoadError)) throw error;
+		return loaders.loadWasm();
+	}
+}
+const nativeRuntime = {
+	kind: "native",
+	async generateFontFaceCss(sources, options) {
+		return generateFontFaceCss(sources, options);
+	},
+	async inspect(input) {
+		return inspect(input);
+	},
+	async otfToTtf(input, options) {
+		return otfToTtf(input, options);
+	},
+	async subsetTtf(input, options) {
+		return subsetTtf(input, options);
+	},
+	async svgFontToTtf(input, options) {
+		return svgFontToTtf(input, options);
+	},
+	async svgsToTtf(inputs, options) {
+		return svgsToTtf(inputs, options);
+	},
+	async ttfToEot(input, options) {
+		return ttfToEot(input, options);
+	},
+	async ttfToSvg(input, options) {
+		return ttfToSvg(input, options);
+	},
+	async ttfToWoff(input, options) {
+		return ttfToWoff(input, options);
+	},
+	async ttfToWoff2(input, options) {
+		return ttfToWoff2(input, options);
+	}
+};
+async function createWasmRuntime(loadRuntime = loadWasmRuntime) {
+	const wasm = await loadRuntime();
+	return {
+		kind: "wasm",
+		async generateFontFaceCss(sources, options) {
+			const { ext: _ext, fileName: _fileName, fontFamily, ...wasmOptions } = options;
+			assertWasmOptionSupported("generateFontFaceCss", "fontFamily", typeof fontFamily === "function" ? fontFamily : void 0);
+			return runWasmOperation("generateFontFaceCss", () => wasm.generateFontFaceCss(sources, {
+				...wasmOptions,
+				...typeof fontFamily === "string" ? { fontFamily } : {}
+			}));
+		},
+		inspect: (input) => runWasmOperation("inspect", () => wasm.inspect(input)),
+		otfToTtf: (input, options) => runWasmOperation("otfToTtf", () => wasm.otfToTtf(input, options)),
+		async subsetTtf(input, options) {
+			const { clone: _clone, keepLayout, hinting, textFile, ...wasmOptions } = options;
+			assertWasmOptionSupported("subsetTtf", "textFile", textFile);
+			return runWasmOperation("subsetTtf", () => wasm.subsetTtf(input, {
+				...wasmOptions,
+				...keepLayout === void 0 ? {} : { layout: keepLayout },
+				...options.preserveHinting === void 0 && hinting !== void 0 ? { preserveHinting: hinting } : {}
+			}));
+		},
+		svgFontToTtf: (input, options) => runWasmOperation("svgFontToTtf", () => wasm.svgFontToTtf(input, options)),
+		svgsToTtf: (inputs, options) => runWasmOperation("svgsToTtf", () => wasm.svgsToTtf(inputs, options)),
+		ttfToEot: (input, options) => runWasmOperation("ttfToEot", () => wasm.ttfToEot(input, options)),
+		ttfToSvg: (input, options) => runWasmOperation("ttfToSvg", () => wasm.ttfToSvg(input, options)),
+		ttfToWoff: (input, options) => runWasmOperation("ttfToWoff", () => wasm.ttfToWoff(input, options)),
+		ttfToWoff2(input, options) {
+			const { clone: _clone, fallback: _fallback, ...wasmOptions } = options;
+			return runWasmOperation("ttfToWoff2", () => wasm.ttfToWoff2(input, wasmOptions));
+		}
+	};
+}
+async function runWasmOperation(operation, run) {
+	try {
+		return await run();
+	} catch (error) {
+		if (error instanceof Error) throw error;
+		throw new Error(typeof error === "string" ? error : `fontmin-rs WASM runtime failed during ${operation}`, { cause: error });
+	}
+}
+function assertWasmOptionSupported(operation, name, value) {
+	if (value !== void 0) throw new Error(`fontmin-rs WASM ${operation} does not support option ${name}`);
+}
+const defaultRuntimeLoaders = {
+	loadNative() {
+		loadNativeBinding();
+		return nativeRuntime;
+	},
+	loadWasm: createWasmRuntime
+};
+//#endregion
+//#region src/optimize.ts
+const CACHE_SCHEMA_VERSION = "v1";
+const FONTMIN_VERSION = "0.1.0-beta.1";
+const DEFAULT_CACHE_DIR = "node_modules/.cache/fontmin-rs";
+const DEFAULT_SVG_ICON_START_UNICODE = 57345;
+const CSS_GLYPHS_META_KEY = "cssGlyphs";
+const CSS_UNICODE_RANGES_META_KEY = "cssUnicodeRanges";
+const MIME_TYPES_BY_FORMAT = {
+	eot: "application/vnd.ms-fontobject",
+	svg: "image/svg+xml",
+	ttf: "font/ttf",
+	woff: "font/woff",
+	woff2: "font/woff2"
+};
+async function optimize(config) {
+	const cwd = config.cwd === void 0 ? process.cwd() : config.cwd;
+	config = await resolveConfigTextFile(config, cwd);
+	const plugins = sortPlugins(await resolvePluginTextFiles(pluginsFromConfig(config), cwd));
+	const legacyFallbacks = woff2FallbacksFromPlugins(plugins);
+	const runtime = createRuntimeSelector(resolvePipelineRuntimeMode(config.runtime, legacyFallbacks));
+	const cacheOptions = normalizeCacheOptions(config.cache, cwd);
+	const emittedAssets = [];
+	const context = createPluginContext(cwd, emittedAssets);
+	for (const plugin of plugins) if (plugin.buildStart !== void 0) await plugin.buildStart(context);
+	let assets = await loadInputAssets(config.input ?? [], cwd);
+	const cacheRuntime = cacheOptions.enabled && isCacheablePipeline(plugins) ? await cacheRuntimeIdentity(config, plugins, runtime) : void 0;
+	const cacheKey = cacheRuntime === void 0 ? void 0 : cacheKeyForAssets(assets, config, plugins, cacheRuntime);
+	const cachedAssets = cacheKey === void 0 || cacheRuntime === void 0 ? void 0 : await readCachedAssets(cacheOptions.dir, cacheKey, cacheRuntime);
+	if (cachedAssets === void 0) {
+		const subset = config.subset;
+		if (subset !== void 0) assets = await flatMapAssets(assets, async (asset) => runGlyph(asset, subset, await runtime.resolve()));
+		for (const plugin of plugins) {
+			assets = await transformAssets(assets, plugin, context, runtime);
+			assets = [...assets, ...emittedAssets.splice(0)];
+		}
+		for (const plugin of plugins) if (isBuiltin(plugin, "css")) {
+			const cssAsset = await runCss(assets, plugin.native.options, await runtime.resolve());
+			if (cssAsset !== void 0) assets = assets.concat(cssAsset);
+		} else {
+			if (plugin.generateBundle !== void 0) await plugin.generateBundle(assets, context);
+			assets = [...assets, ...emittedAssets.splice(0)];
+		}
+		if (cacheKey !== void 0 && cacheRuntime !== void 0) await writeCachedAssets(cacheOptions.dir, cacheKey, cacheRuntime, assets);
+	} else assets = cachedAssets;
+	if (config.outDir !== void 0) {
+		const outDir = resolve(cwd, config.outDir);
+		if (config.clean === true) await rm(outDir, {
+			recursive: true,
+			force: true
+		});
+		await writeAssets(outDir, assets);
+	}
+	for (const plugin of plugins) if (plugin.buildEnd !== void 0) await plugin.buildEnd(context);
+	return assets;
+}
+function createPluginContext(cwd, emittedAssets) {
+	const diagnostics = [];
+	return {
+		cwd,
+		diagnostics,
+		emitFile(asset) {
+			emittedAssets.push(asset);
+		},
+		readFile(path) {
+			return readFile(resolve(cwd, path));
+		},
+		resolve(path) {
+			return resolve(cwd, path);
+		},
+		warn(message) {
+			diagnostics.push({
+				level: "warn",
+				message: warningMessage(message)
+			});
+		},
+		async writeFile(path, contents) {
+			const filePath = resolve(cwd, path);
+			await mkdir(dirname(filePath), { recursive: true });
+			await writeFile(filePath, contents);
+		}
+	};
+}
+function warningMessage(message) {
+	return typeof message === "string" ? message : message.message;
+}
+async function resolveConfigTextFile(config, cwd) {
+	if (config.subset === void 0) return config;
+	const subset = await resolveSubsetTextFile(config.subset, cwd);
+	if (subset === config.subset) return config;
+	return {
+		...config,
+		subset
+	};
+}
+async function resolvePluginTextFiles(plugins, cwd) {
+	const resolvedPlugins = [];
+	for (const plugin of plugins) resolvedPlugins.push(await resolvePluginTextFile(plugin, cwd));
+	return resolvedPlugins;
+}
+async function resolvePluginTextFile(plugin, cwd) {
+	if (!isBuiltin(plugin, "glyph")) return plugin;
+	const options = await resolveSubsetTextFile(plugin.native.options, cwd);
+	if (options === plugin.native.options) return plugin;
+	return {
+		...plugin,
+		native: {
+			...plugin.native,
+			options
+		}
+	};
+}
+async function resolveSubsetTextFile(options, cwd) {
+	if (options.textFile === void 0) return options;
+	const fileText = await readFile(resolve(cwd, options.textFile), "utf8");
+	const { textFile: _textFile, ...resolvedOptions } = options;
+	return {
+		...resolvedOptions,
+		text: mergeSubsetText(options.text, fileText)
+	};
+}
+function mergeSubsetText(text, fileText) {
+	return text === void 0 ? fileText : `${text}${fileText}`;
+}
+function pluginsFromConfig(config) {
+	const plugins = [...config.plugins ?? []];
+	if (config.outputs === void 0) return plugins;
+	const outputs = config.outputs.map(normalizeOutputConfig);
+	const requestedOutputs = outputs.map((output) => output.format);
+	const fontOutputs = requestedOutputs.filter((format) => format !== "css");
+	for (const output of outputs) {
+		const plugin = outputPluginFromConfig(output);
+		if (plugin !== void 0) plugins.push(plugin);
+	}
+	if (fontOutputs.length > 0) plugins.push(outputFilterPlugin(fontOutputs));
+	if (requestedOutputs.includes("css")) {
+		const cssOutput = outputs.find((output) => output.format === "css");
+		plugins.push(builtinPlugin("css", {
+			...cssOptionsRecord(config.css),
+			...outputPathOptionsRecord(cssOutput)
+		}), outputFilterPlugin(requestedOutputs, "post"));
+	}
+	return plugins;
+}
+function normalizeOutputConfig(output) {
+	if (typeof output === "string") return {
+		clone: true,
+		format: output
+	};
+	const config = {
+		clone: output.clone ?? true,
+		format: output.format
+	};
+	if (output.ext !== void 0) config.ext = output.ext;
+	if (output.fileName !== void 0) config.fileName = output.fileName;
+	return config;
+}
+function outputPluginFromConfig(output) {
+	if (output.format === "ttf" || output.format === "css") return;
+	const options = {
+		clone: output.clone ?? true,
+		...outputPathOptionsRecord(output)
+	};
+	if (output.format === "eot") return builtinPlugin("ttf2eot", options);
+	if (output.format === "svg") return builtinPlugin("ttf2svg", options);
+	if (output.format === "woff") return builtinPlugin("ttf2woff", options);
+	return builtinPlugin("ttf2woff2", options);
+}
+function outputPathOptionsRecord(output) {
+	const record = {};
+	if (output?.ext !== void 0) record["ext"] = output.ext;
+	if (output?.fileName !== void 0) record["fileName"] = output.fileName;
+	return record;
+}
+function builtinPlugin(name, options) {
+	return {
+		name: `fontmin:${name}`,
+		native: {
+			kind: "builtin",
+			name,
+			options
+		}
+	};
+}
+function outputFilterPlugin(formats, enforce) {
+	const plugin = {
+		name: "fontmin:output-filter",
+		generateBundle(assets) {
+			const retainedAssets = assets.filter((asset) => {
+				const format = outputFormatFromAsset(asset);
+				return format !== void 0 && formats.includes(format);
+			});
+			assets.splice(0, assets.length, ...retainedAssets);
+		}
+	};
+	if (enforce !== void 0) plugin.enforce = enforce;
+	return plugin;
+}
+function outputFormatFromAsset(asset) {
+	if (asset.format === "unknown" || asset.format === "otf") return;
+	return asset.format;
+}
+function cssOptionsRecord(options) {
+	const record = {};
+	if (options?.base64 !== void 0) record["base64"] = options.base64;
+	if (options?.asFileName !== void 0) record["asFileName"] = options.asFileName;
+	if (options?.fontDisplay !== void 0) record["fontDisplay"] = options.fontDisplay;
+	if (options?.fontFamily !== void 0) record["fontFamily"] = options.fontFamily;
+	if (options?.fontPath !== void 0) record["fontPath"] = options.fontPath;
+	if (options?.glyph !== void 0) record["glyph"] = options.glyph;
+	if (options?.iconPrefix !== void 0) record["iconPrefix"] = options.iconPrefix;
+	if (options?.local !== void 0) record["local"] = options.local;
+	if (options?.target !== void 0) record["target"] = options.target;
+	if (options?.unicodeRanges !== void 0) record["unicodeRanges"] = options.unicodeRanges;
+	return record;
+}
+async function readCachedAssets(cacheDir, key, runtime) {
+	let manifest;
+	try {
+		manifest = JSON.parse(await readFile(cacheManifestPath(cacheDir, key), "utf8"));
+	} catch {
+		return;
+	}
+	if (manifest.version !== CACHE_SCHEMA_VERSION || manifest.key !== key || manifest.runtime?.requested !== runtime.requested || manifest.runtime.resolved !== runtime.resolved) return;
+	const entryDir = cacheEntryDir(cacheDir, key);
+	const assets = [];
+	try {
+		for (const record of manifest.assets) {
+			const contents = await readFile(join(entryDir, record.fileName));
+			assets.push({
+				path: record.path,
+				contents,
+				format: record.format,
+				sourceFormat: record.sourceFormat,
+				meta: {
+					...record.meta,
+					cache: {
+						hit: true,
+						key
+					}
+				}
+			});
+		}
+	} catch {
+		return;
+	}
+	return assets;
+}
+async function writeCachedAssets(cacheDir, key, runtime, assets) {
+	const entryDir = cacheEntryDir(cacheDir, key);
+	const records = [];
+	await mkdir(entryDir, { recursive: true });
+	for (const [index, asset] of assets.entries()) {
+		const fileName = `${String(index).padStart(3, "0")}.${asset.format}`;
+		await writeFile(join(entryDir, fileName), asset.contents);
+		records.push({
+			fileName,
+			format: asset.format,
+			meta: asset.meta,
+			path: asset.path,
+			sourceFormat: asset.sourceFormat
+		});
+	}
+	await writeFile(cacheManifestPath(cacheDir, key), `${JSON.stringify({
+		assets: records,
+		key,
+		runtime,
+		version: CACHE_SCHEMA_VERSION
+	}, void 0, 2)}\n`);
+	await updateCacheIndex(cacheDir, key, records);
+}
+async function updateCacheIndex(cacheDir, key, assets) {
+	const indexPath = cacheIndexPath(cacheDir);
+	let index = {
+		entries: {},
+		version: CACHE_SCHEMA_VERSION
+	};
+	try {
+		index = JSON.parse(await readFile(indexPath, "utf8"));
+	} catch {}
+	if (index.version !== CACHE_SCHEMA_VERSION) index = {
+		entries: {},
+		version: CACHE_SCHEMA_VERSION
+	};
+	index.entries[key] = {
+		assets: assets.map((asset) => asset.path),
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await mkdir(dirname(indexPath), { recursive: true });
+	await writeFile(indexPath, `${JSON.stringify(index, void 0, 2)}\n`);
+}
+async function loadInputAssets(inputs, cwd) {
+	if (inputs.length === 0) throw new Error("fontmin-rs optimize requires at least one input");
+	const assets = [];
+	for (const input of inputs) if (typeof input === "string") {
+		const inputPaths = await expandInputPath(input, cwd);
+		for (const inputPath of inputPaths) {
+			const contents = await readFile(inputPath);
+			const format = detectFormat(contents);
+			assets.push({
+				path: basename(inputPath),
+				contents,
+				format,
+				sourceFormat: format,
+				meta: { inputPath }
+			});
+		}
+	} else {
+		const contents = Buffer.from(input);
+		const format = detectFormat(contents);
+		assets.push({
+			path: `fontmin.${extensionForFormat(format)}`,
+			contents,
+			format,
+			sourceFormat: format,
+			meta: {}
+		});
+	}
+	return assets;
+}
+async function expandInputPath(input, cwd) {
+	if (!isGlobPattern(input)) return [resolve(cwd, input)];
+	const matches = await glob(input, {
+		absolute: true,
+		cwd,
+		onlyFiles: true
+	});
+	if (matches.length === 0) throw new Error(`fontmin-rs input glob matched no files: ${input}`);
+	return matches.sort((left, right) => left.localeCompare(right));
+}
+function isGlobPattern(path) {
+	return /[*?[\]{}]/.test(path);
+}
+async function transformAssets(assets, plugin, context, runtime) {
+	if (isBuiltin(plugin, "glyph")) return flatMapAssets(assets, async (asset) => runGlyph(asset, plugin.native.options, await runtime.resolve()));
+	if (isBuiltin(plugin, "unicodeSlices")) return flatMapAssets(assets, async (asset) => runUnicodeSlices(asset, plugin.native.options, await runtime.resolve()));
+	if (isBuiltin(plugin, "otf2ttf")) return flatMapAssets(assets, async (asset) => runOtf2Ttf(asset, plugin.native.options, await runtime.resolve()));
+	if (isBuiltin(plugin, "ttf2woff")) return flatMapAssets(assets, async (asset) => runTtf2Woff(asset, plugin.native.options, await runtime.resolve()));
+	if (isBuiltin(plugin, "ttf2woff2")) return flatMapAssets(assets, async (asset) => runTtf2Woff2(asset, plugin.native.options, await runtime.resolve()));
+	if (isBuiltin(plugin, "ttf2eot")) return flatMapAssets(assets, async (asset) => runTtf2Eot(asset, plugin.native.options, await runtime.resolve()));
+	if (isBuiltin(plugin, "ttf2svg")) return flatMapAssets(assets, async (asset) => runTtf2Svg(asset, plugin.native.options, await runtime.resolve()));
+	if (isBuiltin(plugin, "svg2ttf")) return flatMapAssets(assets, async (asset) => runSvg2Ttf(asset, plugin.native.options, await runtime.resolve()));
+	if (isBuiltin(plugin, "svgs2ttf")) return runSvgs2Ttf(assets, plugin.native.options, await runtime.resolve());
+	if (isBuiltin(plugin, "css")) return assets;
+	if (plugin.transform === void 0) return assets;
+	const transformedAssets = [];
+	for (const asset of assets) {
+		const result = await plugin.transform(asset, context);
+		if (result === void 0) transformedAssets.push(asset);
+		else if (Array.isArray(result)) transformedAssets.push(...result);
+		else if (result !== null) transformedAssets.push(result);
+	}
+	return transformedAssets;
+}
+async function flatMapAssets(assets, transform) {
+	const transformed = [];
+	for (const asset of assets) transformed.push(...await transform(asset));
+	return transformed;
+}
+async function runGlyph(asset, options, runtime) {
+	if (asset.format !== "ttf") return [asset];
+	const meta = withCssGlyphs(asset.meta, cssGlyphsFromSubsetOptions(options));
+	const subsetAsset = {
+		path: replaceExtension(asset.path, "ttf"),
+		contents: Buffer.from(await runtime.subsetTtf(asset.contents, runtimeSubsetOptions(options))),
+		format: "ttf",
+		sourceFormat: asset.sourceFormat,
+		meta
+	};
+	return options.clone === true ? [asset, subsetAsset] : [subsetAsset];
+}
+async function runUnicodeSlices(asset, options, runtime) {
+	if (asset.format !== "ttf") return [asset];
+	return Promise.all(deliverySlicesFromOptions(options).map(async (slice) => ({
+		path: appendAssetSuffix(asset.path, slice.name),
+		contents: Buffer.from(await runtime.subsetTtf(asset.contents, { unicodeRanges: slice.unicodeRanges })),
+		format: "ttf",
+		sourceFormat: asset.sourceFormat,
+		meta: {
+			...asset.meta,
+			[CSS_UNICODE_RANGES_META_KEY]: slice.unicodeRanges
+		}
+	})));
+}
+function deliverySlicesFromOptions(options) {
+	const values = options["slices"];
+	if (!Array.isArray(values) || values.length === 0) throw new Error("unicode delivery slices must not be empty");
+	const names = /* @__PURE__ */ new Set();
+	return values.map((value, index) => {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`unicode delivery slice ${index + 1} must be an object`);
+		const { name, unicodeRanges } = value;
+		if (typeof name !== "string" || name.length === 0 || !/^[A-Za-z0-9_-]+$/u.test(name)) throw new Error(`unicode delivery slice ${index + 1} must have a name containing only letters, digits, hyphens, or underscores`);
+		if (names.has(name)) throw new Error(`unicode delivery slice name is duplicated: ${name}`);
+		if (!Array.isArray(unicodeRanges) || unicodeRanges.length === 0 || unicodeRanges.some((range) => typeof range !== "string" || range.length === 0)) throw new Error(`unicode delivery slice ${name} must include at least one Unicode range`);
+		names.add(name);
+		return {
+			name,
+			unicodeRanges: [...unicodeRanges]
+		};
+	});
+}
+function runtimeSubsetOptions(options) {
+	const { clone: _clone, ...runtimeOptions } = options;
+	return Object.fromEntries(Object.entries(runtimeOptions).filter(([, value]) => value !== void 0));
+}
+async function runTtf2Woff(asset, options, runtime) {
+	if (asset.format !== "ttf") return [asset];
+	const woffAsset = {
+		path: outputPathForAsset(asset.path, "woff", options),
+		contents: Buffer.from(await runtime.ttfToWoff(asset.contents, woffOptions(options))),
+		format: "woff",
+		sourceFormat: asset.sourceFormat,
+		meta: convertedMeta(asset)
+	};
+	return options["clone"] === false ? [woffAsset] : [asset, woffAsset];
+}
+async function runTtf2Woff2(asset, options, runtime) {
+	if (asset.format !== "ttf") return [asset];
+	const woff2Asset = {
+		path: outputPathForAsset(asset.path, "woff2", options),
+		contents: Buffer.from(await runtime.ttfToWoff2(asset.contents, woff2Options(options))),
+		format: "woff2",
+		sourceFormat: asset.sourceFormat,
+		meta: convertedMeta(asset)
+	};
+	return options["clone"] === false ? [woff2Asset] : [asset, woff2Asset];
+}
+async function runTtf2Eot(asset, options, runtime) {
+	if (asset.format !== "ttf") return [asset];
+	const eotAsset = {
+		path: outputPathForAsset(asset.path, "eot", options),
+		contents: Buffer.from(await runtime.ttfToEot(asset.contents, eotOptions(options))),
+		format: "eot",
+		sourceFormat: asset.sourceFormat,
+		meta: convertedMeta(asset)
+	};
+	return options["clone"] === false ? [eotAsset] : [asset, eotAsset];
+}
+async function runTtf2Svg(asset, options, runtime) {
+	if (asset.format !== "ttf") return [asset];
+	const svgAsset = {
+		path: outputPathForAsset(asset.path, "svg", options),
+		contents: Buffer.from(await runtime.ttfToSvg(asset.contents, svgOptions(options))),
+		format: "svg",
+		sourceFormat: asset.sourceFormat,
+		meta: convertedMeta(asset)
+	};
+	return options["clone"] === false ? [svgAsset] : [asset, svgAsset];
+}
+async function runOtf2Ttf(asset, options, runtime) {
+	if (asset.format !== "otf") return [asset];
+	const ttfAsset = {
+		path: outputPathForAsset(asset.path, "ttf", options),
+		contents: Buffer.from(await runtime.otfToTtf(asset.contents, otf2TtfOptions(options))),
+		format: "ttf",
+		sourceFormat: asset.sourceFormat,
+		meta: convertedMeta(asset)
+	};
+	return options["clone"] === false ? [ttfAsset] : [asset, ttfAsset];
+}
+async function runSvg2Ttf(asset, options, runtime) {
+	if (asset.format !== "svg") return [asset];
+	const ttfAsset = {
+		path: outputPathForAsset(asset.path, "ttf", options),
+		contents: Buffer.from(await runtime.svgFontToTtf(Buffer.from(asset.contents).toString("utf8"), svg2TtfOptions(options))),
+		format: "ttf",
+		sourceFormat: asset.sourceFormat,
+		meta: convertedMeta(asset)
+	};
+	return options["clone"] === false ? [ttfAsset] : [asset, ttfAsset];
+}
+async function runSvgs2Ttf(assets, options, runtime) {
+	const svgAssets = assets.filter((asset) => asset.format === "svg");
+	if (svgAssets.length === 0) return assets;
+	const nonSvgAssets = assets.filter((asset) => asset.format !== "svg");
+	const firstSvg = svgAssets[0];
+	if (firstSvg === void 0) return assets;
+	const fontName = typeof options["fontName"] === "string" ? options["fontName"] : basenameWithoutExtension(firstSvg.path);
+	const icons = svgAssets.map((asset, index) => svgIconFromAsset(asset, index));
+	const cssGlyphs = cssGlyphsFromSvgIcons(icons, typeof options["startUnicode"] === "number" ? options["startUnicode"] : DEFAULT_SVG_ICON_START_UNICODE);
+	const ttfAsset = {
+		path: `${fontName}.ttf`,
+		contents: Buffer.from(await runtime.svgsToTtf(icons, svgs2TtfOptions(options))),
+		format: "ttf",
+		sourceFormat: firstSvg.sourceFormat,
+		meta: {
+			[CSS_GLYPHS_META_KEY]: cssGlyphs,
+			sourcePaths: svgAssets.map((asset) => asset.path)
+		}
+	};
+	return options["clone"] === true ? [...assets, ttfAsset] : [...nonSvgAssets, ttfAsset];
+}
+function convertedMeta(asset) {
+	return {
+		...asset.meta,
+		sourcePath: asset.path
+	};
+}
+async function runCss(assets, options, runtime) {
+	const sourceAssets = assets.filter((asset) => isCssSourceFormat(asset.format));
+	const sources = sourceAssets.flatMap((asset) => cssSourceFromAsset(asset, options.base64 === true));
+	const firstAsset = sourceAssets[0];
+	if (sources.length === 0 || firstAsset === void 0) return;
+	const css = await runtime.generateFontFaceCss(sources, await cssOptionsForSources(options, firstAsset, runtime));
+	return {
+		path: outputPathForAsset(firstAsset.path, cssTargetExtension(options.target), options),
+		contents: Buffer.from(css),
+		format: "css",
+		sourceFormat: firstAsset.sourceFormat,
+		meta: {}
+	};
+}
+function cssSourceFromAsset(asset, inline) {
+	if (!isCssSourceFormat(asset.format)) return [];
+	const source = {
+		fileName: inline ? dataUrlForAsset(asset) : asset.path,
+		format: asset.format
+	};
+	const glyphs = cssGlyphsFromAsset(asset);
+	if (glyphs.length > 0) source.glyphs = glyphs;
+	const unicodeRanges = asset.meta[CSS_UNICODE_RANGES_META_KEY];
+	if (Array.isArray(unicodeRanges) && unicodeRanges.every((range) => typeof range === "string")) source.unicodeRanges = unicodeRanges;
+	return [source];
+}
+async function cssOptionsForSources(options, source, runtime) {
+	const resolvedOptions = await cssOptionsWithResolvedFontFamily(options, source, runtime);
+	if (resolvedOptions.base64 !== true) return resolvedOptions;
+	const inlineOptions = { fontPath: "" };
+	if (resolvedOptions.fontFamily !== void 0) inlineOptions.fontFamily = resolvedOptions.fontFamily;
+	if (resolvedOptions.glyph !== void 0) inlineOptions.glyph = resolvedOptions.glyph;
+	if (resolvedOptions.iconPrefix !== void 0) inlineOptions.iconPrefix = resolvedOptions.iconPrefix;
+	if (resolvedOptions.asFileName !== void 0) inlineOptions.asFileName = resolvedOptions.asFileName;
+	if (resolvedOptions.local !== void 0) inlineOptions.local = resolvedOptions.local;
+	if (resolvedOptions.fontDisplay !== void 0) inlineOptions.fontDisplay = resolvedOptions.fontDisplay;
+	return inlineOptions;
+}
+async function cssOptionsWithResolvedFontFamily(options, source, runtime) {
+	if (typeof options.fontFamily !== "function") return options;
+	return {
+		...options,
+		fontFamily: options.fontFamily(await runtime.inspect(source.contents))
+	};
+}
+function cssTargetExtension(target) {
+	return target ?? "css";
+}
+function outputPathForAsset(path, defaultExtension, options) {
+	if (options.fileName !== void 0) return options.fileName;
+	return replaceExtension(path, options.ext ?? defaultExtension);
+}
+function cssGlyphsFromSubsetOptions(options) {
+	const seen = /* @__PURE__ */ new Set();
+	const glyphs = [];
+	for (const character of options.text ?? "") {
+		const unicode = character.codePointAt(0);
+		if (unicode !== void 0 && !seen.has(unicode)) {
+			seen.add(unicode);
+			glyphs.push({ unicode });
+		}
+	}
+	for (const unicode of options.unicodes ?? []) if (!seen.has(unicode)) {
+		seen.add(unicode);
+		glyphs.push({ unicode });
+	}
+	return glyphs;
+}
+function cssGlyphsFromSvgIcons(icons, startUnicode) {
+	let nextUnicode = startUnicode;
+	const seen = /* @__PURE__ */ new Set();
+	const glyphs = [];
+	for (const icon of icons) {
+		let unicode = icon.unicode;
+		if (unicode === void 0) {
+			while (seen.has(nextUnicode)) nextUnicode += 1;
+			unicode = nextUnicode;
+			nextUnicode += 1;
+		}
+		seen.add(unicode);
+		glyphs.push({
+			name: icon.name,
+			unicode
+		});
+	}
+	return glyphs;
+}
+function withCssGlyphs(meta, glyphs) {
+	if (glyphs.length === 0) return meta;
+	return {
+		...meta,
+		[CSS_GLYPHS_META_KEY]: glyphs
+	};
+}
+function cssGlyphsFromAsset(asset) {
+	const glyphs = asset.meta[CSS_GLYPHS_META_KEY];
+	if (!Array.isArray(glyphs)) return [];
+	return glyphs.flatMap((glyph) => {
+		if (typeof glyph !== "object" || glyph === null || !("unicode" in glyph) || typeof glyph.unicode !== "number") return [];
+		const cssGlyph = { unicode: glyph.unicode };
+		if ("name" in glyph && typeof glyph.name === "string") cssGlyph.name = glyph.name;
+		return [cssGlyph];
+	});
+}
+function dataUrlForAsset(asset) {
+	if (!isCssSourceFormat(asset.format)) throw new Error(`cannot inline ${asset.format} asset in CSS`);
+	const encoded = Buffer.from(asset.contents).toString("base64");
+	return `data:${mimeTypeForFormat(asset.format)};base64,${encoded}`;
+}
+function svgIconFromAsset(asset, index) {
+	const icon = {
+		contents: Buffer.from(asset.contents).toString("utf8"),
+		name: basenameWithoutExtension(asset.path) || `glyph-${index + 1}`
+	};
+	const { unicode } = asset.meta;
+	if (typeof unicode === "number") icon.unicode = unicode;
+	return icon;
+}
+function mimeTypeForFormat(format) {
+	return MIME_TYPES_BY_FORMAT[format];
+}
+function detectFormat(input) {
+	const bytes = Buffer.from(input);
+	if (bytes.subarray(0, 4).equals(Buffer.from([
+		0,
+		1,
+		0,
+		0
+	]))) return "ttf";
+	if (bytes.subarray(0, 4).toString("ascii") === "true") return "ttf";
+	if (bytes.subarray(0, 4).toString("ascii") === "OTTO") return "otf";
+	if (bytes.subarray(0, 4).toString("ascii") === "wOFF") return "woff";
+	if (bytes.subarray(0, 4).toString("ascii") === "wOF2") return "woff2";
+	if (looksLikeEot(bytes)) return "eot";
+	if (looksLikeSvg(bytes)) return "svg";
+	try {
+		return inspect(bytes).format;
+	} catch {
+		return "unknown";
+	}
+}
+function extensionForFormat(format) {
+	return format === "unknown" ? "bin" : format;
+}
+function looksLikeEot(bytes) {
+	if (bytes.byteLength < 12) return false;
+	const version = bytes.subarray(8, 12);
+	return version.equals(Buffer.from([
+		1,
+		0,
+		2,
+		0
+	])) || version.equals(Buffer.from([
+		2,
+		0,
+		2,
+		0
+	]));
+}
+function looksLikeSvg(bytes) {
+	const prefix = bytes.subarray(0, 512).toString("utf8").trimStart();
+	return prefix.startsWith("<svg") || prefix.startsWith("<?xml") && prefix.includes("<svg");
+}
+function isBuiltin(plugin, name) {
+	return plugin.native !== void 0 && plugin.native.kind === "builtin" && plugin.native.name === name;
+}
+function isCssSourceFormat(format) {
+	return format === "ttf" || format === "woff" || format === "woff2" || format === "eot" || format === "svg";
+}
+function replaceExtension(path, extension) {
+	const currentExtension = extname(path);
+	if (currentExtension === "") return `${path}.${extension}`;
+	return `${path.slice(0, -currentExtension.length)}.${extension}`;
+}
+function appendAssetSuffix(path, suffix) {
+	const currentExtension = extname(path);
+	return currentExtension === "" ? `${path}-${suffix}` : `${path.slice(0, -currentExtension.length)}-${suffix}${currentExtension}`;
+}
+function basenameWithoutExtension(path) {
+	const currentExtension = extname(path);
+	return currentExtension === "" ? basename(path) : basename(path, currentExtension);
+}
+function sortPlugins(plugins) {
+	const pre = [];
+	const normal = [];
+	const post = [];
+	for (const plugin of plugins) if (plugin.enforce === "pre") pre.push(plugin);
+	else if (plugin.enforce === "post") post.push(plugin);
+	else normal.push(plugin);
+	return [
+		...pre,
+		...normal,
+		...post
+	];
+}
+function woff2FallbacksFromPlugins(plugins) {
+	return plugins.flatMap((plugin) => {
+		if (!isBuiltin(plugin, "ttf2woff2")) return [];
+		const fallback = plugin.native.options["fallback"];
+		return isWoff2Fallback(fallback) ? [fallback] : [];
+	});
+}
+function woffOptions(options) {
+	const nativeOptions = {};
+	if (typeof options["deflate"] === "boolean") nativeOptions.deflate = options["deflate"];
+	if (typeof options["compressionLevel"] === "number") nativeOptions.compressionLevel = options["compressionLevel"];
+	return nativeOptions;
+}
+function woff2Options(options) {
+	const nativeOptions = {};
+	if (typeof options["quality"] === "number") nativeOptions.quality = options["quality"];
+	return nativeOptions;
+}
+function isWoff2Fallback(value) {
+	return value === "native" || value === "wasm" || value === "js" || value === "auto";
+}
+function eotOptions(options) {
+	const nativeOptions = {};
+	if (typeof options["version"] === "number") nativeOptions.version = options["version"];
+	return nativeOptions;
+}
+function otf2TtfOptions(options) {
+	const nativeOptions = {};
+	if (typeof options["preserveHinting"] === "boolean") nativeOptions.preserveHinting = options["preserveHinting"];
+	const variationCoordinates = options["variationCoordinates"];
+	if (variationCoordinates !== null && typeof variationCoordinates === "object" && !Array.isArray(variationCoordinates)) nativeOptions.variationCoordinates = Object.fromEntries(Object.entries(variationCoordinates).filter(([, value]) => typeof value === "number" && Number.isFinite(value)));
+	return nativeOptions;
+}
+function svgOptions(options) {
+	const nativeOptions = {};
+	if (typeof options["fontFamily"] === "string") nativeOptions.fontFamily = options["fontFamily"];
+	return nativeOptions;
+}
+function svg2TtfOptions(options) {
+	const nativeOptions = {};
+	if (typeof options["hinting"] === "boolean") nativeOptions.hinting = options["hinting"];
+	if (typeof options["normalize"] === "boolean") nativeOptions.normalize = options["normalize"];
+	return nativeOptions;
+}
+function svgs2TtfOptions(options) {
+	const nativeOptions = {};
+	if (typeof options["fontName"] === "string") nativeOptions.fontName = options["fontName"];
+	if (typeof options["startUnicode"] === "number") nativeOptions.startUnicode = options["startUnicode"];
+	if (typeof options["ascent"] === "number") nativeOptions.ascent = options["ascent"];
+	if (typeof options["descent"] === "number") nativeOptions.descent = options["descent"];
+	if (typeof options["normalize"] === "boolean") nativeOptions.normalize = options["normalize"];
+	return nativeOptions;
+}
+function cacheEntryDir(cacheDir, key) {
+	return join(cacheRoot(cacheDir), key.slice(0, 2), key.slice(2, 4), key);
+}
+function cacheIndexPath(cacheDir) {
+	return join(cacheRoot(cacheDir), "index.json");
+}
+function cacheManifestPath(cacheDir, key) {
+	return join(cacheEntryDir(cacheDir, key), "index.json");
+}
+function cacheRoot(cacheDir) {
+	return join(cacheDir, CACHE_SCHEMA_VERSION);
+}
+function cacheKeyForAssets(assets, config, plugins, runtime) {
+	return sha256(stableStringify({
+		clean: config.clean,
+		fontminVersion: FONTMIN_VERSION,
+		inputs: assets.map((asset) => ({
+			format: asset.format,
+			hash: sha256(asset.contents),
+			path: asset.path,
+			sourceFormat: asset.sourceFormat
+		})),
+		plugins: plugins.map((plugin) => ({
+			enforce: plugin.enforce,
+			name: plugin.name,
+			native: plugin.native
+		})),
+		preserveOriginal: config.preserveOriginal,
+		runtime,
+		schema: CACHE_SCHEMA_VERSION,
+		subset: config.subset
+	}));
+}
+async function cacheRuntimeIdentity(config, plugins, runtime) {
+	const resolved = config.subset !== void 0 || plugins.some((plugin) => plugin.native?.kind === "builtin") ? await runtime.resolve() : void 0;
+	return {
+		requested: runtime.requested,
+		resolved: resolved?.kind ?? null
+	};
+}
+function isCacheablePipeline(plugins) {
+	return plugins.every((plugin) => {
+		return plugin.native?.kind === "builtin" && plugin.buildStart === void 0 && plugin.transform === void 0 && plugin.generateBundle === void 0 && plugin.buildEnd === void 0;
+	});
+}
+function normalizeCacheOptions(options, cwd) {
+	if (options === void 0 || options === false) return {
+		dir: resolve(cwd, DEFAULT_CACHE_DIR),
+		enabled: false
+	};
+	if (options === true) return {
+		dir: resolve(cwd, DEFAULT_CACHE_DIR),
+		enabled: true
+	};
+	return {
+		dir: resolve(cwd, options.dir ?? DEFAULT_CACHE_DIR),
+		enabled: options.enabled ?? true
+	};
+}
+function sha256(input) {
+	return createHash("sha256").update(input).digest("hex");
+}
+function stableStringify(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+	return `{${Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => {
+		return `${JSON.stringify(key)}:${stableStringify(entryValue)}`;
+	}).join(",")}}`;
+}
+async function writeAssets(outDir, assets) {
+	for (const asset of assets) {
+		const outputPath = join(outDir, asset.path);
+		await mkdir(dirname(outputPath), { recursive: true });
+		await writeFile(outputPath, asset.contents);
+	}
+}
+//#endregion
+//#region src/compat.ts
+var FontminCompat = class {
+	static glyph = glyph;
+	static deliverySlices = deliverySlices;
+	static ttf2eot = ttf2eot;
+	static ttf2svg = ttf2svg;
+	static ttf2woff = ttf2woff;
+	static ttf2woff2 = ttf2woff2;
+	static otf2ttf = otf2ttf;
+	static svg2ttf = svg2ttf;
+	static svgs2ttf = svgs2ttf;
+	static css = css;
+	input = [];
+	outputDir;
+	plugins = [];
+	src(file) {
+		this.input = Array.isArray(file) ? file : [file];
+		return this;
+	}
+	dest(dir) {
+		this.outputDir = dir;
+		return this;
+	}
+	use(plugin) {
+		this.plugins.push(plugin);
+		return this;
+	}
+	config() {
+		const config = {
+			input: this.input,
+			plugins: this.plugins
+		};
+		if (this.outputDir !== void 0) config.outDir = this.outputDir;
+		return defineConfig(config);
+	}
+	runAsync() {
+		return optimize(this.config());
+	}
+	run(callback) {
+		const handleSuccess = (files) => {
+			callback(null, files);
+		};
+		const handleError = (error) => {
+			callback(error);
+		};
+		this.runAsync().then(handleSuccess).catch(handleError);
+	}
+};
+//#endregion
+export { woffToTtf as _, inspect as a, svgFontToTtf as c, ttfToSvg as d, ttfToWoff as f, woff2ToTtf as g, validateWoff2 as h, generateFontFaceCss as i, svgsToTtf as l, ttfToWoff2Async as m, optimize as n, otfToTtf as o, ttfToWoff2 as p, eotToTtf as r, subsetTtf as s, FontminCompat as t, ttfToEot as u, defineConfig as v, loadConfig as y };