fontmin-rs 0.1.0-beta.1

package/dist/compat.d.mts

@@ -0,0 +1,25 @@
+import { S as FontminPlugin, c as svgs2ttf, d as ttf2woff, f as ttf2woff2, i as glyph, l as ttf2eot, o as otf2ttf, r as deliverySlices, s as svg2ttf, t as css, u as ttf2svg, x as FontminConfig, y as FontAsset } from "./plugins-BeueRRP6.mjs";
+//#region src/compat.d.ts
+declare class FontminCompat {
+  static glyph: typeof glyph;
+  static deliverySlices: typeof deliverySlices;
+  static ttf2eot: typeof ttf2eot;
+  static ttf2svg: typeof ttf2svg;
+  static ttf2woff: typeof ttf2woff;
+  static ttf2woff2: typeof ttf2woff2;
+  static otf2ttf: typeof otf2ttf;
+  static svg2ttf: typeof svg2ttf;
+  static svgs2ttf: typeof svgs2ttf;
+  static css: typeof css;
+  private input;
+  private outputDir?;
+  private plugins;
+  src(file: string | string[] | Uint8Array): this;
+  dest(dir: string): this;
+  use(plugin: FontminPlugin): this;
+  config(): FontminConfig;
+  runAsync(): Promise<FontAsset[]>;
+  run(callback: (error: Error | null, files?: FontAsset[]) => void): void;
+}
+//#endregion
+export { FontminCompat as default };

package/dist/compat.mjs

@@ -0,0 +1,3 @@
+import { t as FontminCompat } from "./compat-B1CHDyqO.mjs";
+import "./plugins.mjs";
+export { FontminCompat as default };

package/dist/index.d.mts

