@fontmin-rs/wasm 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-PRESENT ntnyq <https://github.com/ntnyq>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/fontmin_wasm_core-Cn_EVAE9.mjs

@@ -0,0 +1,458 @@
+//#region src/generated/fontmin_wasm_core.js
+/**
+* @param {any} sources
+* @param {any} options_value
+* @returns {any}
+*/
+function generate_css(sources, options_value) {
+	const ret = wasm.generate_css(sources, options_value);
+	if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+	return takeFromExternrefTable0(ret[0]);
+}
+/**
+* @returns {string}
+*/
+function runtime_name() {
+	let deferred1_0;
+	let deferred1_1;
+	try {
+		const ret = wasm.runtime_name();
+		deferred1_0 = ret[0];
+		deferred1_1 = ret[1];
+		return getStringFromWasm0(ret[0], ret[1]);
+	} finally {
+		wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+	}
+}
+/**
+* @param {string} operation
+* @param {Uint8Array} input
+* @param {any} options
+* @returns {any}
+*/
+function transform(operation, input, options) {
+	const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+	const len0 = WASM_VECTOR_LEN;
+	const ptr1 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+	const len1 = WASM_VECTOR_LEN;
+	const ret = wasm.transform(ptr0, len0, ptr1, len1, options);
+	if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+	return takeFromExternrefTable0(ret[0]);
+}
+/**
+* @param {any} inputs
+* @param {any} options
+* @returns {any}
+*/
+function transform_icons(inputs, options) {
+	const ret = wasm.transform_icons(inputs, options);
+	if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+	return takeFromExternrefTable0(ret[0]);
+}
+/**
+* @param {string} operation
+* @param {string} input
+* @param {any} options
+* @returns {any}
+*/
+function transform_text(operation, input, options) {
+	const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+	const len0 = WASM_VECTOR_LEN;
+	const ptr1 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+	const len1 = WASM_VECTOR_LEN;
+	const ret = wasm.transform_text(ptr0, len0, ptr1, len1, options);
+	if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+	return takeFromExternrefTable0(ret[0]);
+}
+function __wbg_get_imports() {
+	return {
+		__proto__: null,
+		"./fontmin_wasm_core_bg.js": {
+			__proto__: null,
+			__wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
+				return Error(getStringFromWasm0(arg0, arg1));
+			},
+			__wbg_Number_9a4e0ecb0fa16705: function(arg0) {
+				return Number(arg0);
+			},
+			__wbg_String_8564e559799eccda: function(arg0, arg1) {
+				const ptr1 = passStringToWasm0(String(arg1), wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+				const len1 = WASM_VECTOR_LEN;
+				getDataViewMemory0().setInt32(arg0 + 4, len1, true);
+				getDataViewMemory0().setInt32(arg0 + 0, ptr1, true);
+			},
+			__wbg___wbindgen_bigint_get_as_i64_d968e41184ae354f: function(arg0, arg1) {
+				const v = arg1;
+				const ret = typeof v === "bigint" ? v : void 0;
+				getDataViewMemory0().setBigInt64(arg0 + 8, isLikeNone(ret) ? BigInt(0) : ret, true);
+				getDataViewMemory0().setInt32(arg0 + 0, !isLikeNone(ret), true);
+			},
+			__wbg___wbindgen_boolean_get_fa956cfa2d1bd751: function(arg0) {
+				const v = arg0;
+				const ret = typeof v === "boolean" ? v : void 0;
+				return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
+			},
+			__wbg___wbindgen_debug_string_c25d447a39f5578f: function(arg0, arg1) {
+				const ptr1 = passStringToWasm0(debugString(arg1), wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+				const len1 = WASM_VECTOR_LEN;
+				getDataViewMemory0().setInt32(arg0 + 4, len1, true);
+				getDataViewMemory0().setInt32(arg0 + 0, ptr1, true);
+			},
+			__wbg___wbindgen_in_aca499c5de7ff5e5: function(arg0, arg1) {
+				return arg0 in arg1;
+			},
+			__wbg___wbindgen_is_bigint_2f76dc55065b4273: function(arg0) {
+				return typeof arg0 === "bigint";
+			},
+			__wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
+				return typeof arg0 === "function";
+			},
+			__wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
+				const val = arg0;
+				return typeof val === "object" && val !== null;
+			},
+			__wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
+				return typeof arg0 === "string";
+			},
+			__wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
+				return arg0 === void 0;
+			},
+			__wbg___wbindgen_jsval_eq_e659fcf7b0e32763: function(arg0, arg1) {
+				return arg0 === arg1;
+			},
+			__wbg___wbindgen_jsval_loose_eq_db4c3b15f63fc170: function(arg0, arg1) {
+				return arg0 == arg1;
+			},
+			__wbg___wbindgen_number_get_394265ed1e1b84ee: function(arg0, arg1) {
+				const obj = arg1;
+				const ret = typeof obj === "number" ? obj : void 0;
+				getDataViewMemory0().setFloat64(arg0 + 8, isLikeNone(ret) ? 0 : ret, true);
+				getDataViewMemory0().setInt32(arg0 + 0, !isLikeNone(ret), true);
+			},
+			__wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
+				const obj = arg1;
+				const ret = typeof obj === "string" ? obj : void 0;
+				var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+				var len1 = WASM_VECTOR_LEN;
+				getDataViewMemory0().setInt32(arg0 + 4, len1, true);
+				getDataViewMemory0().setInt32(arg0 + 0, ptr1, true);
+			},
+			__wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
+				throw new Error(getStringFromWasm0(arg0, arg1));
+			},
+			__wbg_call_8a2dd23819f8a60a: function() {
+				return handleError(function(arg0, arg1) {
+					return arg0.call(arg1);
+				}, arguments);
+			},
+			__wbg_done_89b2b13e91a60321: function(arg0) {
+				return arg0.done;
+			},
+			__wbg_entries_015dc610cd81ede0: function(arg0) {
+				return Object.entries(arg0);
+			},
+			__wbg_get_507a50627bffa49b: function(arg0, arg1) {
+				return arg0[arg1 >>> 0];
+			},
+			__wbg_get_c7eb1f358a7654df: function() {
+				return handleError(function(arg0, arg1) {
+					return Reflect.get(arg0, arg1);
+				}, arguments);
+			},
+			__wbg_get_unchecked_6e0ad6d2a41b06f6: function(arg0, arg1) {
+				return arg0[arg1 >>> 0];
+			},
+			__wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
+				return arg0[arg1];
+			},
+			__wbg_instanceof_ArrayBuffer_4480b9e0068a8adb: function(arg0) {
+				let result;
+				try {
+					result = arg0 instanceof ArrayBuffer;
+				} catch (_) {
+					result = false;
+				}
+				return result;
+			},
+			__wbg_instanceof_Map_e5b5e3db98422fcc: function(arg0) {
+				let result;
+				try {
+					result = arg0 instanceof Map;
+				} catch (_) {
+					result = false;
+				}
+				return result;
+			},
+			__wbg_instanceof_Uint8Array_309b927aaf7a3fc7: function(arg0) {
+				let result;
+				try {
+					result = arg0 instanceof Uint8Array;
+				} catch (_) {
+					result = false;
+				}
+				return result;
+			},
+			__wbg_isArray_0677c962b281d01a: function(arg0) {
+				return Array.isArray(arg0);
+			},
+			__wbg_isSafeInteger_04f36e4056f1b851: function(arg0) {
+				return Number.isSafeInteger(arg0);
+			},
+			__wbg_iterator_6f722e4a93058b71: function() {
+				return Symbol.iterator;
+			},
+			__wbg_length_1f0964f4a5e2c6d8: function(arg0) {
+				return arg0.length;
+			},
+			__wbg_length_370319915dc99107: function(arg0) {
+				return arg0.length;
+			},
+			__wbg_new_32b398fb48b6d94a: function() {
+				return new Array();
+			},
+			__wbg_new_7796ffc7ed656783: function() {
+				return /* @__PURE__ */ new Map();
+			},
+			__wbg_new_cd45aabdf6073e84: function(arg0) {
+				return new Uint8Array(arg0);
+			},
+			__wbg_new_da52cf8fe3429cb2: function() {
+				return /* @__PURE__ */ new Object();
+			},
+			__wbg_next_6dbf2c0ac8cde20f: function(arg0) {
+				return arg0.next;
+			},
+			__wbg_next_71f2aa1cb3d1e37e: function() {
+				return handleError(function(arg0) {
+					return arg0.next();
+				}, arguments);
+			},
+			__wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
+				Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+			},
+			__wbg_set_575dd786d51585f8: function(arg0, arg1, arg2) {
+				return arg0.set(arg1, arg2);
+			},
+			__wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+				arg0[arg1] = arg2;
+			},
+			__wbg_set_8a16b38e4805b298: function(arg0, arg1, arg2) {
+				arg0[arg1 >>> 0] = arg2;
+			},
+			__wbg_value_a5d5488a9589444a: function(arg0) {
+				return arg0.value;
+			},
+			__wbindgen_cast_0000000000000001: function(arg0) {
+				return arg0;
+			},
+			__wbindgen_cast_0000000000000002: function(arg0) {
+				return arg0;
+			},
+			__wbindgen_cast_0000000000000003: function(arg0, arg1) {
+				return getStringFromWasm0(arg0, arg1);
+			},
+			__wbindgen_cast_0000000000000004: function(arg0) {
+				return BigInt.asUintN(64, arg0);
+			},
+			__wbindgen_init_externref_table: function() {
+				const table = wasm.__wbindgen_externrefs;
+				const offset = table.grow(4);
+				table.set(0, void 0);
+				table.set(offset + 0, void 0);
+				table.set(offset + 1, null);
+				table.set(offset + 2, true);
+				table.set(offset + 3, false);
+			}
+		}
+	};
+}
+function addToExternrefTable0(obj) {
+	const idx = wasm.__externref_table_alloc();
+	wasm.__wbindgen_externrefs.set(idx, obj);
+	return idx;
+}
+function debugString(val) {
+	const type = typeof val;
+	if (type == "number" || type == "boolean" || val == null) return `${val}`;
+	if (type == "string") return `"${val}"`;
+	if (type == "symbol") {
+		const description = val.description;
+		if (description == null) return "Symbol";
+		else return `Symbol(${description})`;
+	}
+	if (type == "function") {
+		const name = val.name;
+		if (typeof name == "string" && name.length > 0) return `Function(${name})`;
+		else return "Function";
+	}
+	if (Array.isArray(val)) {
+		const length = val.length;
+		let debug = "[";
+		if (length > 0) debug += debugString(val[0]);
+		for (let i = 1; i < length; i++) debug += ", " + debugString(val[i]);
+		debug += "]";
+		return debug;
+	}
+	const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+	let className;
+	if (builtInMatches && builtInMatches.length > 1) className = builtInMatches[1];
+	else return toString.call(val);
+	if (className == "Object") try {
+		return "Object(" + JSON.stringify(val) + ")";
+	} catch (_) {
+		return "Object";
+	}
+	if (val instanceof Error) return `${val.name}: ${val.message}\n${val.stack}`;
+	return className;
+}
+function getArrayU8FromWasm0(ptr, len) {
+	ptr = ptr >>> 0;
+	return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+	if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+	return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+	return decodeText(ptr >>> 0, len);
+}
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+	if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+	return cachedUint8ArrayMemory0;
+}
+function handleError(f, args) {
+	try {
+		return f.apply(this, args);
+	} catch (e) {
+		const idx = addToExternrefTable0(e);
+		wasm.__wbindgen_exn_store(idx);
+	}
+}
+function isLikeNone(x) {
+	return x === void 0 || x === null;
+}
+function passArray8ToWasm0(arg, malloc) {
+	const ptr = malloc(arg.length * 1, 1) >>> 0;
+	getUint8ArrayMemory0().set(arg, ptr / 1);
+	WASM_VECTOR_LEN = arg.length;
+	return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+	if (realloc === void 0) {
+		const buf = cachedTextEncoder.encode(arg);
+		const ptr = malloc(buf.length, 1) >>> 0;
+		getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+		WASM_VECTOR_LEN = buf.length;
+		return ptr;
+	}
+	let len = arg.length;
+	let ptr = malloc(len, 1) >>> 0;
+	const mem = getUint8ArrayMemory0();
+	let offset = 0;
+	for (; offset < len; offset++) {
+		const code = arg.charCodeAt(offset);
+		if (code > 127) break;
+		mem[ptr + offset] = code;
+	}
+	if (offset !== len) {
+		if (offset !== 0) arg = arg.slice(offset);
+		ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+		const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+		const ret = cachedTextEncoder.encodeInto(arg, view);
+		offset += ret.written;
+		ptr = realloc(ptr, len, offset, 1) >>> 0;
+	}
+	WASM_VECTOR_LEN = offset;
+	return ptr;
+}
+function takeFromExternrefTable0(idx) {
+	const value = wasm.__wbindgen_externrefs.get(idx);
+	wasm.__externref_table_dealloc(idx);
+	return value;
+}
+let cachedTextDecoder = new TextDecoder("utf-8", {
+	ignoreBOM: true,
+	fatal: true
+});
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+	numBytesDecoded += len;
+	if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+		cachedTextDecoder = new TextDecoder("utf-8", {
+			ignoreBOM: true,
+			fatal: true
+		});
+		cachedTextDecoder.decode();
+		numBytesDecoded = len;
+	}
+	return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+const cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) cachedTextEncoder.encodeInto = function(arg, view) {
+	const buf = cachedTextEncoder.encode(arg);
+	view.set(buf);
+	return {
+		read: arg.length,
+		written: buf.length
+	};
+};
+let WASM_VECTOR_LEN = 0;
+let wasm;
+function __wbg_finalize_init(instance, module) {
+	wasm = instance.exports;
+	cachedDataViewMemory0 = null;
+	cachedUint8ArrayMemory0 = null;
+	wasm.__wbindgen_start();
+	return wasm;
+}
+async function __wbg_load(module, imports) {
+	if (typeof Response === "function" && module instanceof Response) {
+		if (typeof WebAssembly.instantiateStreaming === "function") try {
+			return await WebAssembly.instantiateStreaming(module, imports);
+		} catch (e) {
+			if (module.ok && expectedResponseType(module.type) && module.headers.get("Content-Type") !== "application/wasm") console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+			else throw e;
+		}
+		const bytes = await module.arrayBuffer();
+		return await WebAssembly.instantiate(bytes, imports);
+	} else {
+		const instance = await WebAssembly.instantiate(module, imports);
+		if (instance instanceof WebAssembly.Instance) return {
+			instance,
+			module
+		};
+		else return instance;
+	}
+	function expectedResponseType(type) {
+		switch (type) {
+			case "basic":
+			case "cors":
+			case "default": return true;
+		}
+		return false;
+	}
+}
+function initSync(module) {
+	if (wasm !== void 0) return wasm;
+	if (module !== void 0) if (Object.getPrototypeOf(module) === Object.prototype) ({module} = module);
+	else console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+	const imports = __wbg_get_imports();
+	if (!(module instanceof WebAssembly.Module)) module = new WebAssembly.Module(module);
+	return __wbg_finalize_init(new WebAssembly.Instance(module, imports), module);
+}
+async function __wbg_init(module_or_path) {
+	if (wasm !== void 0) return wasm;
+	if (module_or_path !== void 0) if (Object.getPrototypeOf(module_or_path) === Object.prototype) ({module_or_path} = module_or_path);
+	else console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+	if (module_or_path === void 0) module_or_path = new URL("fontmin_wasm_core_bg.wasm", import.meta.url);
+	const imports = __wbg_get_imports();
+	if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) module_or_path = fetch(module_or_path);
+	const { instance, module } = await __wbg_load(await module_or_path, imports);
+	return __wbg_finalize_init(instance, module);
+}
+//#endregion
+export { __wbg_init as default, generate_css, initSync, runtime_name, transform, transform_icons, transform_text };

