@fontmin-rs/wasm 1.0.2-rc.1 → 1.1.0

package/dist/index.d.mts

@@ -50,17 +50,129 @@ interface FontInfo {
   metadata: FontMetadata;
   size: number;
 }
+interface FontCollectionFaceInfo extends FontInfo {
+  capabilities: FontCapabilityReport;
+  /** Zero-based face index used by extractCollectionFace. */
+  index: number;
+  /** Absolute SFNT directory offset in the collection. */
+  offset: number;
+}
+type CapabilitySupport = 'subset' | 'passthrough' | 'unsupported';
+type ColorFontTechnology = 'colr-cpal' | 'cbdt-cblc' | 'sbix' | 'svg';
+interface ColorFontTechnologyCapability {
+  detail: string;
+  subsetSupport: CapabilitySupport;
+  tables: string[];
+  technology: ColorFontTechnology;
+  version?: number;
+}
+interface ColorFontCapabilityReport {
+  isColorFont: boolean;
+  subsetSupport?: CapabilitySupport;
+  technologies: ColorFontTechnologyCapability[];
+}
+interface FontCapabilityReport {
+  color: ColorFontCapabilityReport;
+  format: FontFormat;
+}
+interface FontCollectionInfo {
+  faces: FontCollectionFaceInfo[];
+  majorVersion: number;
+  minorVersion: number;
+  size: number;
+}
 interface SubsetOptions extends CoverageOptions {
+  /** Original glyph IDs to retain in addition to Unicode selection. */
+  gids?: number[];
+  /** PostScript glyph names to retain in addition to other selectors. */
+  glyphNames?: string[];
   /** Retain the original glyph-zero outline; false emits the required empty glyph-zero slot. */
   keepNotdef?: boolean;
+  /** Preserve original glyph IDs and leave null entries for empty mapping slots. */
+  retainGids?: boolean;
+  /** Retain PostScript glyph names in a rewritten version 2 `post` table. */
+  retainGlyphNames?: boolean;
+  /** Retain non-Unicode, non-symbol cmap records after remapping. */
+  retainLegacyCmap?: boolean;
+  /** Retain the Windows symbol cmap record after remapping. */
+  retainSymbolCmap?: boolean;
   /** Drop layout, remap supported data, or reject known contextual loss. */
   layout?: LayoutSubsetMode;
+  /** Four-byte OpenType feature tags to retain, or all features when omitted. */
+  layoutFeatures?: string[];
+  /** Four-byte OpenType script tags to retain, or all scripts when omitted. */
+  layoutScripts?: string[];
+  /** OpenType language tags to retain; `default` selects DefaultLangSys. */
+  layoutLanguages?: string[];
+  /** OpenType name IDs to retain, or all name IDs when omitted. */
+  nameIds?: number[];
+  /** Platform-specific name language IDs to retain, or all languages when omitted. */
+  nameLanguages?: number[];
+  /** Optional OpenType tables to remove after subsetting. */
+  dropTables?: string[];
+  /** Optional source tables to copy verbatim into the subset. */
+  passThroughTables?: string[];
   missingGlyphs?: MissingGlyphPolicy;
   /** Retain the cvt, fpgm, and prep TrueType program tables while trimming. */
   preserveHinting?: boolean;
   /** Skip subsetting and return the validated source bytes unchanged when false. */
   trim?: boolean;
 }