@@ -0,0 +1,28 @@
+import { A as SubsetOptions, B as FontInfo, C as MaybePromise, D as PluginContext, E as OutputConfig, F as Ttf2Woff2Options, G as WoffOptions, H as LayoutSubsetMode, I as Ttf2WoffOptions, L as CssFontSource, M as Svgs2TtfOptions, N as Ttf2EotOptions, O as PluginDiagnostic, P as Ttf2SvgOptions, R as CssGlyph, S as FontminPlugin, T as Otf2TtfOptions, U as OutputFormat, V as FontMetadata, W as SvgIcon, _ as CssOptions, a as modernWeb, b as FontminCompatPresetOptions, c as svgs2ttf, d as ttf2woff, f as ttf2woff2, g as CssFontFamily, h as ConfigOutput, i as glyph, j as Svg2TtfOptions, k as RuntimeMode, l as ttf2eot, m as CacheOptions, n as definePlugin, o as otf2ttf, p as AssetFormat, r as deliverySlices, s as svg2ttf, t as css, u as ttf2svg, v as DeliverySlice, w as ModernWebOptions, x as FontminConfig, y as FontAsset, z as FontFormat } from "./plugins-BeueRRP6.mjs";
+import FontminCompat from "./compat.mjs";
+import { fontminCompatPreset } from "./presets.mjs";
+//#region src/config.d.ts
+declare function defineConfig<T extends FontminConfig>(config: T): T;
+declare function loadConfig(configPath?: string): Promise<FontminConfig>;
+//#endregion
+//#region src/native.d.ts
+declare function subsetTtf(input: Uint8Array, options?: SubsetOptions): Buffer;
+declare function inspect(input: Uint8Array): FontInfo;
+declare function ttfToWoff(input: Uint8Array, options?: WoffOptions): Buffer;
+declare function woffToTtf(input: Uint8Array): Buffer;
+declare function woff2ToTtf(input: Uint8Array): Buffer;
+declare function eotToTtf(input: Uint8Array): Buffer;
+declare function otfToTtf(input: Uint8Array, options?: Otf2TtfOptions): Buffer;
+declare function ttfToWoff2(input: Uint8Array, options?: Ttf2Woff2Options): Buffer;
+declare function ttfToWoff2Async(input: Uint8Array, options?: Ttf2Woff2Options): Promise<Buffer>;
+declare function validateWoff2(input: Uint8Array): void;
+declare function ttfToEot(input: Uint8Array, options?: Ttf2EotOptions): Buffer;
+declare function ttfToSvg(input: Uint8Array, options?: Ttf2SvgOptions): string;
+declare function svgFontToTtf(input: string, options?: Svg2TtfOptions): Buffer;
+declare function svgsToTtf(inputs: SvgIcon[], options?: Svgs2TtfOptions): Buffer;
+declare function generateFontFaceCss(sources: CssFontSource[], options?: CssOptions): string;
+//#endregion
+//#region src/optimize.d.ts
+declare function optimize(config: FontminConfig): Promise<FontAsset[]>;
+//#endregion
+export { type AssetFormat, type CacheOptions, type ConfigOutput, type CssFontFamily, type CssFontSource, type CssGlyph, type CssOptions, type DeliverySlice, type FontAsset, type FontFormat, type FontInfo, type FontMetadata, type FontminCompatPresetOptions, type FontminConfig, type FontminPlugin, type LayoutSubsetMode, type MaybePromise, type ModernWebOptions, type Otf2TtfOptions, type OutputConfig, type OutputFormat, type PluginContext, type PluginDiagnostic, type RuntimeMode, type SubsetOptions, type Svg2TtfOptions, type SvgIcon, type Svgs2TtfOptions, type Ttf2EotOptions, type Ttf2SvgOptions, type Ttf2Woff2Options, type Ttf2WoffOptions, type WoffOptions, css, FontminCompat as default, defineConfig, definePlugin, deliverySlices, eotToTtf, fontminCompatPreset, generateFontFaceCss, glyph, inspect, loadConfig, modernWeb, optimize, otf2ttf, otfToTtf, subsetTtf, svg2ttf, svgFontToTtf, svgs2ttf, svgsToTtf, ttf2eot, ttf2svg, ttf2woff, ttf2woff2, ttfToEot, ttfToSvg, ttfToWoff, ttfToWoff2, ttfToWoff2Async, validateWoff2, woff2ToTtf, woffToTtf };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { _ as woffToTtf, a as inspect, c as svgFontToTtf, d as ttfToSvg, f as ttfToWoff, g as woff2ToTtf, h as validateWoff2, i as generateFontFaceCss, l as svgsToTtf, m as ttfToWoff2Async, n as optimize, o as otfToTtf, p as ttfToWoff2, r as eotToTtf, s as subsetTtf, t as FontminCompat, u as ttfToEot, v as defineConfig, y as loadConfig } from "./compat-B1CHDyqO.mjs";
+import { css, definePlugin, deliverySlices, glyph, modernWeb, otf2ttf, svg2ttf, svgs2ttf, ttf2eot, ttf2svg, ttf2woff, ttf2woff2 } from "./plugins.mjs";
+import { fontminCompatPreset } from "./presets.mjs";
+export { css, FontminCompat as default, defineConfig, definePlugin, deliverySlices, eotToTtf, fontminCompatPreset, generateFontFaceCss, glyph, inspect, loadConfig, modernWeb, optimize, otf2ttf, otfToTtf, subsetTtf, svg2ttf, svgFontToTtf, svgs2ttf, svgsToTtf, ttf2eot, ttf2svg, ttf2woff, ttf2woff2, ttfToEot, ttfToSvg, ttfToWoff, ttfToWoff2, ttfToWoff2Async, validateWoff2, woff2ToTtf, woffToTtf };

package/dist/plugins-BeueRRP6.d.mts