package/dist/index.d.mts

@@ -0,0 +1,196 @@
+//#region src/generated/fontmin_wasm_core.d.ts
+type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+//#endregion
+//#region src/runtime.d.ts
+declare function isWasmInitialized(): boolean;
+declare function initWasm(input?: InitInput): Promise<void>;
+//#endregion
+//#region 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 {
+  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 {
+  quality?: number;
+}
+interface Ttf2EotOptions {
+  version?: number;
+}
+interface Ttf2SvgOptions {
+  fontFamily?: string;
+}
+interface Otf2TtfOptions {
+  preserveHinting?: boolean;
+  variationCoordinates?: Record<string, number>;
+}
+interface Svg2TtfOptions {
+  hinting?: boolean;
+  normalize?: boolean;
+}
+interface SvgIcon {
+  contents: string;
+  name: string;
+  unicode?: number;
+}
+interface Svgs2TtfOptions {
+  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 {
+  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/native.d.ts
+declare function subsetTtf(input: Uint8Array, options?: SubsetOptions): Promise<Uint8Array>;
+declare function ttfToWoff(input: Uint8Array, options?: WoffOptions): Promise<Uint8Array>;
+declare function woffToTtf(input: Uint8Array): Promise<Uint8Array>;
+declare function ttfToWoff2(input: Uint8Array, options?: Ttf2Woff2Options): Promise<Uint8Array>;
+declare function woff2ToTtf(input: Uint8Array): Promise<Uint8Array>;
+declare function validateWoff2(input: Uint8Array): Promise<void>;
+declare function ttfToEot(input: Uint8Array, options?: Ttf2EotOptions): Promise<Uint8Array>;
+declare function eotToTtf(input: Uint8Array): Promise<Uint8Array>;
+declare function ttfToSvg(input: Uint8Array, options?: Ttf2SvgOptions): Promise<string>;
+declare function svgFontToTtf(input: string, options?: Svg2TtfOptions): Promise<Uint8Array>;
+declare function svgsToTtf(inputs: SvgIcon[], options?: Svgs2TtfOptions): Promise<Uint8Array>;
+declare function otfToTtf(input: Uint8Array, options?: Otf2TtfOptions): Promise<Uint8Array>;
+declare function inspect(input: Uint8Array): Promise<FontInfo>;
+declare function generateFontFaceCss(sources: CssFontSource[], options?: CssOptions): Promise<string>;
+//#endregion
+//#region src/plugins.d.ts
+type MaybePromise<T> = T | Promise<T>;
+interface DeliverySlice {
+  name: string;
+  unicodeRanges: string[];
+}
+interface DeliverySlicesOptions {
+  slices: DeliverySlice[];
+}
+interface GlyphOptions extends SubsetOptions {
+  clone?: boolean;
+}
+interface Ttf2WoffPluginOptions extends WoffOptions {
+  clone?: boolean;
+}
+interface Ttf2Woff2PluginOptions extends Ttf2Woff2Options {
+  clone?: boolean;
+}
+interface Ttf2EotPluginOptions extends Ttf2EotOptions {
+  clone?: boolean;
+}
+interface Ttf2SvgPluginOptions extends Ttf2SvgOptions {
+  clone?: boolean;
+}
+interface Otf2TtfPluginOptions extends Otf2TtfOptions {
+  clone?: boolean;
+}
+interface Svg2TtfPluginOptions extends Svg2TtfOptions {
+  clone?: boolean;
+}
+interface Svgs2TtfPluginOptions extends Svgs2TtfOptions {
+  clone?: boolean;
+}
+interface ModernWebOptions extends GlyphOptions, Otf2TtfPluginOptions, Ttf2WoffPluginOptions, Ttf2Woff2PluginOptions {
+  fontDisplay?: CssOptions['fontDisplay'];
+  fontFamily?: string;
+  fontPath?: string;
+  local?: boolean;
+}
+interface FontminCompatPresetOptions extends GlyphOptions, Otf2TtfPluginOptions, Ttf2EotPluginOptions, Ttf2SvgPluginOptions, Ttf2WoffPluginOptions, Ttf2Woff2PluginOptions {
+  fontDisplay?: CssOptions['fontDisplay'];
+  fontPath?: string;
+  local?: boolean;
+}
+interface BrowserPluginContext {
+  diagnostics: {
+    level: 'warn';
+    message: string;
+  }[];
+  emitFile(asset: BrowserAsset): void;
+  warn(message: string | Error): void;
+}
+interface BrowserPlugin<Options extends object = object> {
+  name: string;
+  options?: Options;
+  transform?(asset: BrowserAsset, context: BrowserPluginContext): MaybePromise<BrowserAsset | BrowserAsset[] | null | undefined>;
+}
+declare function glyph(options?: GlyphOptions): BrowserPlugin<GlyphOptions>;
+declare function deliverySlices(slices: DeliverySlice[]): BrowserPlugin<DeliverySlicesOptions>;
+declare function ttf2woff(options?: Ttf2WoffPluginOptions): BrowserPlugin<Ttf2WoffPluginOptions>;
+declare function ttf2woff2(options?: Ttf2Woff2PluginOptions): BrowserPlugin<Ttf2Woff2PluginOptions>;
+declare function ttf2eot(options?: Ttf2EotPluginOptions): BrowserPlugin<Ttf2EotPluginOptions>;
+declare function ttf2svg(options?: Ttf2SvgPluginOptions): BrowserPlugin<Ttf2SvgPluginOptions>;
+declare function otf2ttf(options?: Otf2TtfPluginOptions): BrowserPlugin<Otf2TtfPluginOptions>;
+declare function svg2ttf(options?: Svg2TtfPluginOptions): BrowserPlugin<Svg2TtfPluginOptions>;
+declare function svgs2ttf(options?: Svgs2TtfPluginOptions): BrowserPlugin<Svgs2TtfPluginOptions>;
+declare function css(options?: CssOptions): BrowserPlugin<CssOptions>;
+declare function modernWeb(options?: ModernWebOptions): BrowserPlugin[];
+declare function fontminCompatPreset(options?: FontminCompatPresetOptions): BrowserPlugin[];
+//#endregion
+//#region src/optimize.d.ts
+interface BrowserAsset {
+  contents: Uint8Array;
+  fileName: string;
+  format?: string;
+  unicodeRanges?: string[];
+}
+interface BrowserOptimizeConfig {
+  assets: BrowserAsset[];
+  plugins?: BrowserPlugin[];
+}
+declare function optimizeBrowser(config: BrowserOptimizeConfig): Promise<BrowserAsset[]>;
+//#endregion
+export { type BrowserAsset, type BrowserOptimizeConfig, type BrowserPlugin, type BrowserPluginContext, type CssFontSource, type CssGlyph, type CssOptions, type DeliverySlice, type DeliverySlicesOptions, type FontFormat, type FontInfo, type FontMetadata, type FontminCompatPresetOptions, type GlyphOptions, type LayoutSubsetMode, type MaybePromise, type ModernWebOptions, type Otf2TtfOptions, type Otf2TtfPluginOptions, type OutputFormat, type SubsetOptions, type Svg2TtfOptions, type Svg2TtfPluginOptions, type SvgIcon, type Svgs2TtfOptions, type Svgs2TtfPluginOptions, type Ttf2EotOptions, type Ttf2EotPluginOptions, type Ttf2SvgOptions, type Ttf2SvgPluginOptions, type Ttf2Woff2Options, type Ttf2Woff2PluginOptions, type Ttf2WoffPluginOptions, type WoffOptions, css, deliverySlices, eotToTtf, fontminCompatPreset, generateFontFaceCss, glyph, initWasm, inspect, isWasmInitialized, modernWeb, optimizeBrowser, otf2ttf, otfToTtf, subsetTtf, svg2ttf, svgFontToTtf, svgs2ttf, svgsToTtf, ttf2eot, ttf2svg, ttf2woff, ttf2woff2, ttfToEot, ttfToSvg, ttfToWoff, ttfToWoff2, validateWoff2, woff2ToTtf, woffToTtf };

package/dist/index.mjs

@@ -0,0 +1,333 @@
+//#region src/runtime.ts
+let initialization;
+let initialized = false;
+function isWasmInitialized() {
+	return initialized;
+}
+function assertWasmInitialized() {
+	if (!initialized) throw new Error("fontmin-rs WASM runtime is not initialized; call initWasm() first");
+}
+async function getWasmModule() {
+	assertWasmInitialized();
+	return initialization;
+}
+async function initWasm(input) {
+	initialization ??= import("./fontmin_wasm_core-Cn_EVAE9.mjs").then(async (module) => {
+		await module.default(input === void 0 ? void 0 : { module_or_path: input });
+		if (module.runtime_name() !== "fontmin-rs") throw new Error("fontmin-rs WASM runtime did not initialize correctly");
+		initialized = true;
+		return module;
+	});
+	await initialization;
+}
+//#endregion
+//#region src/native.ts
+function bytes(value) {
+	return new Uint8Array(value);
+}
+async function binary(operation, input, options = {}) {
+	return bytes((await getWasmModule()).transform(operation, input, options));
+}
+async function subsetTtf(input, options = {}) {
+	return binary("subsetTtf", input, options);
+}
+async function ttfToWoff(input, options = {}) {
+	return binary("ttfToWoff", input, options);
+}
+async function woffToTtf(input) {
+	return binary("woffToTtf", input);
+}
+async function ttfToWoff2(input, options = {}) {
+	return binary("ttfToWoff2", input, options);
+}
+async function woff2ToTtf(input) {
+	return binary("woff2ToTtf", input);
+}
+async function validateWoff2(input) {
+	(await getWasmModule()).transform("validateWoff2", input, {});
+}
+async function ttfToEot(input, options = {}) {
+	return binary("ttfToEot", input, options);
+}
+async function eotToTtf(input) {
+	return binary("eotToTtf", input);
+}
+async function ttfToSvg(input, options = {}) {
+	return (await getWasmModule()).transform("ttfToSvg", input, options);
+}
+async function svgFontToTtf(input, options = {}) {
+	return bytes((await getWasmModule()).transform_text("svgFontToTtf", input, options));
+}
+async function svgsToTtf(inputs, options = {}) {
+	return bytes((await getWasmModule()).transform_icons(inputs, options));
+}
+async function otfToTtf(input, options = {}) {
+	return binary("otfToTtf", input, options);
+}
+async function inspect(input) {
+	return (await getWasmModule()).transform("inspect", input, {});
+}
+async function generateFontFaceCss(sources, options = {}) {
+	return (await getWasmModule()).generate_css(sources, options);
+}
+//#endregion
+//#region src/plugins.ts
+function plugin(name, options) {
+	return {
+		name,
+		options
+	};
+}
+function glyph(options = {}) {
+	return plugin("glyph", {
+		basicText: false,
+		keepNotdef: true,
+		layout: "conservative",
+		preserveHinting: false,
+		trim: true,
+		unicodes: [],
+		...options
+	});
+}
+function deliverySlices(slices) {
+	return plugin("unicodeSlices", { slices: slices.map((slice) => ({
+		name: slice.name,
+		unicodeRanges: [...slice.unicodeRanges]
+	})) });
+}
+function normalizeDeliverySlices(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 ttf2woff(options = {}) {
+	return plugin("ttf2woff", options);
+}
+function ttf2woff2(options = {}) {
+	return plugin("ttf2woff2", options);
+}
+function ttf2eot(options = {}) {
+	return plugin("ttf2eot", options);
+}
+function ttf2svg(options = {}) {
+	return plugin("ttf2svg", options);
+}
+function otf2ttf(options = {}) {
+	return plugin("otf2ttf", options);
+}
+function svg2ttf(options = {}) {
+	return plugin("svg2ttf", options);
+}
+function svgs2ttf(options = {}) {
+	return plugin("svgs2ttf", options);
+}
+function css(options = {}) {
+	return plugin("css", {
+		asFileName: false,
+		base64: false,
+		fontDisplay: "swap",
+		fontFamily: "fontmin",
+		fontPath: "./",
+		glyph: false,
+		iconPrefix: "icon",
+		local: true,
+		target: "css",
+		...options
+	});
+}
+function modernWeb(options = {}) {
+	const { fontFamily, fontPath, local, fontDisplay, ...subset } = options;
+	const cssOptions = {};
+	if (fontFamily !== void 0) cssOptions.fontFamily = fontFamily;
+	if (fontPath !== void 0) cssOptions.fontPath = fontPath;
+	if (local !== void 0) cssOptions.local = local;
+	if (fontDisplay !== void 0) cssOptions.fontDisplay = fontDisplay;
+	const otfOptions = { clone: false };
+	if (typeof options.preserveHinting === "boolean") otfOptions.preserveHinting = options.preserveHinting;
+	if (options.variationCoordinates !== void 0) otfOptions.variationCoordinates = options.variationCoordinates;
+	return [
+		otf2ttf(otfOptions),
+		glyph(subset),
+		ttf2woff(options),
+		ttf2woff2(options),
+		css(cssOptions)
+	];
+}
+function fontminCompatPreset(options = {}) {
+	const { fontFamily, fontPath, local, fontDisplay, ...subset } = options;
+	const cssOptions = {};
+	if (fontFamily !== void 0) cssOptions.fontFamily = fontFamily;
+	if (fontPath !== void 0) cssOptions.fontPath = fontPath;
+	if (local !== void 0) cssOptions.local = local;
+	if (fontDisplay !== void 0) cssOptions.fontDisplay = fontDisplay;
+	return [
+		otf2ttf(options),
+		glyph(subset),
+		ttf2eot(options),
+		ttf2svg(options),
+		ttf2woff(options),
+		ttf2woff2(options),
+		css(cssOptions)
+	];
+}
+//#endregion
+//#region src/optimize.ts
+async function optimizeBrowser(config) {
+	let assets = config.assets.map(formatAsset);
+	for (const plugin of config.plugins ?? []) {
+		if (plugin.name === "glyph") {
+			assets = await Promise.all(assets.map(async (asset) => asset.format === "ttf" ? {
+				...asset,
+				contents: await subsetTtf(asset.contents, optionsOf(plugin))
+			} : asset));
+			continue;
+		}
+		if (plugin.name === "unicodeSlices") {
+			const slices = normalizeDeliverySlices(optionsOf(plugin));
+			const slicedAssets = [];
+			for (const asset of assets) {
+				if (asset.format !== "ttf") {
+					slicedAssets.push(asset);
+					continue;
+				}
+				for (const slice of slices) slicedAssets.push({
+					...asset,
+					contents: await subsetTtf(asset.contents, { unicodeRanges: slice.unicodeRanges }),
+					fileName: appendFileNameSuffix(asset.fileName, slice.name),
+					unicodeRanges: slice.unicodeRanges
+				});
+			}
+			assets = slicedAssets;
+			continue;
+		}
+		if (plugin.name === "css") {
+			const css = await generateFontFaceCss(assets.filter((asset) => [
+				"eot",
+				"svg",
+				"ttf",
+				"woff",
+				"woff2"
+			].includes(asset.format ?? "")).map((asset) => {
+				const source = {
+					contents: asset.contents,
+					fileName: asset.fileName,
+					format: asset.format
+				};
+				return asset.unicodeRanges === void 0 ? source : {
+					...source,
+					unicodeRanges: asset.unicodeRanges
+				};
+			}), optionsOf(plugin));
+			const firstFont = assets.find((asset) => asset.format === "ttf");
+			if (firstFont !== void 0) assets.push({
+				contents: new TextEncoder().encode(css),
+				fileName: replaceExtension(firstFont.fileName, "css"),
+				format: "css"
+			});
+			continue;
+		}
+		if (plugin.name === "svgs2ttf") {
+			const icons = assets.filter((asset) => asset.format === "svg").map((asset) => ({
+				contents: new TextDecoder().decode(asset.contents),
+				name: asset.fileName.replace(/\.[^.]+$/u, "")
+			}));
+			if (icons.length > 0) {
+				const options = optionsOf(plugin);
+				const fontName = options.fontName ?? "iconfont";
+				assets.push({
+					contents: await svgsToTtf(icons, options),
+					fileName: `${toKebabCase(fontName)}.ttf`,
+					format: "ttf"
+				});
+			}
+			continue;
+		}
+		if (plugin.transform !== void 0) {
+			const emitted = [];
+			const context = {
+				diagnostics: [],
+				emitFile(asset) {
+					emitted.push(formatAsset(asset));
+				},
+				warn(message) {
+					context.diagnostics.push({
+						level: "warn",
+						message: message instanceof Error ? message.message : message
+					});
+				}
+			};
+			const transformed = [];
+			for (const asset of assets) {
+				const result = await plugin.transform(asset, context);
+				if (result === null) continue;
+				if (result === void 0) transformed.push(asset);
+				else transformed.push(...(Array.isArray(result) ? result : [result]).map(formatAsset));
+			}
+			assets = transformed.concat(emitted);
+			continue;
+		}
+		if (plugin.name === "otf2ttf" && optionsOf(plugin).clone === false) {
+			assets = await Promise.all(assets.map(async (asset) => await convert(asset, plugin) ?? asset));
+			continue;
+		}
+		const additions = [];
+		for (const asset of assets) {
+			const converted = await convert(asset, plugin);
+			if (converted !== void 0) additions.push(converted);
+		}
+		assets = assets.concat(additions);
+	}
+	return assets;
+}
+async function convert(asset, plugin) {
+	if (plugin.name === "ttf2woff" && asset.format === "ttf") return converted(asset, "woff", await ttfToWoff(asset.contents, optionsOf(plugin)));
+	if (plugin.name === "ttf2woff2" && asset.format === "ttf") return converted(asset, "woff2", await ttfToWoff2(asset.contents, optionsOf(plugin)));
+	if (plugin.name === "ttf2eot" && asset.format === "ttf") return converted(asset, "eot", await ttfToEot(asset.contents, optionsOf(plugin)));
+	if (plugin.name === "ttf2svg" && asset.format === "ttf") return converted(asset, "svg", new TextEncoder().encode(await ttfToSvg(asset.contents, optionsOf(plugin))));
+	if (plugin.name === "otf2ttf" && asset.format === "otf") return converted(asset, "ttf", await otfToTtf(asset.contents, optionsOf(plugin)));
+	if (plugin.name === "svg2ttf" && asset.format === "svg") return converted(asset, "ttf", await svgFontToTtf(new TextDecoder().decode(asset.contents), optionsOf(plugin)));
+}
+function optionsOf(plugin) {
+	return plugin.options ?? {};
+}
+function converted(asset, format, contents) {
+	return {
+		...asset,
+		contents,
+		fileName: replaceExtension(asset.fileName, format),
+		format
+	};
+}
+function formatAsset(asset) {
+	return {
+		...asset,
+		format: formatOf(asset.fileName)
+	};
+}
+function formatOf(fileName) {
+	return fileName.split(".").pop()?.toLowerCase() ?? "unknown";
+}
+function replaceExtension(fileName, extension) {
+	return `${fileName.replace(/\.[^.]+$/u, "")}.${extension}`;
+}
+function appendFileNameSuffix(fileName, suffix) {
+	const extension = fileName.match(/(\.[^.]+)$/u)?.[1] ?? "";
+	return `${extension === "" ? fileName : fileName.slice(0, -extension.length)}-${suffix}${extension}`;
+}
+function toKebabCase(value) {
+	return value.trim().replaceAll(/([a-z])([A-Z])/gu, "$1-$2").replaceAll(/\s+/gu, "-").toLowerCase();
+}
+//#endregion
+export { css, deliverySlices, eotToTtf, fontminCompatPreset, generateFontFaceCss, glyph, initWasm, inspect, isWasmInitialized, modernWeb, optimizeBrowser, otf2ttf, otfToTtf, subsetTtf, svg2ttf, svgFontToTtf, svgs2ttf, svgsToTtf, ttf2eot, ttf2svg, ttf2woff, ttf2woff2, ttfToEot, ttfToSvg, ttfToWoff, ttfToWoff2, validateWoff2, woff2ToTtf, woffToTtf };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@fontmin-rs/wasm",
+  "version": "0.1.0-beta.1",
+  "description": "Browser WASM runtime for fontmin-rs.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fontmin-rs/fontmin-rs.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@ntnyq/tsconfig": "^3.1.0",
+    "playwright": "^1.61.1",
+    "tsdown": "^0.22.8",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "build": "pnpm run build:wasm && pnpm run build:js",
+    "build:js": "tsdown && node scripts/copy-wasm.mjs",
+    "build:wasm": "wasm-pack build ../fontmin-core --target web --out-dir ../fontmin/src/generated --out-name fontmin_wasm_core",
+    "test": "vitest --run",
+    "test:browser": "pnpm run build && node tests/browser-runtime.mjs",
+    "typecheck": "tsgo --noEmit"
+  }
+}