+interface GidMapping {
+  newGid: number;
+  oldGid: number;
+}
+interface UnicodeGidMapping {
+  oldGid: number;
+  unicode: number;
+}
+interface GlyphNameGidMapping {
+  glyphName: string;
+  oldGid: number;
+}
+interface SubsetReport {
+  cffCharstringsVerbatim: boolean;
+  droppedContextSubtables: number;
+  glyphsRetained: number;
+  glyphNameToOldGid: GlyphNameGidMapping[];
+  missingGids: number[];
+  missingGlyphNames: string[];
+  newToOld: (number | null)[];
+  oldToNew: GidMapping[];
+  originalSize: number;
+  requestedGids: number[];
+  requestedGlyphNames: string[];
+  subsetSize: number;
+  supportedGids: number[];
+  supportedGlyphNames: string[];
+  tablesRetained: string[];
+  unicodeToOldGid: UnicodeGidMapping[];
+}
+interface SubsetResult {
+  data: Uint8Array;
+  report: SubsetReport;
+}
+/** Resolved selectors bound to one source font by SHA-256. */
+interface SubsetPlan {
+  coverage: CoverageReport;
+  glyphNameToOldGid: GlyphNameGidMapping[];
+  missingGids: number[];
+  missingGlyphNames: string[];
+  options: SubsetOptions;
+  /** SHA-256 integrity digest of the canonical plan payload. */
+  planSha256: string;
+  requestedGids: number[];
+  requestedGlyphNames: string[];
+  schemaVersion: number;
+  /** Original glyph IDs used to seed glyph and layout closure. */
+  seedGids: number[];
+  sourceGlyphs: number;
+  sourceSha256: string;
+  sourceSize: number;
+  supportedGids: number[];
+  supportedGlyphNames: string[];
+  unicodeToOldGid: UnicodeGidMapping[];
+}
 interface WoffOptions {
   compressionLevel?: number;
   deflate?: boolean;
@@ -81,6 +193,25 @@ interface Otf2TtfOptions {
   preserveHinting?: boolean;
   variationCoordinates?: Record<string, number>;
 }
+interface InstanceOptions {
+  /** Axis values in fvar user units. Unspecified axes use their defaults. */
+  variationCoordinates?: Record<string, number>;
+}
+interface AxisRange {
+  /** Inclusive lower bound in fvar user units. */
+  min: number;
+  /** Inclusive upper bound in fvar user units. */
+  max: number;
+  /** New default, or the original default clamped into the range when omitted. */
+  default?: number;
+}
+type AxisSetting = number | AxisRange;
+interface VariationSpaceOptions {
+  /** Axis tags mapped to a pin or retained range. Unlisted axes stay variable. */
+  axes: Record<string, AxisSetting>;
+  /** Convert fully pinned CFF2 outlines to CFF1 for older renderers. */
+  downgradeCff2?: boolean;
+}
 interface Svg2TtfOptions {
   /** Compatibility option accepted without generating TrueType hint instructions. */
   hinting?: boolean;
@@ -124,7 +255,12 @@ interface CssOptions {
 //#endregion
 //#region src/native.d.ts
 declare function subsetTtf(input: Uint8Array, options?: SubsetOptions): Promise<Uint8Array>;
+declare function subsetTtfWithReport(input: Uint8Array, options?: SubsetOptions): Promise<SubsetResult>;
+declare function createTtfSubsetPlan(input: Uint8Array, options?: SubsetOptions): Promise<SubsetPlan>;
+declare function subsetTtfWithPlan(input: Uint8Array, plan: SubsetPlan): Promise<SubsetResult>;
 declare function analyzeCoverage(input: Uint8Array, options?: CoverageOptions): Promise<CoverageReport>;
+declare function instantiateFont(input: Uint8Array, options?: InstanceOptions): Promise<Uint8Array>;
+declare function reduceVariationSpace(input: Uint8Array, options: VariationSpaceOptions): 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>;
@@ -137,8 +273,49 @@ declare function svgFontToTtf(input: string, options?: Svg2TtfOptions): Promise<
 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 inspectCapabilities(input: Uint8Array): Promise<FontCapabilityReport>;
+declare function inspectCollection(input: Uint8Array): Promise<FontCollectionInfo>;
+declare function extractCollectionFace(input: Uint8Array, faceIndex: number): Promise<Uint8Array>;
 declare function generateFontFaceCss(sources: CssFontSource[], options?: CssOptions): Promise<string>;
 //#endregion
+//#region ../../packages/fontmin/src/runtime-neutral/auto-delivery.d.ts
+type DeliveryLanguagePreset = 'ar' | 'el' | 'en' | 'hi' | 'ja' | 'ko' | 'ru' | 'zh-Hans' | 'zh-Hant';
+interface AutoDeliveryPlanOptions {
+  frequencyText?: string;
+  languages?: DeliveryLanguagePreset[];
+  maxSlices?: number;
+  targetBytes?: number;
+  tolerance?: number;
+}
+interface AutoDeliveryPlanSlice {
+  codePoints: number[];
+  estimatedBytes: number;
+  name: string;
+  unicodeRanges: string[];
+}
+interface AutoDeliveryPlan {
+  codePointCount: number;
+  languages: DeliveryLanguagePreset[];
+  slices: AutoDeliveryPlanSlice[];
+  targetBytes: number;
+  tolerance: number;
+}
+/**
+ * Detect supported delivery-language presets from representative page text.
+ *
+ * @param text - Static or frequency-weighted business text.
+ * @returns Presets in first-observed order, with Han assigned to a detected
+ *   Japanese, Korean, or Traditional Chinese context before Simplified Chinese.
+ */
+declare function detectDeliveryLanguages(text: string): DeliveryLanguagePreset[];
+/**
+ * Compact code points into canonical CSS Unicode ranges.
+ *
+ * @param codePoints - Unicode scalar values in any order.
+ * @returns Sorted `U+XXXX[-YYYY]` ranges.
+ */
+declare function unicodeRangesFromCodePoints(codePoints: readonly number[]): string[];
+//#endregion
 //#region src/plugins.d.ts
 type MaybePromise<T> = T | Promise<T>;
 interface DeliverySlice {
@@ -148,6 +325,12 @@ interface DeliverySlice {
 interface DeliverySlicesOptions {
   slices: DeliverySlice[];
 }
+interface AutoDeliveryPluginOptions extends AutoDeliveryPlanOptions {
+  measureFormat?: 'ttf' | 'woff' | 'woff2';
+  subset?: SubsetOptions;
+  woff2Quality?: number;
+  woffCompressionLevel?: number;
+}
 interface GlyphOptions extends SubsetOptions {
   clone?: boolean;
 }
@@ -166,6 +349,9 @@ interface Ttf2SvgPluginOptions extends Ttf2SvgOptions {
 interface Otf2TtfPluginOptions extends Otf2TtfOptions {
   clone?: boolean;
 }
+interface VariationSpacePluginOptions extends VariationSpaceOptions {
+  clone?: boolean;
+}
 interface Svg2TtfPluginOptions extends Svg2TtfOptions {
   clone?: boolean;
 }
@@ -177,6 +363,8 @@ interface ModernWebOptions extends GlyphOptions, Otf2TtfPluginOptions, Ttf2WoffP
   fontFamily?: string;
   fontPath?: string;
   local?: boolean;
+  variationAxes?: VariationSpaceOptions['axes'];
+  downgradeCff2?: boolean;
 }
 interface FontminCompatPresetOptions extends GlyphOptions, Otf2TtfPluginOptions, Ttf2EotPluginOptions, Ttf2SvgPluginOptions, Ttf2WoffPluginOptions, Ttf2Woff2PluginOptions {
   fontDisplay?: CssOptions['fontDisplay'];
@@ -198,11 +386,13 @@ interface BrowserPlugin<Options extends object = object> {
 }
 declare function glyph(options?: GlyphOptions): BrowserPlugin<GlyphOptions>;
 declare function deliverySlices(slices: DeliverySlice[]): BrowserPlugin<DeliverySlicesOptions>;
+declare function autoDeliverySlices(options?: AutoDeliveryPluginOptions): BrowserPlugin<AutoDeliveryPluginOptions>;
 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 variationSpace(options: VariationSpacePluginOptions): BrowserPlugin<VariationSpacePluginOptions>;
 declare function svg2ttf(options?: Svg2TtfPluginOptions): BrowserPlugin<Svg2TtfPluginOptions>;
 declare function svgs2ttf(options?: Svgs2TtfPluginOptions): BrowserPlugin<Svgs2TtfPluginOptions>;
 declare function css(options?: CssOptions): BrowserPlugin<CssOptions>;
@@ -222,4 +412,4 @@ interface BrowserOptimizeConfig {
 }
 declare function optimizeBrowser(config: BrowserOptimizeConfig): Promise<BrowserAsset[]>;
 //#endregion
-export { type BrowserAsset, type BrowserOptimizeConfig, type BrowserPlugin, type BrowserPluginContext, type CoverageOptions, type CoverageReport, type CssFontSource, type CssGlyph, type CssOptions, type DeliverySlice, type DeliverySlicesOptions, type FontFormat, type FontInfo, type FontMetadata, type FontminCompatPresetOptions, type FontminDiagnosticCode, FontminDiagnosticError, type GlyphOptions, type LayoutSubsetMode, type MaybePromise, type MissingGlyphPolicy, 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, analyzeCoverage, 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 };
+export { type AutoDeliveryPlan, type AutoDeliveryPlanOptions, type AutoDeliveryPlanSlice, type AutoDeliveryPluginOptions, type AxisRange, type AxisSetting, type BrowserAsset, type BrowserOptimizeConfig, type BrowserPlugin, type BrowserPluginContext, type CapabilitySupport, type ColorFontCapabilityReport, type ColorFontTechnology, type ColorFontTechnologyCapability, type CoverageOptions, type CoverageReport, type CssFontSource, type CssGlyph, type CssOptions, type DeliveryLanguagePreset, type DeliverySlice, type DeliverySlicesOptions, type FontCapabilityReport, type FontCollectionFaceInfo, type FontCollectionInfo, type FontFormat, type FontInfo, type FontMetadata, type FontminCompatPresetOptions, type FontminDiagnosticCode, FontminDiagnosticError, type GidMapping, type GlyphNameGidMapping, type GlyphOptions, type InstanceOptions, type LayoutSubsetMode, type MaybePromise, type MissingGlyphPolicy, type ModernWebOptions, type Otf2TtfOptions, type Otf2TtfPluginOptions, type OutputFormat, type SubsetOptions, type SubsetPlan, type SubsetReport, type SubsetResult, 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 UnicodeGidMapping, type VariationSpaceOptions, type VariationSpacePluginOptions, type WoffOptions, analyzeCoverage, autoDeliverySlices, createTtfSubsetPlan, css, deliverySlices, detectDeliveryLanguages, eotToTtf, extractCollectionFace, fontminCompatPreset, generateFontFaceCss, glyph, initWasm, inspect, inspectCapabilities, inspectCollection, instantiateFont, isWasmInitialized, modernWeb, optimizeBrowser, otf2ttf, otfToTtf, reduceVariationSpace, subsetTtf, subsetTtfWithPlan, subsetTtfWithReport, svg2ttf, svgFontToTtf, svgs2ttf, svgsToTtf, ttf2eot, ttf2svg, ttf2woff, ttf2woff2, ttfToEot, ttfToSvg, ttfToWoff, ttfToWoff2, unicodeRangesFromCodePoints, validateWoff2, variationSpace, woff2ToTtf, woffToTtf };

package/dist/index.mjs

@@ -174,16 +174,51 @@ async function binary(operation, input, options = {}) {
 	return withFontminDiagnostics(() => bytes(wasm.transform(operation, input, options)));
 }
 async function subsetTtf(input, options = {}) {
-	if ((options.missingGlyphs ?? "warn") === "warn") {
+	if ((options.missingGlyphs ?? "warn") === "warn" && hasUnicodeSelection(options)) {
 		const warning = missingGlyphWarning(await analyzeCoverage(input, coverageOptions(options)));
 		if (warning !== void 0) console.warn(warning);
 	}
 	return binary("subsetTtf", input, options);
 }
+async function subsetTtfWithReport(input, options = {}) {
+	const wasm = await getWasmModule();
+	const result = withFontminDiagnostics(() => wasm.transform("subsetTtfWithReport", input, options));
+	return {
+		data: bytes(result.data),
+		report: {
+			...result.report,
+			newToOld: result.report.newToOld.map((gid) => gid ?? null)
+		}
+	};
+}
+async function createTtfSubsetPlan(input, options = {}) {
+	const wasm = await getWasmModule();
+	return withFontminDiagnostics(() => wasm.transform("createTtfSubsetPlan", input, options));
+}
+async function subsetTtfWithPlan(input, plan) {
+	const wasm = await getWasmModule();
+	const result = withFontminDiagnostics(() => wasm.transform("subsetTtfWithPlan", input, plan));
+	return {
+		data: bytes(result.data),
+		report: {
+			...result.report,
+			newToOld: result.report.newToOld.map((gid) => gid ?? null)
+		}
+	};
+}
+function hasUnicodeSelection(options) {
+	return options.basicText === true || (options.text?.length ?? 0) > 0 || (options.unicodes?.length ?? 0) > 0 || (options.unicodeRanges?.length ?? 0) > 0;
+}
 async function analyzeCoverage(input, options = {}) {
 	const wasm = await getWasmModule();
 	return withFontminDiagnostics(() => wasm.transform("analyzeCoverage", input, options));
 }
+async function instantiateFont(input, options = {}) {
+	return binary("instantiateFont", input, options);
+}
+async function reduceVariationSpace(input, options) {
+	return binary("reduceVariationSpace", input, options);
+}
 async function ttfToWoff(input, options = {}) {
 	return binary("ttfToWoff", input, options);
 }
@@ -225,6 +260,25 @@ async function inspect(input) {
 	const wasm = await getWasmModule();
 	return withFontminDiagnostics(() => wasm.transform("inspect", input, {}));
 }
+async function inspectCapabilities(input) {
+	const wasm = await getWasmModule();
+	const report = withFontminDiagnostics(() => wasm.transform("inspectCapabilities", input, {}));
+	if (report.color.subsetSupport === void 0) {
+		const { subsetSupport: _subsetSupport, ...color } = report.color;
+		return {
+			...report,
+			color
+		};
+	}
+	return report;
+}
+async function inspectCollection(input) {
+	const wasm = await getWasmModule();
+	return withFontminDiagnostics(() => wasm.transform("inspectCollection", input, {}));
+}
+async function extractCollectionFace(input, faceIndex) {
+	return binary("extractCollectionFace", input, { faceIndex });
+}
 async function generateFontFaceCss(sources, options = {}) {
 	const wasm = await getWasmModule();
 	return withFontminDiagnostics(() => wasm.generate_css(sources, options));
@@ -238,6 +292,418 @@ function coverageOptions(options) {
 	return coverage;
 }
 //#endregion
+//#region ../../packages/fontmin/src/runtime-neutral/auto-delivery.ts
+const DEFAULT_TARGET_BYTES = 100 * 1024;
+const DEFAULT_TOLERANCE = .15;
+const DEFAULT_MAX_SLICES = 32;
+const GROUPS = {
+	arabic: ranges([
+		[1536, 1791],
+		[1872, 1919],
+		[2160, 2207],
+		[2208, 2303],
+		[64336, 65023],
+		[65136, 65279]
+	]),
+	bopomofo: ranges([[12544, 12591], [12704, 12735]]),
+	cyrillic: ranges([
+		[1024, 1327],
+		[7296, 7311],
+		[11744, 11775],
+		[42560, 42655]
+	]),
+	devanagari: ranges([[2304, 2431], [43232, 43263]]),
+	greek: ranges([[880, 1023], [7936, 8191]]),
+	han: ranges([
+		[11904, 12255],
+		[13312, 19903],
+		[19968, 40959],
+		[63744, 64255],
+		[131072, 191471],
+		[196608, 205743]
+	]),
+	hangul: ranges([
+		[4352, 4607],
+		[12592, 12687],
+		[43360, 43391],
+		[44032, 55215],
+		[55216, 55295]
+	]),
+	kana: ranges([
+		[12352, 12543],
+		[12784, 12799],
+		[110592, 110959]
+	]),
+	latin: ranges([
+		[32, 126],
+		[160, 687],
+		[7680, 7935]
+	]),
+	punctuation: ranges([
+		[8192, 8303],
+		[12288, 12351],
+		[65040, 65055],
+		[65072, 65103],
+		[65280, 65519]
+	])
+};
+const LANGUAGE_GROUPS = {
+	ar: ["arabic"],
+	el: ["greek"],
+	en: ["latin"],
+	hi: ["devanagari"],
+	ja: [
+		"punctuation",
+		"kana",
+		"han"
+	],
+	ko: [
+		"punctuation",
+		"hangul",
+		"han"
+	],
+	ru: ["cyrillic"],
+	"zh-Hans": ["punctuation", "han"],
+	"zh-Hant": [
+		"punctuation",
+		"bopomofo",
+		"han"
+	]
+};
+/**
+* Detect supported delivery-language presets from representative page text.
+*
+* @param text - Static or frequency-weighted business text.
+* @returns Presets in first-observed order, with Han assigned to a detected
+*   Japanese, Korean, or Traditional Chinese context before Simplified Chinese.
+*/
+function detectDeliveryLanguages(text) {
+	const detected = [];
+	const seen = /* @__PURE__ */ new Set();
+	let pendingHan = false;
+	for (const character of text) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint === void 0) continue;
+		const language = languageOf(codePoint);
+		if (language === "han") pendingHan = true;
+		else if (language !== void 0 && !seen.has(language)) {
+			seen.add(language);
+			detected.push(language);
+		}
+	}
+	if (pendingHan && ![
+		"ja",
+		"ko",
+		"zh-Hant"
+	].some((tag) => seen.has(tag))) detected.push("zh-Hans");
+	return detected;
+}
+/**
+* Plan byte-bounded delivery slices over code points supported by a font.
+*
+* @param supportedCodePoints - Unicode cmap coverage from one or more faces.
+* @param options - Language, frequency, byte target, and request constraints.
+* @param measure - Returns the actual encoded byte size for a proposed slice.
+* @returns A deterministic, measured delivery plan.
+*/
+async function planAutoDeliverySlices(supportedCodePoints, options, measure) {
+	const normalized = normalizeOptions(options);
+	const languages = resolveLanguages(normalized);
+	const groups = planningGroups(supportedCodePoints, languages, normalized);
+	if (groups.length === 0) throw new Error("auto delivery presets matched no supported code points");
+	if (groups.length > normalized.maxSlices) throw new Error(`auto delivery requires at least ${groups.length} slices for the selected languages`);
+	const merged = await mergeSmallGroups(await splitOversizedGroups(await Promise.all(groups.map(async (group) => measureGroup(group, measure))), normalized, measure), normalized, measure);
+	const groupCounts = /* @__PURE__ */ new Map();
+	for (const group of merged) groupCounts.set(group.name, (groupCounts.get(group.name) ?? 0) + 1);
+	const groupIndexes = /* @__PURE__ */ new Map();
+	const slices = merged.map((group) => {
+		const index = (groupIndexes.get(group.name) ?? 0) + 1;
+		const count = groupCounts.get(group.name) ?? 1;
+		groupIndexes.set(group.name, index);
+		return {
+			codePoints: [...group.codePoints].toSorted((left, right) => left - right),
+			estimatedBytes: group.estimatedBytes,
+			name: count === 1 ? group.name : `${group.name}-${String(index).padStart(String(count).length, "0")}`,
+			unicodeRanges: unicodeRangesFromCodePoints(group.codePoints)
+		};
+	});
+	return {
+		codePointCount: new Set(slices.flatMap((slice) => slice.codePoints)).size,
+		languages,
+		slices,
+		targetBytes: normalized.targetBytes,
+		tolerance: normalized.tolerance
+	};
+}
+function normalizeOptions(options) {
+	const targetBytes = options.targetBytes ?? DEFAULT_TARGET_BYTES;
+	const tolerance = options.tolerance ?? DEFAULT_TOLERANCE;
+	const maxSlices = options.maxSlices ?? DEFAULT_MAX_SLICES;
+	if (!Number.isInteger(targetBytes) || targetBytes <= 0) throw new TypeError("auto delivery targetBytes must be a positive integer");
+	if (!Number.isFinite(tolerance) || tolerance < 0 || tolerance >= 1) throw new TypeError("auto delivery tolerance must be in [0, 1)");
+	if (!Number.isInteger(maxSlices) || maxSlices <= 0 || maxSlices > 256) throw new TypeError("auto delivery maxSlices must be an integer in [1, 256]");
+	return {
+		frequencyText: options.frequencyText ?? "",
+		languages: [...options.languages ?? []],
+		maxSlices,
+		targetBytes,
+		tolerance
+	};
+}
+function resolveLanguages(options) {
+	const languages = options.languages.length === 0 ? detectDeliveryLanguages(options.frequencyText) : options.languages;
+	const resolved = languages.length === 0 ? ["en"] : languages;
+	return [...new Set(resolved)];
+}
+function planningGroups(supportedCodePoints, languages, options) {
+	const supported = new Set(supportedCodePoints.filter((codePoint) => isValidUnicodeScalar$1(codePoint)).toSorted((left, right) => left - right));
+	const languageGroups = groupsForLanguages(languages);
+	const selected = new Set(languageGroups.flatMap((group) => [...supported].filter((codePoint) => includesCodePoint(group, codePoint))));
+	const frequency = frequencyOrder(options.frequencyText).filter((codePoint) => selected.has(codePoint));
+	const prioritized = new Set(frequency);
+	const groups = [];
+	if (frequency.length > 0) groups.push({
+		codePoints: frequency,
+		name: "priority"
+	});
+	const assigned = new Set(prioritized);
+	for (const group of languageGroups) {
+		const codePoints = [...supported].filter((codePoint) => !assigned.has(codePoint) && includesCodePoint(group, codePoint));
+		for (const codePoint of codePoints) assigned.add(codePoint);
+		if (codePoints.length > 0) groups.push({
+			codePoints,
+			name: group.name
+		});
+	}
+	return groups;
+}
+function groupsForLanguages(languages) {
+	return [...new Set(languages.flatMap((language) => LANGUAGE_GROUPS[language]))].map((name) => ({
+		name,
+		ranges: GROUPS[name]
+	}));
+}
+async function splitOversizedGroups(initial, options, measure) {
+	const groups = [...initial];
+	const maximumBytes = options.targetBytes * (1 + options.tolerance);
+	while (groups.length < options.maxSlices) {
+		const candidateIndex = groups.map((group, index) => ({
+			group,
+			index
+		})).filter(({ group }) => group.estimatedBytes > maximumBytes && group.codePoints.length > 1).toSorted((left, right) => right.group.estimatedBytes - left.group.estimatedBytes || left.index - right.index)[0]?.index;
+		if (candidateIndex === void 0) break;
+		const candidate = groups[candidateIndex];
+		if (candidate === void 0) break;
+		const midpoint = Math.ceil(candidate.codePoints.length / 2);
+		const replacements = await Promise.all([measureGroup({
+			codePoints: candidate.codePoints.slice(0, midpoint),
+			name: candidate.name
+		}, measure), measureGroup({
+			codePoints: candidate.codePoints.slice(midpoint),
+			name: candidate.name
+		}, measure)]);
+		groups.splice(candidateIndex, 1, ...replacements);
+	}
+	return groups;
+}
+async function mergeSmallGroups(initial, options, measure) {
+	const groups = [...initial];
+	const minimumBytes = options.targetBytes * (1 - options.tolerance);
+	const maximumBytes = options.targetBytes * (1 + options.tolerance);
+	let index = 0;
+	while (index < groups.length - 1) {
+		const current = groups[index];
+		const next = groups[index + 1];
+		if (current === void 0 || next === void 0) break;
+		if (current.name !== next.name || current.estimatedBytes >= minimumBytes) {
+			index += 1;
+			continue;
+		}
+		const merged = await measureGroup({
+			codePoints: [...current.codePoints, ...next.codePoints],
+			name: current.name
+		}, measure);
+		if (merged.estimatedBytes <= maximumBytes) groups.splice(index, 2, merged);
+		else index += 1;
+	}
+	return groups;
+}
+async function measureGroup(group, measure) {
+	const estimatedBytes = await measure(group.codePoints);
+	if (!Number.isInteger(estimatedBytes) || estimatedBytes < 0) throw new TypeError("auto delivery measure must return a non-negative integer");
+	return {
+		...group,
+		estimatedBytes
+	};
+}
+function frequencyOrder(text) {
+	const frequencies = /* @__PURE__ */ new Map();
+	let index = 0;
+	for (const character of text) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint !== void 0) {
+			const current = frequencies.get(codePoint);
+			frequencies.set(codePoint, {
+				count: (current?.count ?? 0) + 1,
+				index: current?.index ?? index
+			});
+			index += 1;
+		}
+	}
+	return [...frequencies.entries()].toSorted(([, left], [, right]) => right.count - left.count || left.index - right.index).map(([codePoint]) => codePoint);
+}
+/**
+* Compact code points into canonical CSS Unicode ranges.
+*
+* @param codePoints - Unicode scalar values in any order.
+* @returns Sorted `U+XXXX[-YYYY]` ranges.
+*/
+function unicodeRangesFromCodePoints(codePoints) {
+	const sorted = [...new Set(codePoints)].toSorted((left, right) => left - right);
+	const compact = [];
+	for (let index = 0; index < sorted.length;) {
+		const start = sorted[index];
+		if (start === void 0) break;
+		let end = start;
+		while (sorted[index + 1] === end + 1) {
+			end += 1;
+			index += 1;
+		}
+		compact.push(start === end ? `U+${unicodeHex(start)}` : `U+${unicodeHex(start)}-${unicodeHex(end)}`);
+		index += 1;
+	}
+	return compact;
+}
+function languageOf(codePoint) {
+	if (includesRanges(GROUPS.kana, codePoint)) return "ja";
+	if (includesRanges(GROUPS.hangul, codePoint)) return "ko";
+	if (includesRanges(GROUPS.bopomofo, codePoint)) return "zh-Hant";
+	if (includesRanges(GROUPS.han, codePoint)) return "han";
+	if (includesRanges(GROUPS.arabic, codePoint)) return "ar";
+	if (includesRanges(GROUPS.devanagari, codePoint)) return "hi";
+	if (includesRanges(GROUPS.cyrillic, codePoint)) return "ru";
+	if (includesRanges(GROUPS.greek, codePoint)) return "el";
+	if (includesRanges(GROUPS.latin, codePoint)) return "en";
+}
+function includesCodePoint(group, codePoint) {
+	return includesRanges(group.ranges, codePoint);
+}
+function includesRanges(values, codePoint) {
+	return values.some((range) => codePoint >= range.start && codePoint <= range.end);
+}
+function ranges(values) {
+	return values.map(([start, end]) => ({
+		end,
+		start
+	}));
+}
+function isValidUnicodeScalar$1(codePoint) {
+	return Number.isInteger(codePoint) && codePoint >= 0 && codePoint <= 1114111 && (codePoint < 55296 || codePoint > 57343);
+}
+function unicodeHex(codePoint) {
+	return codePoint.toString(16).toUpperCase().padStart(4, "0");
+}
+//#endregion
+//#region ../../packages/fontmin/src/runtime-neutral/sfnt-unicode.ts
+/**
+* Read mapped Unicode scalar values from the Unicode cmap subtables of an SFNT.
+*
+* @param input - TTF or OTF bytes.
+* @returns Sorted, unique code points whose mapped glyph ID is non-zero.
+*/
+function unicodeCodePointsFromSfnt(input) {
+	const view = new DataView(input.buffer, input.byteOffset, input.byteLength);
+	const cmapOffset = tableOffset(view, input, "cmap");
+	if (cmapOffset === void 0 || cmapOffset + 4 > view.byteLength) return [];
+	const recordCount = view.getUint16(cmapOffset + 2);
+	const codePoints = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	for (let index = 0; index < recordCount; index += 1) {
+		const recordOffset = cmapOffset + 4 + index * 8;
+		if (recordOffset + 8 > view.byteLength) break;
+		const platform = view.getUint16(recordOffset);
+		const encoding = view.getUint16(recordOffset + 2);
+		if (platform !== 0 && !(platform === 3 && (encoding === 1 || encoding === 10))) continue;
+		const subtableOffset = cmapOffset + view.getUint32(recordOffset + 4);
+		if (visited.has(subtableOffset) || subtableOffset + 2 > view.byteLength) continue;
+		visited.add(subtableOffset);
+		collectSubtable(view, subtableOffset, codePoints);
+	}
+	return [...codePoints].toSorted((left, right) => left - right);
+}
+function tableOffset(view, input, requestedTag) {
+	if (view.byteLength < 12) return;
+	const tableCount = view.getUint16(4);
+	const decoder = new TextDecoder();
+	for (let index = 0; index < tableCount; index += 1) {
+		const recordOffset = 12 + index * 16;
+		if (recordOffset + 16 > view.byteLength) return;
+		if (decoder.decode(input.subarray(recordOffset, recordOffset + 4)) === requestedTag) {
+			const offset = view.getUint32(recordOffset + 8);
+			return offset < view.byteLength ? offset : void 0;
+		}
+	}
+}
+function collectSubtable(view, offset, codePoints) {
+	const format = view.getUint16(offset);
+	if (format === 0) collectFormat0(view, offset, codePoints);
+	else if (format === 4) collectFormat4(view, offset, codePoints);
+	else if (format === 12 || format === 13) collectFormat12Or13(view, offset, codePoints, format);
+}
+function collectFormat0(view, offset, codePoints) {
+	if (offset + 262 > view.byteLength) return;
+	for (let codePoint = 0; codePoint < 256; codePoint += 1) if (view.getUint8(offset + 6 + codePoint) !== 0) codePoints.add(codePoint);
+}
+function collectFormat4(view, offset, codePoints) {
+	if (offset + 16 > view.byteLength) return;
+	const length = view.getUint16(offset + 2);
+	const end = Math.min(offset + length, view.byteLength);
+	const segmentCount = view.getUint16(offset + 6) / 2;
+	const endCodesOffset = offset + 14;
+	const startCodesOffset = endCodesOffset + segmentCount * 2 + 2;
+	const deltasOffset = startCodesOffset + segmentCount * 2;
+	const rangeOffsetsOffset = deltasOffset + segmentCount * 2;
+	if (rangeOffsetsOffset + segmentCount * 2 > end) return;
+	for (let segment = 0; segment < segmentCount; segment += 1) {
+		const start = view.getUint16(startCodesOffset + segment * 2);
+		const segmentEnd = view.getUint16(endCodesOffset + segment * 2);
+		const delta = view.getInt16(deltasOffset + segment * 2);
+		const rangeOffsetPosition = rangeOffsetsOffset + segment * 2;
+		const rangeOffset = view.getUint16(rangeOffsetPosition);
+		for (let codePoint = start; codePoint <= segmentEnd && codePoint < 65535; codePoint += 1) {
+			let glyphId;
+			if (rangeOffset === 0) glyphId = uint16(codePoint + delta);
+			else {
+				const glyphOffset = rangeOffsetPosition + rangeOffset + (codePoint - start) * 2;
+				if (glyphOffset + 2 > end) continue;
+				const rawGlyphId = view.getUint16(glyphOffset);
+				glyphId = rawGlyphId === 0 ? 0 : uint16(rawGlyphId + delta);
+			}
+			if (glyphId !== 0 && isValidUnicodeScalar(codePoint)) codePoints.add(codePoint);
+		}
+	}
+}
+function collectFormat12Or13(view, offset, codePoints, format) {
+	if (offset + 16 > view.byteLength) return;
+	const length = view.getUint32(offset + 4);
+	const end = Math.min(offset + length, view.byteLength);
+	const groupCount = view.getUint32(offset + 12);
+	for (let group = 0; group < groupCount; group += 1) {
+		const groupOffset = offset + 16 + group * 12;
+		if (groupOffset + 12 > end) break;
+		const start = view.getUint32(groupOffset);
+		const groupEnd = Math.min(view.getUint32(groupOffset + 4), 1114111);
+		const startGlyphId = view.getUint32(groupOffset + 8);
+		for (let codePoint = start; codePoint <= groupEnd; codePoint += 1) if ((format === 12 ? startGlyphId + codePoint - start : startGlyphId) !== 0 && isValidUnicodeScalar(codePoint)) codePoints.add(codePoint);
+	}
+}
+function isValidUnicodeScalar(codePoint) {
+	return codePoint < 55296 || codePoint > 57343;
+}
+function uint16(value) {
+	return (value % 65536 + 65536) % 65536;
+}
+//#endregion
 //#region src/plugins.ts
 function plugin(name, options) {
 	return {
@@ -250,9 +716,18 @@ function glyph(options = {}) {
 		basicText: false,
 		keepNotdef: true,
 		layout: "conservative",
+		layoutFeatures: [],
+		layoutScripts: [],
+		layoutLanguages: [],
+		nameIds: [],
+		nameLanguages: [],
+		dropTables: [],
+		passThroughTables: [],
 		missingGlyphs: "warn",
 		preserveHinting: false,
 		trim: true,
+		gids: [],
+		glyphNames: [],
 		unicodes: [],
 		...options
 	});
@@ -263,6 +738,9 @@ function deliverySlices(slices) {
 		unicodeRanges: [...slice.unicodeRanges]
 	})) });
 }