@@ -0,0 +1,221 @@
+//#region ../../wasm/fontmin/types.d.ts
+type FontFormat = 'ttf' | 'otf' | 'woff' | 'woff2' | 'eot' | 'svg' | 'css' | 'unknown';
+type OutputFormat = 'ttf' | 'woff' | 'woff2' | 'eot' | 'svg' | 'css';
+type LayoutSubsetMode = 'drop' | 'conservative' | 'preserve';
+interface FontMetadata {
+  ascender: number;
+  descender: number;
+  familyName?: string;
+  fullName?: string;
+  glyphCount: number;
+  postScriptName?: string;
+  subfamilyName?: string;
+  tables: string[];
+  unitsPerEm: number;
+}
+interface FontInfo {
+  format: FontFormat;
+  metadata: FontMetadata;
+  size: number;
+}
+interface SubsetOptions$1 {
+  basicText?: boolean;
+  keepNotdef?: boolean;
+  layout?: LayoutSubsetMode;
+  preserveHinting?: boolean;
+  text?: string;
+  trim?: boolean;
+  unicodeRanges?: string[];
+  unicodes?: number[];
+}
+interface WoffOptions {
+  compressionLevel?: number;
+  deflate?: boolean;
+  metadata?: string;
+  privateData?: Uint8Array;
+}
+interface Ttf2Woff2Options$1 {
+  quality?: number;
+}
+interface Ttf2EotOptions$1 {
+  version?: number;
+}
+interface Ttf2SvgOptions$1 {
+  fontFamily?: string;
+}
+interface Otf2TtfOptions$1 {
+  preserveHinting?: boolean;
+  variationCoordinates?: Record<string, number>;
+}
+interface Svg2TtfOptions$1 {
+  hinting?: boolean;
+  normalize?: boolean;
+}
+interface SvgIcon {
+  contents: string;
+  name: string;
+  unicode?: number;
+}
+interface Svgs2TtfOptions$1 {
+  ascent?: number;
+  descent?: number;
+  fontName?: string;
+  normalize?: boolean;
+  startUnicode?: number;
+}
+interface CssGlyph {
+  name?: string;
+  unicode: number;
+}
+interface CssFontSource {
+  contents?: Uint8Array;
+  fileName: string;
+  format: Exclude<OutputFormat, 'css'>;
+  glyphs?: CssGlyph[];
+  unicodeRanges?: string[];
+}
+interface CssOptions$1 {
+  asFileName?: boolean;
+  base64?: boolean;
+  fontDisplay?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+  fontFamily?: string;
+  fontPath?: string;
+  glyph?: boolean;
+  iconPrefix?: string;
+  local?: boolean;
+  target?: 'css' | 'scss' | 'less';
+  unicodeRanges?: string[];
+}
+//#endregion
+//#region src/types.d.ts
+type AssetFormat = FontFormat | OutputFormat;
+type RuntimeMode = 'native' | 'wasm' | 'auto';
+type CssFontFamily = string | ((info: FontInfo) => string);
+interface SubsetOptions extends Omit<SubsetOptions$1, 'layout'> {
+  textFile?: string;
+  keepLayout?: LayoutSubsetMode;
+  hinting?: boolean;
+  clone?: boolean;
+}
+interface DeliverySlice {
+  name: string;
+  unicodeRanges: string[];
+}
+interface FontAsset {
+  path: string;
+  contents: Uint8Array;
+  format: AssetFormat;
+  sourceFormat: FontFormat;
+  meta: Record<string, unknown>;
+}
+interface PluginDiagnostic {
+  level: 'warn';
+  message: string;
+}
+interface PluginContext {
+  cwd: string;
+  diagnostics: PluginDiagnostic[];
+  emitFile(asset: FontAsset): void;
+  readFile(path: string): Promise<Buffer>;
+  resolve(path: string): string;
+  warn(message: string | Error): void;
+  writeFile(path: string, contents: string | Uint8Array): Promise<void>;
+}
+type MaybePromise<T> = T | Promise<T>;
+interface FontminPlugin {
+  name: string;
+  enforce?: 'pre' | 'post';
+  native?: {
+    kind: 'builtin';
+    name: string;
+    options: Record<string, unknown>;
+  };
+  buildStart?(ctx: PluginContext): MaybePromise<void>;
+  transform?(asset: FontAsset, ctx: PluginContext): MaybePromise<FontAsset | FontAsset[] | null | undefined>;
+  generateBundle?(assets: FontAsset[], ctx: PluginContext): MaybePromise<void>;
+  buildEnd?(ctx: PluginContext): MaybePromise<void>;
+}
+interface Ttf2WoffOptions extends Pick<WoffOptions, 'compressionLevel' | 'deflate'> {
+  clone?: boolean;
+}
+interface Ttf2Woff2Options extends Ttf2Woff2Options$1 {
+  clone?: boolean;
+  fallback?: 'native' | 'wasm' | 'js' | 'auto';
+}
+interface Ttf2EotOptions extends Ttf2EotOptions$1 {
+  clone?: boolean;
+}
+interface Otf2TtfOptions extends Otf2TtfOptions$1 {
+  clone?: boolean;
+}
+interface Ttf2SvgOptions extends Ttf2SvgOptions$1 {
+  clone?: boolean;
+}
+interface Svg2TtfOptions extends Svg2TtfOptions$1 {
+  clone?: boolean;
+}
+interface Svgs2TtfOptions extends Svgs2TtfOptions$1 {
+  clone?: boolean;
+}
+interface CssOptions extends Omit<CssOptions$1, 'fontFamily'> {
+  fontFamily?: CssFontFamily;
+}
+interface OutputConfig {
+  clone?: boolean;
+  ext?: string;
+  fileName?: string;
+  format: OutputFormat;
+}
+type ConfigOutput = OutputFormat | OutputConfig;
+interface ModernWebOptions extends SubsetOptions, Otf2TtfOptions, Ttf2WoffOptions, Ttf2Woff2Options {
+  fontFamily?: CssOptions['fontFamily'];
+  fontPath?: string;
+  local?: boolean;
+  fontDisplay?: CssOptions['fontDisplay'];
+}
+interface FontminCompatPresetOptions extends SubsetOptions, Ttf2WoffOptions, Ttf2Woff2Options, Otf2TtfOptions, Ttf2EotOptions, Ttf2SvgOptions {
+  asFileName?: boolean;
+  base64?: boolean;
+  cssGlyph?: boolean;
+  deflateWoff?: boolean;
+  fontDisplay?: CssOptions['fontDisplay'];
+  fontPath?: string;
+  glyph?: boolean;
+  glyphCss?: boolean;
+  iconPrefix?: string;
+  local?: boolean;
+  target?: CssOptions['target'];
+}
+interface FontminConfig {
+  cwd?: string;
+  input?: (string | Uint8Array)[];
+  outDir?: string;
+  clean?: boolean;
+  preserveOriginal?: boolean;
+  cache?: boolean | CacheOptions;
+  subset?: SubsetOptions;
+  outputs?: ConfigOutput[];
+  css?: CssOptions;
+  plugins?: FontminPlugin[];
+  runtime?: RuntimeMode;
+}
+interface CacheOptions {
+  enabled?: boolean;
+  dir?: string;
+}
+//#endregion
+//#region src/plugins.d.ts
+declare function definePlugin<T extends FontminPlugin>(plugin: T): T;
+declare function glyph(options?: SubsetOptions): FontminPlugin;
+declare function deliverySlices(slices: DeliverySlice[]): FontminPlugin;
+declare function ttf2woff(options?: Ttf2WoffOptions): FontminPlugin;
+declare function ttf2woff2(options?: Ttf2Woff2Options): FontminPlugin;
+declare function ttf2eot(options?: Ttf2EotOptions): FontminPlugin;
+declare function otf2ttf(options?: Otf2TtfOptions): FontminPlugin;
+declare function ttf2svg(options?: Ttf2SvgOptions): FontminPlugin;
+declare function svg2ttf(options?: Svg2TtfOptions): FontminPlugin;
+declare function svgs2ttf(options?: Svgs2TtfOptions): FontminPlugin;
+declare function css(options?: CssOptions): FontminPlugin;
+declare function modernWeb(options?: ModernWebOptions): FontminPlugin[];
+//#endregion
+export { SubsetOptions as A, FontInfo as B, MaybePromise as C, PluginContext as D, OutputConfig as E, Ttf2Woff2Options as F, WoffOptions as G, LayoutSubsetMode as H, Ttf2WoffOptions as I, CssFontSource as L, Svgs2TtfOptions as M, Ttf2EotOptions as N, PluginDiagnostic as O, Ttf2SvgOptions as P, CssGlyph as R, FontminPlugin as S, Otf2TtfOptions as T, OutputFormat as U, FontMetadata as V, SvgIcon as W, CssOptions as _, modernWeb as a, FontminCompatPresetOptions as b, svgs2ttf as c, ttf2woff as d, ttf2woff2 as f, CssFontFamily as g, ConfigOutput as h, glyph as i, Svg2TtfOptions as j, RuntimeMode as k, ttf2eot as l, CacheOptions as m, definePlugin as n, otf2ttf as o, AssetFormat as p, deliverySlices as r, svg2ttf as s, css as t, ttf2svg as u, DeliverySlice as v, ModernWebOptions as w, FontminConfig as x, FontAsset as y, FontFormat as z };

package/dist/plugins.d.mts

@@ -0,0 +1,2 @@
+import { a as modernWeb, c as svgs2ttf, d as ttf2woff, f as ttf2woff2, i as glyph, l as ttf2eot, n as definePlugin, o as otf2ttf, r as deliverySlices, s as svg2ttf, t as css, u as ttf2svg } from "./plugins-BeueRRP6.mjs";
+export { css, definePlugin, deliverySlices, glyph, modernWeb, otf2ttf, svg2ttf, svgs2ttf, ttf2eot, ttf2svg, ttf2woff, ttf2woff2 };

package/dist/plugins.mjs

@@ -0,0 +1,149 @@
+//#region src/plugins.ts
+function definePlugin(plugin) {
+	return plugin;
+}
+function glyph(options = {}) {
+	const preserveHinting = options.preserveHinting ?? options.hinting ?? false;
+	return {
+		name: "fontmin:glyph",
+		native: {
+			kind: "builtin",
+			name: "glyph",
+			options: {
+				text: options.text,
+				textFile: options.textFile,
+				unicodes: options.unicodes,
+				unicodeRanges: options.unicodeRanges,
+				basicText: options.basicText,
+				hinting: options.hinting,
+				trim: options.trim,
+				keepNotdef: options.keepNotdef,
+				keepLayout: options.keepLayout,
+				clone: options.clone,
+				preserveHinting
+			}
+		}
+	};
+}
+function deliverySlices(slices) {
+	return {
+		name: "fontmin:unicode-slices",
+		native: {
+			kind: "builtin",
+			name: "unicodeSlices",
+			options: { slices: slices.map((slice) => ({
+				name: slice.name,
+				unicodeRanges: [...slice.unicodeRanges]
+			})) }
+		}
+	};
+}
+function ttf2woff(options = {}) {
+	return {
+		name: "fontmin:ttf2woff",
+		native: {
+			kind: "builtin",
+			name: "ttf2woff",
+			options: { ...options }
+		}
+	};
+}
+function ttf2woff2(options = {}) {
+	return {
+		name: "fontmin:ttf2woff2",
+		native: {
+			kind: "builtin",
+			name: "ttf2woff2",
+			options: { ...options }
+		}
+	};
+}
+function ttf2eot(options = {}) {
+	return {
+		name: "fontmin:ttf2eot",
+		native: {
+			kind: "builtin",
+			name: "ttf2eot",
+			options: { ...options }
+		}
+	};
+}
+function otf2ttf(options = {}) {
+	return {
+		name: "fontmin:otf2ttf",
+		native: {
+			kind: "builtin",
+			name: "otf2ttf",
+			options: { ...options }
+		}
+	};
+}
+function ttf2svg(options = {}) {
+	return {
+		name: "fontmin:ttf2svg",
+		native: {
+			kind: "builtin",
+			name: "ttf2svg",
+			options: { ...options }
+		}
+	};
+}
+function svg2ttf(options = {}) {
+	return {
+		name: "fontmin:svg2ttf",
+		native: {
+			kind: "builtin",
+			name: "svg2ttf",
+			options: { ...options }
+		}
+	};
+}
+function svgs2ttf(options = {}) {
+	return {
+		name: "fontmin:svgs2ttf",
+		native: {
+			kind: "builtin",
+			name: "svgs2ttf",
+			options: { ...options }
+		}
+	};
+}
+function css(options = {}) {
+	return {
+		name: "fontmin:css",
+		native: {
+			kind: "builtin",
+			name: "css",
+			options: { ...options }
+		}
+	};
+}
+function modernWeb(options = {}) {
+	const cssOptions = {};
+	if (options.fontFamily !== void 0) cssOptions.fontFamily = options.fontFamily;
+	if (options.fontPath !== void 0) cssOptions.fontPath = options.fontPath;
+	if (options.local !== void 0) cssOptions.local = options.local;
+	if (options.fontDisplay !== void 0) cssOptions.fontDisplay = options.fontDisplay;
+	const otfOptions = { clone: false };
+	const woffOptions = {};
+	const woff2Options = {};
+	if (options.preserveHinting !== void 0) otfOptions.preserveHinting = options.preserveHinting;
+	if (options.variationCoordinates !== void 0) otfOptions.variationCoordinates = options.variationCoordinates;
+	if (options.clone !== void 0) {
+		woffOptions.clone = options.clone;
+		woff2Options.clone = options.clone;
+	}
+	if (options.deflate !== void 0) woffOptions.deflate = options.deflate;
+	if (options.compressionLevel !== void 0) woffOptions.compressionLevel = options.compressionLevel;
+	if (options.quality !== void 0) woff2Options.quality = options.quality;
+	if (options.fallback !== void 0) woff2Options.fallback = options.fallback;
+	return [
+		otf2ttf(otfOptions),
+		glyph(options),
+		ttf2woff(woffOptions),
+		ttf2woff2(woff2Options),
+		css(cssOptions)
+	];
+}
+//#endregion
+export { css, definePlugin, deliverySlices, glyph, modernWeb, otf2ttf, svg2ttf, svgs2ttf, ttf2eot, ttf2svg, ttf2woff, ttf2woff2 };