+function autoDeliverySlices(options = {}) {
+	return plugin("autoUnicodeSlices", structuredClone(options));
+}
 function normalizeDeliverySlices(options) {
 	return normalizeDeliverySlices$1(options.slices);
 }
@@ -281,6 +759,9 @@ function ttf2svg(options = {}) {
 function otf2ttf(options = {}) {
 	return plugin("otf2ttf", options);
 }
+function variationSpace(options) {
+	return plugin("variationSpace", options);
+}
 function svg2ttf(options = {}) {
 	return plugin("svg2ttf", options);
 }
@@ -312,6 +793,11 @@ function modernWeb(options = {}) {
 	if (typeof options.preserveHinting === "boolean") otfOptions.preserveHinting = options.preserveHinting;
 	if (options.variationCoordinates !== void 0) otfOptions.variationCoordinates = options.variationCoordinates;
 	return [
+		...options.variationAxes === void 0 ? [] : [variationSpace({
+			axes: options.variationAxes,
+			clone: false,
+			...options.downgradeCff2 === void 0 ? {} : { downgradeCff2: options.downgradeCff2 }
+		})],
 		otf2ttf(otfOptions),
 		glyph(subset),
 		ttf2woff(options),
@@ -341,6 +827,29 @@ function fontminCompatPreset(options = {}) {
 async function optimizeBrowser(config) {
 	let assets = config.assets.map(formatAsset);
 	for (const plugin of config.plugins ?? []) {
+		if (plugin.name === "variationSpace") {
+			const options = optionsOf(plugin);
+			assets = await flatMapAssets(assets, async (asset) => {
+				if (![
+					"eot",
+					"otf",
+					"ttf",
+					"woff",
+					"woff2"
+				].includes(asset.format)) return [asset];
+				const contents = await reduceVariationSpace(asset.contents, options);
+				const format = new TextDecoder().decode(contents.subarray(0, 4)) === "OTTO" ? "otf" : "ttf";
+				const normalizedFileName = replaceExtension(asset.fileName, format);
+				const reduced = {
+					...asset,
+					contents,
+					fileName: options.clone === true ? appendFileNameSuffix(normalizedFileName, "reduced") : normalizedFileName,
+					format
+				};
+				return options.clone === true ? [asset, reduced] : [reduced];
+			});
+			continue;
+		}
 		if (plugin.name === "glyph") {
 			const options = optionsOf(plugin);
 			assets = await flatMapAssets(assets, async (asset) => {
@@ -369,6 +878,10 @@ async function optimizeBrowser(config) {
 			});
 			continue;
 		}
+		if (plugin.name === "autoUnicodeSlices") {
+			assets = await runAutoDeliverySlices(assets, optionsOf(plugin));
+			continue;
+		}
 		if (plugin.name === "css") {
 			const options = optionsOf(plugin);
 			const css = await generateFontFaceCss(assets.filter((asset) => [
@@ -442,6 +955,56 @@ async function optimizeBrowser(config) {
 	}
 	return assets;
 }
+async function runAutoDeliverySlices(assets, options) {
+	const sources = assets.flatMap((asset, index) => asset.format === "ttf" ? [{
+		asset,
+		codePoints: new Set(unicodeCodePointsFromSfnt(asset.contents)),
+		index
+	}] : []);
+	if (sources.length === 0) return assets;
+	const supported = [...new Set(sources.flatMap((source) => [...source.codePoints]))];
+	const cache = /* @__PURE__ */ new Map();
+	const subsetFor = async (source, codePoints) => {
+		const key = `${source.index}:${codePoints.join(",")}`;
+		const cached = cache.get(key);
+		if (cached !== void 0) return cached;
+		const contents = await subsetTtf(source.asset.contents, {
+			...options.subset,
+			missingGlyphs: "ignore",
+			unicodeRanges: unicodeRangesFromCodePoints(codePoints)
+		});
+		cache.set(key, contents);
+		return contents;
+	};
+	const plan = await planAutoDeliverySlices(supported, options, async (codePoints) => {
+		const sizes = await Promise.all(sources.filter((source) => codePoints.some((codePoint) => source.codePoints.has(codePoint))).map(async (source) => measureAutoDeliverySubset(await subsetFor(source, codePoints), options)));
+		return Math.max(...sizes);
+	});
+	const output = [];
+	for (const [index, asset] of assets.entries()) {
+		const source = sources.find((candidate) => candidate.index === index);
+		if (source === void 0) {
+			output.push(asset);
+			continue;
+		}
+		for (const slice of plan.slices) {
+			const codePoints = slice.codePoints.filter((codePoint) => source.codePoints.has(codePoint));
+			if (codePoints.length > 0) output.push({
+				...asset,
+				contents: await subsetFor(source, codePoints),
+				fileName: appendFileNameSuffix(asset.fileName, slice.name),
+				unicodeRanges: unicodeRangesFromCodePoints(codePoints)
+			});
+		}
+	}
+	return output;
+}
+async function measureAutoDeliverySubset(contents, options) {
+	const format = options.measureFormat ?? "woff2";
+	if (format === "ttf") return contents.byteLength;
+	if (format === "woff") return (await ttfToWoff(contents, options.woffCompressionLevel === void 0 ? {} : { compressionLevel: options.woffCompressionLevel })).byteLength;
+	return (await ttfToWoff2(contents, options.woff2Quality === void 0 ? {} : { quality: options.woff2Quality })).byteLength;
+}
 async function convert(asset, plugin, conversion) {
 	if (conversion.name === "ttf2woff") return converted(asset, conversion.outputFormat, await ttfToWoff(asset.contents, optionsOf(plugin)));
 	if (conversion.name === "ttf2woff2") return converted(asset, conversion.outputFormat, await ttfToWoff2(asset.contents, optionsOf(plugin)));
@@ -481,4 +1044,4 @@ function toKebabCase(value) {
 	return value.trim().replaceAll(/(?<lower>[a-z])(?<upper>[A-Z])/gu, "$<lower>-$<upper>").replaceAll(/\s+/gu, "-").toLowerCase();
 }
 //#endregion
-export { FontminDiagnosticError, analyzeCoverage, 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 };
+export { FontminDiagnosticError, analyzeCoverage, autoDeliverySlices, createTtfSubsetPlan, css, deliverySlices, detectDeliveryLanguages, eotToTtf, extractCollectionFace, fontminCompatPreset, generateFontFaceCss, glyph, initWasm, inspect, inspectCapabilities, inspectCollection, instantiateFont, isWasmInitialized, modernWeb, optimizeBrowser, otf2ttf, otfToTtf, reduceVariationSpace, subsetTtf, subsetTtfWithPlan, subsetTtfWithReport, svg2ttf, svgFontToTtf, svgs2ttf, svgsToTtf, ttf2eot, ttf2svg, ttf2woff, ttf2woff2, ttfToEot, ttfToSvg, ttfToWoff, ttfToWoff2, unicodeRangesFromCodePoints, validateWoff2, variationSpace, woff2ToTtf, woffToTtf };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fontmin-rs/wasm",
-  "version": "1.0.2-rc.1",
+  "version": "1.1.0",
   "description": "Browser WASM runtime for fontmin-rs.",
   "license": "MIT",
   "repository": {