package/dist/presets.d.mts

@@ -0,0 +1,5 @@
+import { S as FontminPlugin, a as modernWeb, b as FontminCompatPresetOptions } from "./plugins-BeueRRP6.mjs";
+//#region src/presets.d.ts
+declare function fontminCompatPreset(options?: FontminCompatPresetOptions): FontminPlugin[];
+//#endregion
+export { fontminCompatPreset, modernWeb };

package/dist/presets.mjs

@@ -0,0 +1,70 @@
+import { css, glyph, modernWeb, otf2ttf, ttf2eot, ttf2svg, ttf2woff, ttf2woff2 } from "./plugins.mjs";
+//#region src/presets.ts
+function fontminCompatPreset(options = {}) {
+	const cssOptions = cssOptionsFromPreset(options);
+	const eotOptions = eotOptionsFromPreset(options);
+	const otfOptions = otfOptionsFromPreset(options);
+	const svgOptions = svgOptionsFromPreset(options);
+	const woffOptions = woffOptionsFromPreset(options);
+	const woff2Options = woff2OptionsFromPreset(options);
+	return [
+		otf2ttf(otfOptions),
+		glyph(options),
+		ttf2eot(eotOptions),
+		ttf2svg(svgOptions),
+		ttf2woff(woffOptions),
+		ttf2woff2(woff2Options),
+		css(cssOptions)
+	];
+}
+function cssOptionsFromPreset(options) {
+	const cssOptions = {};
+	if (options.asFileName !== void 0) cssOptions.asFileName = options.asFileName;
+	if (options.base64 !== void 0) cssOptions.base64 = options.base64;
+	if (options.cssGlyph !== void 0) cssOptions.glyph = options.cssGlyph;
+	else if (options.glyphCss !== void 0) cssOptions.glyph = options.glyphCss;
+	else if (typeof options.glyph === "boolean") cssOptions.glyph = options.glyph;
+	if (options.fontDisplay !== void 0) cssOptions.fontDisplay = options.fontDisplay;
+	if (options.fontFamily !== void 0) cssOptions.fontFamily = options.fontFamily;
+	if (options.fontPath !== void 0) cssOptions.fontPath = options.fontPath;
+	if (options.iconPrefix !== void 0) cssOptions.iconPrefix = options.iconPrefix;
+	if (options.local !== void 0) cssOptions.local = options.local;
+	if (options.target !== void 0) cssOptions.target = options.target;
+	return cssOptions;
+}
+function eotOptionsFromPreset(options) {
+	const eotOptions = {};
+	if (options.clone !== void 0) eotOptions.clone = options.clone;
+	if (options.version !== void 0) eotOptions.version = options.version;
+	return eotOptions;
+}
+function otfOptionsFromPreset(options) {
+	const otfOptions = {};
+	if (options.clone !== void 0) otfOptions.clone = options.clone;
+	if (options.preserveHinting !== void 0) otfOptions.preserveHinting = options.preserveHinting;
+	if (options.variationCoordinates !== void 0) otfOptions.variationCoordinates = options.variationCoordinates;
+	return otfOptions;
+}
+function svgOptionsFromPreset(options) {
+	const svgOptions = {};
+	if (options.clone !== void 0) svgOptions.clone = options.clone;
+	if (options.fontFamily !== void 0) svgOptions.fontFamily = options.fontFamily;
+	return svgOptions;
+}
+function woffOptionsFromPreset(options) {
+	const woffOptions = {};
+	if (options.clone !== void 0) woffOptions.clone = options.clone;
+	if (options.compressionLevel !== void 0) woffOptions.compressionLevel = options.compressionLevel;
+	if (options.deflate !== void 0) woffOptions.deflate = options.deflate;
+	else if (options.deflateWoff !== void 0) woffOptions.deflate = options.deflateWoff;
+	return woffOptions;
+}
+function woff2OptionsFromPreset(options) {
+	const woff2Options = {};
+	if (options.clone !== void 0) woff2Options.clone = options.clone;
+	if (options.fallback !== void 0) woff2Options.fallback = options.fallback;
+	if (options.quality !== void 0) woff2Options.quality = options.quality;
+	return woff2Options;
+}
+//#endregion
+export { fontminCompatPreset, modernWeb };

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "fontmin-rs",
+  "version": "0.1.0-beta.1",
+  "description": "Fast font subsetter and converter written in Rust with Node.js bindings.",
+  "keywords": [
+    "font",
+    "fontmin",
+    "napi",
+    "subset",
+    "ttf"
+  ],
+  "homepage": "https://github.com/fontmin-rs/fontmin-rs#readme",
+  "bugs": {
+    "url": "https://github.com/fontmin-rs/fontmin-rs/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "ntnyq",
+    "email": "ntnyq13@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fontmin-rs/fontmin-rs.git"
+  },
+  "bin": {
+    "fontmin-rs": "./bin/fontmin-rs.mjs"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./plugins": {
+      "types": "./dist/plugins.d.mts",
+      "default": "./dist/plugins.mjs"
+    },
+    "./presets": {
+      "types": "./dist/presets.d.mts",
+      "default": "./dist/presets.mjs"
+    },
+    "./compat": {
+      "types": "./dist/compat.d.mts",
+      "default": "./dist/compat.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "jsonc-parser": "^3.3.1",
+    "tinyglobby": "^0.2.17",
+    "@fontmin-rs/wasm": "0.1.0-beta.1"
+  },
+  "devDependencies": {
+    "@ntnyq/tsconfig": "^3.1.0",
+    "@types/node": "^26.1.1",
+    "fontmin": "^1.1.1",
+    "playwright": "^1.61.1",
+    "tinybench": "^6.0.2",
+    "tsdown": "^0.22.8",
+    "vitest": "^4.1.10"
+  },
+  "optionalDependencies": {
+    "@fontmin-rs/binding": "0.1.0-beta.1"
+  },
+  "scripts": {
+    "bench": "vitest bench --run bench",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
+    "lint": "oxlint",
+    "pretest": "node ../../scripts/ensure-wasm.mjs",
+    "test": "vitest --run",
+    "test:browser": "pnpm run build && node tests/browser-load.mjs",
+    "typecheck": "tsgo --noEmit"
+  }
+}