@overpunch/vf-clamp 2.3.0 → 2.4.0

package/dist/index.js

@@ -1,9 +1,11 @@
-import { createRequire as $ } from "node:module";
-const M = $(import.meta.url), { preparePyodide: d, PyodideFile: x } = M("@web-alchemy/fonttools/src/pyodide.js");
-let A = null;
-async function L() {
-  return A || (A = d().then(
-    (e) => e.runPythonAsync(`
+import { createRequire as j } from "node:module";
+import { findInstance as F, rangeName as E } from "./naming.js";
+import { compactName as st, numberKey as rt, planOutputs as lt, unboughtInstances as ft } from "./naming.js";
+const P = j(import.meta.url), { preparePyodide: f, PyodideFile: p } = P("@web-alchemy/fonttools/src/pyodide.js");
+let y = null;
+async function M() {
+  return y || (y = f().then(
+    (t) => t.runPythonAsync(`
 from fontTools.ttLib import TTFont
 
 def vf_convert_flavor(file_options):
@@ -13,39 +15,39 @@ def vf_convert_flavor(file_options):
 
 vf_convert_flavor
 `)
-  )), A;
+  )), y;
 }
-async function R(e, a) {
-  const t = await d(), n = new x({ pyodide: t }), i = new x({ pyodide: t });
+async function O(t, o) {
+  const a = await f(), n = new p({ pyodide: a }), e = new p({ pyodide: a });
   try {
-    await n.upload(e);
-    const o = /* @__PURE__ */ new Map([
+    await n.upload(t);
+    const i = /* @__PURE__ */ new Map([
       ["input-file", n.filename],
-      ["output-file", i.filename],
-      ["flavor", a]
+      ["output-file", e.filename],
+      ["flavor", o]
     ]);
-    return (await L())(o), i.download();
+    return (await M())(i), e.download();
   } finally {
     try {
       n.delete();
     } catch {
     }
     try {
-      i.delete();
+      e.delete();
     } catch {
     }
   }
 }
-async function k(e) {
-  return R(e, "woff");
+async function U(t) {
+  return O(t, "woff");
 }
-async function C(e) {
-  return R(e, "woff2");
+async function q(t) {
+  return O(t, "woff2");
 }
-let I = null;
-async function E() {
-  return I || (I = d().then(
-    (e) => e.runPythonAsync(`
+let v = null;
+async function W() {
+  return v || (v = f().then(
+    (t) => t.runPythonAsync(`
 import json
 from fontTools.ttLib import TTFont
 
@@ -78,18 +80,28 @@ def get_instances_fn(input_file):
         for i, inst in enumerate(fvar.instances)
     ]
 
-    return json.dumps({'axes': axes, 'instances': instances, 'family': family})
+    labels = {}
+    if 'STAT' in font and font['STAT'].table.AxisValueArray:
+        stat = font['STAT'].table
+        tags = [a.AxisTag for a in stat.DesignAxisRecord.Axis]
+        for av in stat.AxisValueArray.AxisValue:
+            if av.Format in (1, 2, 3) and av.AxisIndex < len(tags):
+                value = av.NominalValue if av.Format == 2 else av.Value
+                key = ('%f' % float(value)).rstrip('0').rstrip('.')
+                labels.setdefault(tags[av.AxisIndex], {})[key] = name_table.getDebugName(av.ValueNameID) or ''
+
+    return json.dumps({'axes': axes, 'instances': instances, 'family': family, 'labels': labels})
 
 get_instances_fn
 `)
-  )), I;
+  )), v;
 }
-async function B(e) {
-  const a = await d(), t = e instanceof ArrayBuffer ? new Uint8Array(e) : e, n = new x({ pyodide: a });
+async function z(t) {
+  const o = await f(), a = t instanceof ArrayBuffer ? new Uint8Array(t) : t, n = new p({ pyodide: o });
   try {
-    await n.upload(t);
-    const o = (await E())(n.filename);
-    return JSON.parse(o);
+    await n.upload(a);
+    const i = (await W())(n.filename);
+    return JSON.parse(i);
   } finally {
     try {
       n.delete();
@@ -97,125 +109,414 @@ async function B(e) {
     }
   }
 }
-function U(e, a) {
-  if (e === a) return e;
-  const t = e.split(" "), n = a.split(" ");
-  let i = 0;
-  for (; i < t.length && i < n.length && t[i] === n[i]; )
-    i++;
-  let o = 0;
-  for (; o < t.length - i && o < n.length - i && t[t.length - 1 - o] === n[n.length - 1 - o]; )
-    o++;
-  const r = t.slice(0, i).join(" "), s = t.slice(i, t.length - (o || 0)).join(" "), h = n.slice(i, n.length - (o || 0)).join(" "), y = o > 0 ? t.slice(t.length - o).join(" ") : "", f = s && h ? `${s}-${h}` : s || h;
-  return [r, f, y].filter(Boolean).join(" ");
+const $ = `# vfclamp_naming.py — the single implementation of vf-clamp's naming, style-bit and STAT clean-up rules (docs/NAMING.md), shared by the npm package (run in Pyodide), the Glyphs plugin and the RoboFont extension.
+#
+# Canonical copy: vfClamp/shared/plugin-views/vfclamp_naming.py. The plugins get byte-identical copies via
+# \`npm run sync-plugin-views\`; the npm package imports this file's text at build time. Never edit a copy.
+# Pure fontTools: no Glyphs, RoboFont or AppKit imports.
+
+import re
+import unicodedata
+
+#: OS/2.fsSelection bits this module owns.
+FS_ITALIC = 0x01
+FS_BOLD = 0x20
+FS_REGULAR = 0x40
+FS_OBLIQUE = 0x200
+#: head.macStyle bits this module owns.
+MAC_BOLD = 0x01
+MAC_ITALIC = 0x02
+
+#: Label for an axis value that has no word in the font's style names (e.g. wdth 100 in "Light").
+DEFAULT_AXIS_WORDS = {'wght': 'Regular', 'wdth': 'Normal', 'ital': 'Upright', 'slnt': 'Upright'}
+
+#: The four style-linking (RIBBI) subfamily names.
+RIBBI = ('Regular', 'Italic', 'Bold', 'Bold Italic')
+
+
+def short_hash(text):
+	"""Six-character FNV-1a hash of a string, base 36; identical to shortHash() in the npm package."""
+	h = 0x811c9dc5
+	for ch in text:
+		h ^= ord(ch)
+		h = (h * 0x01000193) & 0xFFFFFFFF
+	digits = '0123456789abcdefghijklmnopqrstuvwxyz'
+	out = ''
+	while h:
+		h, rem = divmod(h, 36)
+		out = digits[rem] + out
+	return (out or '0').rjust(6, '0')[-6:]
+
+
+def ps_name(text, max_len=63):
+	"""PostScript name (nameID 6): accents transliterated, [A-Za-z0-9-] only, at most 63 characters.
+
+	Over 63 characters, a readable prefix plus a hash of the full text keeps names unique. Text with
+	letters in another script becomes 'Font-<hash>' (never the source font's name); text with no
+	letters at all becomes 'Font'.
+	"""
+	ascii_text = unicodedata.normalize('NFKD', text or '').encode('ascii', 'ignore').decode('ascii')
+	s = re.sub(r'[^A-Za-z0-9 -]', '', ascii_text).strip()
+	s = re.sub(r'\\s+', '-', s)
+	s = re.sub(r'-+', '-', s).strip('-')
+	if not s:
+		return f'Font-{short_hash(text)}' if any(c.isalpha() for c in (text or '')) else 'Font'
+	if len(s) > max_len:
+		s = f'{s[:max_len - 7].rstrip("-")}-{short_hash(text)}'
+	return s
+
+
+def vf_prefix(ps, family):
+	"""Variations PostScript Name Prefix (nameID 25): ASCII letters and digits only (OpenType spec), at most 27."""
+	alnum = re.sub(r'[^A-Za-z0-9]', '', ps)
+	if not alnum:
+		return 'Font'
+	if len(alnum) > 27:
+		return alnum[:21] + short_hash(family)
+	return alnum
+
+
+def full_name(family, style):
+	"""Full name (nameID 4): family plus style, leaving out 'Regular' and a style the family name already ends with."""
+	if not style or style == 'Regular' or family.lower().endswith(style.lower()):
+		return family
+	return f'{family} {style}'
+
+
+def number_key(value):
+	"""Stable text key for an axis value, identical in Python and JavaScript ('100', '87.5')."""
+	return ('%f' % float(value)).rstrip('0').rstrip('.')
+
+
+# ---------------------------------------------------------------------------
+# Inputs read from the source font (before instancing)
+# ---------------------------------------------------------------------------
+
+def source_style_info(font):
+	"""What the style rules need to know about the source: its italic/oblique bits and whether ital/slnt exist."""
+	fs = font['OS/2'].fsSelection if 'OS/2' in font else 0
+	tags = {ax.axisTag for ax in font['fvar'].axes} if 'fvar' in font else set()
+	return {'italic': bool(fs & FS_ITALIC), 'oblique': bool(fs & FS_OBLIQUE), 'has_ital_slnt': bool(tags & {'ital', 'slnt'})}
+
+
+def naming_inputs(font):
+	"""Instances, axes and STAT labels of a source font, in the shape range_name() takes."""
+	name = font['name']
+	axes = [{'tag': ax.axisTag, 'default': ax.defaultValue} for ax in font['fvar'].axes] if 'fvar' in font else []
+	instances = [
+		{'name': name.getDebugName(inst.subfamilyNameID) or '', 'coordinates': dict(inst.coordinates)}
+		for inst in (font['fvar'].instances if 'fvar' in font else [])
+	]
+	labels = {}
+	if 'STAT' in font and font['STAT'].table.AxisValueArray:
+		stat = font['STAT'].table
+		tags = [a.AxisTag for a in stat.DesignAxisRecord.Axis]
+		for av in stat.AxisValueArray.AxisValue:
+			if av.Format in (1, 2, 3) and av.AxisIndex < len(tags):
+				value = av.NominalValue if av.Format == 2 else av.Value
+				labels.setdefault(tags[av.AxisIndex], {})[number_key(value)] = name.getDebugName(av.ValueNameID) or ''
+	return {'instances': instances, 'axes': axes, 'labels': labels}
+
+
+# ---------------------------------------------------------------------------
+# Default output name for a selection
+# ---------------------------------------------------------------------------
+
+def _words(text):
+	"""Whitespace-separated words of a style name."""
+	return [w for w in (text or '').split() if w]
+
+
+def range_name(selected, instances, axes, labels=None):
+	"""Default name for a selection of named instances: one range per axis, in the font's own style words.
+
+	Each word in the font's style names is attributed to the one axis that is constant wherever the word
+	appears and varies across the font ("SemiCondensed" -> wdth, "Thin" -> wght). An axis that varies in
+	the selection becomes "low-high" ("SemiCondensed-Normal", "Thin-Light"); an axis that doesn't shows
+	its word once, or nothing when that value has no word. A value with no word (wdth 100 in "Light")
+	takes its STAT name ("Normal"), else a default word, else "<tag><value>". Parts follow the order the
+	words appear in the font's names; words shared by every selected name and owned by no axis (a family prefix,
+	"Italic" in an italic-only font) stay in place before or after them.
+
+	\`\`selected\`\`/\`\`instances\`\`: dicts with 'name' and 'coordinates'; \`\`axes\`\`: dicts with 'tag' and
+	'default'; \`\`labels\`\`: {tag: {number_key(value): name}} from STAT. Mirrored by rangeName() in
+	TypeScript; both are checked against shared/naming-cases.json.
+	"""
+	if not selected:
+		return ''
+	if len(selected) == 1:
+		return selected[0]['name']
+	labels = labels or {}
+	defaults = {a['tag']: a['default'] for a in axes}
+	tags = [a['tag'] for a in axes]
+
+	def coord(inst, tag):
+		return inst['coordinates'].get(tag, defaults.get(tag))
+
+	varying = [t for t in tags if len({coord(i, t) for i in instances}) > 1]
+
+	owner_cache = {}
+
+	def owner(word):
+		if word not in owner_cache:
+			having = [i for i in instances if word in _words(i['name'])]
+			cands = [t for t in varying if len({coord(i, t) for i in having}) == 1] if having else []
+			owner_cache[word] = cands[0] if len(cands) == 1 else None
+		return owner_cache[word]
+
+	def label(tag, value):
+		at = [i for i in instances if coord(i, tag) == value]
+		if not at:
+			return ''
+		common = [w for w in _words(at[0]['name']) if owner(w) == tag and all(w in _words(i['name']) for i in at)]
+		return ' '.join(common)
+
+	def fallback(tag, value):
+		stat = labels.get(tag, {}).get(number_key(value))
+		if stat:
+			return stat
+		return DEFAULT_AXIS_WORDS.get(tag) or f'{tag}{number_key(value)}'
+
+	# Axis order follows the font's own names: positions come from names carrying words for two or more
+	# axes ("SemiCondensed Thin" puts width before weight); a plain "Thin" says nothing about order.
+	def owned_axes(inst):
+		return {owner(w) for w in _words(inst['name'])} - {None}
+
+	rich = [i for i in instances if len(owned_axes(i)) > 1] or instances
+
+	def axis_position(tag):
+		found = [k for i in rich for k, w in enumerate(_words(i['name'])) if owner(w) == tag]
+		return min(found) if found else 10_000
+
+	parts = []
+	for order, tag in enumerate(tags):
+		values = sorted({coord(i, tag) for i in selected})
+		lo, hi = values[0], values[-1]
+		if lo == hi:
+			text = label(tag, lo)
+			if not text:
+				continue
+		else:
+			a = label(tag, lo) or fallback(tag, lo)
+			b = label(tag, hi) or fallback(tag, hi)
+			text = a if a == b else f'{a}-{b}'
+		parts.append((axis_position(tag), order, text))
+	parts.sort()
+
+	first_words = _words(selected[0]['name'])
+	shared = [w for w in first_words if owner(w) is None and all(w in _words(i['name']) for i in selected)]
+	owned_positions = [k for k, w in enumerate(first_words) if owner(w) is not None]
+	first_owned = min(owned_positions) if owned_positions else len(first_words)
+	before = [w for w in shared if first_words.index(w) < first_owned]
+	after = [w for w in shared if first_words.index(w) >= first_owned]
+	name = ' '.join(before + [p[2] for p in parts] + after).strip()
+	return name or f'{selected[0]["name"]}-{selected[-1]["name"]}'
+
+
+# ---------------------------------------------------------------------------
+# Rules applied to the clamped font (after instancing)
+# ---------------------------------------------------------------------------
+
+_WIDTH_CLASSES = ((62.5, 1), (75.0, 2), (87.5, 3), (100.0, 4), (112.5, 5), (125.0, 6), (150.0, 7), (200.0, 8))
+
+
+def location_after(font, pinned):
+	"""The clamped font's default location: remaining fvar defaults plus the values of pinned axes."""
+	loc = {ax.axisTag: ax.defaultValue for ax in font['fvar'].axes} if 'fvar' in font else {}
+	for tag, value in (pinned or {}).items():
+		loc.setdefault(tag, value)
+	return loc
+
+
+def unlink_out_of_range_stat(font, location):
+	"""Turn STAT Format 3 values whose LinkedValue the clamped font can't reach into Format 1 (same name, no link)."""
+	if 'STAT' not in font or not font['STAT'].table.AxisValueArray:
+		return
+	stat = font['STAT'].table
+	tags = [a.AxisTag for a in stat.DesignAxisRecord.Axis]
+	ranges = {ax.axisTag: (ax.minValue, ax.maxValue) for ax in font['fvar'].axes} if 'fvar' in font else {}
+	for av in stat.AxisValueArray.AxisValue:
+		if av.Format != 3 or av.AxisIndex >= len(tags):
+			continue
+		tag = tags[av.AxisIndex]
+		if tag in ranges:
+			lo, hi = ranges[tag]
+			reachable = lo <= av.LinkedValue <= hi
+		elif tag in location:
+			reachable = av.LinkedValue == location[tag]
+		else:
+			continue
+		if not reachable:
+			av.Format = 1
+			del av.LinkedValue
+
+
+def apply_style_bits(font, location, source):
+	"""Set usWeightClass/usWidthClass, fsSelection and macStyle from the clamped font's default location.
+
+	BOLD from weight 700; ITALIC from ital >= 0.5 or slnt < 0 (OBLIQUE as well for a slant without ital);
+	with neither axis in the source, the source's italic/oblique bits are kept. REGULAR only when none of
+	BOLD, ITALIC or OBLIQUE is set. Returns (is_bold, is_italic).
+	"""
+	if 'OS/2' not in font:
+		return False, False
+	os2 = font['OS/2']
+	wght, wdth = location.get('wght'), location.get('wdth')
+	if wght is not None:
+		os2.usWeightClass = max(1, min(1000, int(round(wght))))
+	if wdth is not None:
+		os2.usWidthClass = next((cls for edge, cls in _WIDTH_CLASSES if wdth < edge), 9)
+	if source.get('has_ital_slnt'):
+		ital, slnt = location.get('ital'), location.get('slnt')
+		is_italic = (ital is not None and ital >= 0.5) or (slnt is not None and slnt < 0)
+		is_oblique = slnt is not None and slnt < 0 and not (ital is not None and ital >= 0.5)
+	else:
+		is_italic, is_oblique = source.get('italic', False), source.get('oblique', False)
+	is_bold = os2.usWeightClass >= 700
+	fs = os2.fsSelection & ~(FS_ITALIC | FS_BOLD | FS_REGULAR | FS_OBLIQUE)
+	if is_italic or is_oblique:
+		fs |= FS_ITALIC
+	if is_oblique:
+		fs |= FS_OBLIQUE
+	if is_bold:
+		fs |= FS_BOLD
+	if not (is_bold or is_italic or is_oblique):
+		fs |= FS_REGULAR
+	os2.fsSelection = fs
+	if 'head' in font:
+		mac = font['head'].macStyle & ~(MAC_BOLD | MAC_ITALIC)
+		font['head'].macStyle = mac | (MAC_BOLD if is_bold else 0) | (MAC_ITALIC if (is_italic or is_oblique) else 0)
+	return is_bold, (is_italic or is_oblique)
+
+
+def default_instance_style(font):
+	"""Subfamily name of the named instance at the clamped font's default location, or None."""
+	if 'fvar' not in font:
+		return None
+	defaults = {ax.axisTag: ax.defaultValue for ax in font['fvar'].axes}
+	for inst in font['fvar'].instances:
+		if all(abs(inst.coordinates.get(t, v) - v) < 0.01 for t, v in defaults.items()):
+			return font['name'].getDebugName(inst.subfamilyNameID)
+	return None
+
+
+def apply_names(font, family, style=None, keep_mac=True, version=None):
+	"""Write name IDs 1, 2, 3, 4, 6, 16/17, 25 and the named instances' PostScript names. Run after apply_style_bits.
+
+	\`\`family\`\` is the output name; blank raises ValueError. \`\`style\`\` is the picked instance's name for a
+	single-style output; for a range it defaults to the instance at the new default location. nameID 2 is
+	the RIBBI style matching OS/2; a non-RIBBI style (SemiBold) goes into 16/17, and for a static file
+	into nameID 1 too ("Family SemiBold" + "Regular"), as the OpenType spec describes. A static file's
+	PostScript name includes its style so two pins never collide.
+	"""
+	family = (family or '').strip()
+	if not family:
+		raise ValueError('vf-clamp: the output name is empty')
+	name_table = font['name']
+	existing = {r.nameID for r in name_table.names}
+	static = 'fvar' not in font
+	fs = font['OS/2'].fsSelection if 'OS/2' in font else FS_REGULAR
+	is_bold, is_italic = bool(fs & FS_BOLD), bool(fs & FS_ITALIC)
+	ribbi = ('Bold Italic' if is_italic else 'Bold') if is_bold else ('Italic' if is_italic else 'Regular')
+
+	typo = (style or '').strip() or default_instance_style(font) or ribbi
+	if is_italic and 'Italic' not in typo and 'Oblique' not in typo:
+		typo = 'Italic' if typo == 'Regular' else f'{typo} Italic'
+	core = ' '.join(w for w in typo.split() if w not in ('Italic', 'Oblique'))
+	non_ribbi = core not in ('', 'Regular', 'Bold')
+
+	name1 = family
+	if static and non_ribbi and not family.lower().endswith(core.lower()):
+		name1 = f'{family} {core}'
+	ps_base = family if not static or typo == 'Regular' or family.lower().endswith(typo.lower()) else f'{family} {typo}'
+	ps = ps_name(ps_base)
+	prefix = vf_prefix(ps, family)
+	if version is None:
+		try:
+			version = '%.3f' % font['head'].fontRevision
+		except Exception:
+			version = '1.000'
+
+	updates = {
+		1: name1,
+		2: ribbi,
+		3: f'{version};{ps};{family}',
+		4: full_name(family, typo if static else ribbi),
+		6: ps,
+	}
+	if 16 in existing or 17 in existing or non_ribbi:
+		updates[16] = family
+		updates[17] = typo
+	if 25 in existing:
+		updates[25] = prefix
+	if 'fvar' in font:
+		for inst in font['fvar'].instances:
+			pid = getattr(inst, 'postscriptNameID', 0xFFFF)
+			if pid in (None, 0xFFFF) or pid in updates:
+				continue
+			inst_style = re.sub(r'[^A-Za-z0-9-]', '', (name_table.getDebugName(inst.subfamilyNameID) or '').replace(' ', ''))
+			updates[pid] = f'{prefix}-{inst_style}'[:63]
+
+	english = {0, 0x0409}
+	kept = []
+	written = set()
+	for record in name_table.names:
+		if record.nameID not in updates:
+			kept.append(record)
+			continue
+		if record.platformID in (1, 3) and record.langID not in english:
+			continue  # stale localised name for an ID we're rewriting
+		value = updates[record.nameID]
+		if record.platformID in (0, 3):
+			record.string = value.encode('utf-16-be')
+		elif record.platformID == 1:
+			if not keep_mac:
+				continue
+			try:
+				record.string = value.encode('mac_roman')
+			except (UnicodeEncodeError, LookupError):
+				continue  # drop rather than write '?'
+		kept.append(record)
+		written.add((record.nameID, record.platformID))
+	name_table.names = kept
+	for name_id, value in updates.items():
+		if (name_id, 3) not in written:
+			name_table.setName(value, name_id, 3, 1, 0x0409)
+	return updates
+
+
+def finish(font, family, style, pinned, source, keep_mac=True):
+	"""Everything after instancing, in order: STAT links, style bits, names. Returns the name updates."""
+	location = location_after(font, pinned)
+	unlink_out_of_range_stat(font, location)
+	apply_style_bits(font, location, source)
+	return apply_names(font, family, style, keep_mac=keep_mac)
+`;
+let b = null, A = null, T = null, I = null;
+function C() {
+  return b || (b = f().then(async (t) => {
+    await t.runPythonAsync($);
+  })), b;
 }
-function T(e, a) {
-  const t = a.filter((n) => n.name === e);
-  if (!t.length) throw new Error(`Named instance "${e}" not found in font`);
-  if (t.length > 1) throw new Error(`Named instance "${e}" is ambiguous: ${t.length} instances share that name`);
-  return t[0];
-}
-let S = null, V = null, D = null, N = null;
-async function z() {
-  return S || (S = d().then(
-    (e) => e.runPythonAsync(`
-from fontTools import ttLib
-
-def patch_font_names_fn(file_options):
-    font = ttLib.TTFont(file_options['input-file'])
-    name_table = font['name']
-    family_name  = file_options['family-name']
-    ps_name      = file_options['postscript-name']
-
-    existing_ids = {r.nameID for r in name_table.names}
-
-    # A family name with no ASCII letters gives an empty PostScript name: fall back to the
-    # source PostScript name plus a short hash of the family name (passed in from JS).
-    if not ps_name:
-        source_ps = name_table.getDebugName(6) or 'Font'
-        ps_name = ('%s-%s' % (source_ps[:52], file_options['postscript-suffix']))[:63]
-
-    # nameID 2 must be a RIBBI style that matches OS/2 (already updated): Regular, Italic, Bold or Bold Italic.
-    fs = font['OS/2'].fsSelection if 'OS/2' in font else 0x40
-    is_italic = bool(fs & 0x01)
-    is_bold = bool(fs & 0x20)
-    ribbi = ('Bold Italic' if is_italic else 'Bold') if is_bold else ('Italic' if is_italic else 'Regular')
-
-    # nameID 17 (typographic subfamily): the name of the named instance at the new default, if any.
-    default_style = None
-    if 'fvar' in font:
-        defaults = {ax.axisTag: ax.defaultValue for ax in font['fvar'].axes}
-        for inst in font['fvar'].instances:
-            if all(abs(inst.coordinates.get(t, v) - v) < 0.01 for t, v in defaults.items()):
-                default_style = name_table.getDebugName(inst.subfamilyNameID)
-                break
-
-    # nameID 1 = Family, 4 = Full name, 6 = PostScript name
-    # nameID 2 = Subfamily — reset to 'Regular' so the restricted file does not
-    #            collide with the source font's Subfamily in OS font caches.
-    # nameID 3 = Unique ID — regenerate so it is distinct from the source font.
-    # nameID 16 = Preferred family (update only if present)
-    # nameID 25 = Variations PS Name Prefix (update only if present)
-    #
-    # head.fontRevision is a Fixed value (e.g. 1.000). Fall back to '1.000' if
-    # the head table is unreadable.
-    try:
-        version = '%.3f' % font['head'].fontRevision
-    except Exception:
-        version = '1.000'
-    unique_id = '%s;%s;%s' % (version, ps_name, family_name)
-
-    updates = {
-        1: family_name,
-        2: ribbi,
-        3: unique_id,
-        4: family_name if ribbi == 'Regular' else '%s %s' % (family_name, ribbi),
-        6: ps_name,
-    }
-    if 16 in existing_ids:
-        updates[16] = family_name
-    if 17 in existing_ids and default_style:
-        updates[17] = default_style
-    if 25 in existing_ids:
-        updates[25] = ps_name
-
-    # Named instances' PostScript names must follow the new prefix, e.g. Inter-Regular-Bold-Medium.
-    if 'fvar' in font:
-        for inst in font['fvar'].instances:
-            pid = getattr(inst, 'postscriptNameID', 0xFFFF)
-            if pid in (None, 0xFFFF):
-                continue
-            style = (name_table.getDebugName(inst.subfamilyNameID) or '').replace(' ', '')
-            style = ''.join(c for c in style if c.isascii() and (c.isalnum() or c == '-'))
-            updates[pid] = ('%s-%s' % (ps_name, style))[:63]
-
-    # Rewrite every platform. A Mac (platform 1) record that can't be encoded in Mac Roman is dropped
-    # rather than filled with '?'; Windows and Unicode records always carry the full name.
-    keep = []
-    for record in name_table.names:
-        if record.nameID not in updates:
-            keep.append(record)
-            continue
-        value = updates[record.nameID]
-        if record.platformID in (0, 3):
-            record.string = value.encode('utf-16-be')
-        elif record.platformID == 1:
-            try:
-                record.string = value.encode('mac_roman')
-            except Exception:
-                continue
-        keep.append(record)
-    name_table.names = keep
+async function G() {
+  return A || (A = C().then(() => f()).then(
+    (t) => t.runPythonAsync(`
+import json
+from fontTools.ttLib import TTFont
 
+def vf_clamp_finish(file_options, opts_json):
+    opts = json.loads(opts_json)
+    font = TTFont(file_options['input-file'])
+    finish(font, opts['family'], opts.get('style'), opts.get('pinned') or {}, opts['source'])
     font.save(file_options['output-file'])
 
-patch_font_names_fn
+vf_clamp_finish
 `)
-  )), S;
+  )), A;
 }
-async function W() {
-  return V || (V = d().then(
-    (e) => e.runPythonAsync(`
+async function Q() {
+  return T || (T = C().then(() => f()).then(
+    (t) => t.runPythonAsync(`
 from fontTools.ttLib import TTFont
 from fontTools.varLib import instancer
 import json
@@ -246,16 +547,20 @@ def vf_clamp_instantiate(file_options, axes_json):
         else:
             limits[tag] = float(spec)
 
+    # The style rules need the source's italic bits and which axes were pinned (they leave fvar).
+    source = source_style_info(font)
+    pinned = {tag: value for tag, value in limits.items() if isinstance(value, float)}
     partial = instancer.instantiateVariableFont(font, limits)
     partial.save(file_options['output-file'])
+    return json.dumps({'source': source, 'pinned': pinned})
 
 vf_clamp_instantiate
 `)
-  )), V;
+  )), T;
 }
-async function q() {
-  return D || (D = d().then(
-    (e) => e.runPythonAsync(`
+async function J() {
+  return I || (I = f().then(
+    (t) => t.runPythonAsync(`
 from fontTools.ttLib import TTFont
 
 def vf_clamp_normalize_wght(file_options, new_min_str):
@@ -322,276 +627,135 @@ def vf_clamp_normalize_wght(file_options, new_min_str):
 
 vf_clamp_normalize_wght
 `)
-  )), D;
-}
-async function H() {
-  return N || (N = d().then(
-    (e) => e.runPythonAsync(`
-from fontTools.ttLib import TTFont
-
-def vf_clamp_update_os2(file_options):
-    font = TTFont(file_options['input-file'])
-
-    if 'fvar' not in font:
-        font.save(file_options['output-file'])
-        return
-
-    wght_axis = next((ax for ax in font['fvar'].axes if ax.axisTag == 'wght'), None)
-    if wght_axis is not None:
-        # OS/2.usWeightClass valid range is 1..1000.
-        weight_class = int(round(max(1, min(1000, wght_axis.defaultValue))))
-    elif 'OS/2' in font:
-        # wght was pinned: fontTools has already set usWeightClass to the pinned weight.
-        weight_class = font['OS/2'].usWeightClass
-    else:
-        font.save(file_options['output-file'])
-        return
-
-    if 'OS/2' in font:
-        os2 = font['OS/2']
-        os2.usWeightClass = weight_class
-        # fsSelection: 0x01 ITALIC (kept), 0x20 BOLD, 0x40 REGULAR. REGULAR only when neither ITALIC nor BOLD.
-        fs = os2.fsSelection
-        fs &= ~(0x20 | 0x40)
-        if weight_class >= 700:
-            fs |= 0x20
-        elif not fs & 0x01:
-            fs |= 0x40
-        os2.fsSelection = fs
-
-    if 'head' in font:
-        head = font['head']
-        # macStyle bit 0 = bold.
-        ms = head.macStyle
-        if weight_class >= 700:
-            ms |= 0x01
-        else:
-            ms &= ~0x01
-        head.macStyle = ms
-
-    font.save(file_options['output-file'])
-
-vf_clamp_update_os2
-`)
-  )), N;
-}
-function J(e) {
-  const a = e.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^A-Za-z0-9 -]/g, "").trim().split(/\s+/).join("-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
-  return a.length <= 63 ? a : `${a.slice(0, 56).replace(/-+$/, "")}-${P(e)}`;
-}
-function P(e) {
-  let a = 2166136261;
-  for (const t of e)
-    a ^= t.codePointAt(0), a = Math.imul(a, 16777619) >>> 0;
-  return a.toString(36).padStart(6, "0").slice(-6);
+  )), I;
 }
-async function G(e, a) {
-  if (!a) return e;
-  const t = await d(), n = new x({ pyodide: t }), i = new x({ pyodide: t });
+async function H(t, o) {
+  const a = await f(), n = new p({ pyodide: a }), e = new p({ pyodide: a });
   try {
-    const o = J(a);
-    await n.upload(e);
-    const r = /* @__PURE__ */ new Map([
+    await n.upload(t);
+    const i = /* @__PURE__ */ new Map([
       ["input-file", n.filename],
-      ["output-file", i.filename],
-      ["family-name", a],
-      ["postscript-name", o],
-      ["postscript-suffix", P(a)]
+      ["output-file", e.filename]
     ]);
-    return (await z())(r), i.download();
-  } catch (o) {
-    throw Object.assign(new Error(`vf-clamp: name table patching failed for "${a}"`), { cause: o });
+    return (await G())(i, JSON.stringify(o)), e.download();
+  } catch (i) {
+    throw Object.assign(new Error(`vf-clamp: name table patching failed for "${o.family}"`), { cause: i });
   } finally {
     try {
       n.delete();
     } catch {
     }
     try {
-      i.delete();
+      e.delete();
     } catch {
     }
   }
 }
-function K(e) {
-  return typeof e == "number" ? e : e === null ? null : [e.min, e.max];
+function Z(t) {
+  return typeof t == "number" ? t : t === null ? null : [t.min, t.max];
 }
-async function Z(e, a) {
-  const t = await d(), n = new x({ pyodide: t }), i = new x({ pyodide: t });
+async function K(t, o) {
+  const a = await f(), n = new p({ pyodide: a }), e = new p({ pyodide: a });
   try {
-    await n.upload(e);
-    const o = /* @__PURE__ */ new Map([
+    await n.upload(t);
+    const i = /* @__PURE__ */ new Map([
       ["input-file", n.filename],
-      ["output-file", i.filename]
-    ]);
-    return (await W())(o, JSON.stringify(a)), i.download();
+      ["output-file", e.filename]
+    ]), s = await Q(), d = JSON.parse(s(i, JSON.stringify(o)));
+    return { buffer: e.download(), info: d };
   } finally {
     try {
       n.delete();
     } catch {
     }
     try {
-      i.delete();
+      e.delete();
     } catch {
     }
   }
 }
-async function Q(e) {
-  const a = await d(), t = new x({ pyodide: a }), n = new x({ pyodide: a });
+async function X(t, o) {
+  const a = await f(), n = new p({ pyodide: a }), e = new p({ pyodide: a });
   try {
-    await t.upload(e);
+    await n.upload(t);
     const i = /* @__PURE__ */ new Map([
-      ["input-file", t.filename],
-      ["output-file", n.filename]
-    ]);
-    return (await H())(i), n.download();
-  } catch (i) {
-    throw Object.assign(new Error("vf-clamp: OS/2 and macStyle update failed"), { cause: i });
-  } finally {
-    try {
-      t.delete();
-    } catch {
-    }
-    try {
-      n.delete();
-    } catch {
-    }
-  }
-}
-async function X(e, a) {
-  const t = await d(), n = new x({ pyodide: t }), i = new x({ pyodide: t });
-  try {
-    await n.upload(e);
-    const o = /* @__PURE__ */ new Map([
       ["input-file", n.filename],
-      ["output-file", i.filename]
+      ["output-file", e.filename]
     ]);
-    return (await q())(o, String(a)) === "skipped" && console.warn("vf-clamp: normalizeWeightAxis skipped: the weight default is the axis minimum, so there is no lower range to remap"), i.download();
-  } catch (o) {
-    throw Object.assign(new Error("vf-clamp: wght normalisation failed"), { cause: o });
+    return (await J())(i, String(o)) === "skipped" && console.warn("vf-clamp: normalizeWeightAxis skipped: the weight default is the axis minimum, so there is no lower range to remap"), e.download();
+  } catch (i) {
+    throw Object.assign(new Error("vf-clamp: wght normalisation failed"), { cause: i });
   } finally {
     try {
       n.delete();
     } catch {
     }
     try {
-      i.delete();
+      e.delete();
     } catch {
     }
   }
 }
-function Y(e, a) {
-  const t = {};
-  for (const i of e) {
-    const o = T(i, a);
-    for (const [r, s] of Object.entries(o.coordinates))
-      t[r] ? (t[r].min = Math.min(t[r].min, s), t[r].max = Math.max(t[r].max, s)) : t[r] = { min: s, max: s };
+function Y(t, o) {
+  const a = {};
+  for (const e of t) {
+    const i = F(e, o);
+    for (const [s, d] of Object.entries(i.coordinates))
+      a[s] ? (a[s].min = Math.min(a[s].min, d), a[s].max = Math.max(a[s].max, d)) : a[s] = { min: d, max: d };
   }
   const n = {};
-  for (const [i, { min: o, max: r }] of Object.entries(t))
-    n[i] = o === r ? o : { min: o, max: r };
+  for (const [e, { min: i, max: s }] of Object.entries(a))
+    n[e] = i === s ? i : { min: i, max: s };
   return n;
 }
-function ee(e) {
-  return e.length >= 4 && e[0] === 79 && e[1] === 84 && e[2] === 84 && e[3] === 79;
+function tt(t) {
+  return t.length >= 4 && t[0] === 79 && t[1] === 84 && t[2] === 84 && t[3] === 79;
 }
-async function ae(e, a) {
-  var h, y;
-  if (a.outputs.length === 0) return [];
-  const t = e instanceof ArrayBuffer ? new Uint8Array(e) : e, n = a.format ?? "ttf", { instances: i, axes: o, family: r } = await B(t), s = [];
-  for (const f of a.outputs) {
-    let l = {};
-    if ((h = f.instances) != null && h.length && (l = Y(f.instances, i)), f.axes && (l = { ...l, ...f.axes }), a.strict) {
-      const _ = new Set((f.instances ?? []).map((p) => T(p, i))), w = i.filter((p) => !_.has(p) && o.every((b) => {
-        const F = p.coordinates[b.tag] ?? b.default, v = l[b.tag];
-        return v == null ? !0 : typeof v == "number" ? F === v : F >= v.min && F <= v.max;
-      })).map((p) => p.name);
-      if (w.length)
-        throw new Error(`vf-clamp: output "${f.name || (f.instances ?? []).join(", ") || "axes-only"}" would include unselected instances (${w.join(", ")}); use planOutputs() to split the selection`);
+async function at(t, o) {
+  var N, V;
+  if (o.outputs.length === 0) return [];
+  const a = t instanceof ArrayBuffer ? new Uint8Array(t) : t, n = o.format ?? "ttf", { instances: e, axes: i, family: s, labels: d } = await z(a), S = [];
+  for (const m of o.outputs) {
+    let h = {};
+    if ((N = m.instances) != null && N.length && (h = Y(m.instances, e)), m.axes && (h = { ...h, ...m.axes }), o.strict) {
+      const l = new Set((m.instances ?? []).map((r) => F(r, e))), u = e.filter((r) => !l.has(r) && i.every((_) => {
+        const w = r.coordinates[_.tag] ?? _.default, g = h[_.tag];
+        return g == null ? !0 : typeof g == "number" ? w === g : w >= g.min && w <= g.max;
+      })).map((r) => r.name);
+      if (u.length)
+        throw new Error(`vf-clamp: output "${m.name || (m.instances ?? []).join(", ") || "axes-only"}" would include unselected instances (${u.join(", ")}); use planOutputs() to split the selection`);
     }
-    for (const _ of o) {
-      const w = l[_.tag];
-      if (w != null && typeof w == "object") {
-        const p = w;
-        if (_.default < p.min || _.default > p.max) {
-          const b = Math.max(p.min, Math.min(p.max, _.default));
+    for (const l of i) {
+      const u = h[l.tag];
+      if (u != null && typeof u == "object") {
+        const r = u;
+        if (l.default < r.min || l.default > r.max) {
+          const _ = Math.max(r.min, Math.min(r.max, l.default));
           console.warn(
-            `vf-clamp: axis "${_.tag}" default (${_.default}) is outside restricted range [${p.min}, ${p.max}] — will be clamped to ${b}`
+            `vf-clamp: axis "${l.tag}" default (${l.default}) is outside restricted range [${r.min}, ${r.max}] — will be clamped to ${_}`
           );
         }
       }
     }
-    const c = {};
-    for (const [_, w] of Object.entries(l))
-      w !== null && (c[_] = K(w));
-    const u = (y = f.instances) != null && y.length ? f.instances.length === 1 ? f.instances[0] : `${f.instances[0]}-${f.instances[f.instances.length - 1]}` : "Clamped", g = f.name || (r ? `${r} ${u}` : u);
-    let m = await Z(t, c);
-    if (n === "otf" && !ee(m))
+    const D = {};
+    for (const [l, u] of Object.entries(h))
+      u !== null && (D[l] = Z(u));
+    const x = (m.instances ?? []).map((l) => F(l, e)), k = x.length ? E(x, e, i, d ?? {}) : "Clamped", L = ((V = m.name) == null ? void 0 : V.trim()) || (s ? `${s} ${k}` : k), { buffer: B, info: R } = await K(a, D);
+    let c = B;
+    if (n === "otf" && !tt(c))
       throw new Error("vf-clamp: format 'otf' needs a CFF/CFF2 source font; this font has TrueType outlines — use 'ttf'");
-    a.normalizeWeightAxis && (m = await X(m, 100)), m = await Q(m), m = await G(m, g), n === "woff2" ? m = await C(m) : n === "woff" && (m = await k(m)), s.push({ name: g, buffer: m, format: n });
-  }
-  return s;
-}
-function O(e, a) {
-  const t = {};
-  for (const n of a) {
-    const i = e.map((o) => o.coordinates[n.tag] ?? n.default);
-    t[n.tag] = { min: Math.min(...i), max: Math.max(...i) };
+    o.normalizeWeightAxis && (c = await X(c, 100)), c = await H(c, { family: L, style: x.length === 1 ? x[0].name : null, pinned: R.pinned, source: R.source }), n === "woff2" ? c = await q(c) : n === "woff" && (c = await U(c)), S.push({ name: L, buffer: c, format: n });
   }
-  return t;
-}
-function j(e, a, t, n) {
-  return a.filter((i) => t.has(i) ? !1 : n.every((o) => {
-    const r = i.coordinates[o.tag] ?? o.default, s = e[o.tag];
-    return !s || r >= s.min && r <= s.max;
-  }));
-}
-function te(e) {
-  return e.reduce((a, t) => !a || t.maximum - t.minimum > a.maximum - a.minimum ? t : a, void 0);
-}
-function ie(e, a, t) {
-  const { axes: n, instances: i } = e, o = [...new Set(a)].map((l) => T(l, i));
-  if (!o.length) return [];
-  const r = new Set(o);
-  let s;
-  if (!j(O(o, n), i, r, n).length)
-    s = [o];
-  else {
-    s = o.map((c) => [c]);
-    let l = !0;
-    for (; l; ) {
-      l = !1;
-      e: for (let c = 0; c < s.length; c++)
-        for (let u = c + 1; u < s.length; u++) {
-          const g = [...s[c], ...s[u]];
-          if (!j(O(g, n), i, r, n).length) {
-            s[c] = g, s.splice(u, 1), l = !0;
-            break e;
-          }
-        }
-    }
-  }
-  const h = te(n), y = h ? [h, ...n.filter((l) => l.tag !== h.tag)] : n, f = (l, c) => {
-    for (const u of y) {
-      const g = (l.coordinates[u.tag] ?? u.default) - (c.coordinates[u.tag] ?? u.default);
-      if (g) return g;
-    }
-    return 0;
-  };
-  return s = s.map((l) => [...l].sort(f)).sort((l, c) => f(l[0], c[0])), s.map((l) => {
-    const c = l[0], u = l[l.length - 1], g = l.length === 1 ? c.name : U(c.name, u.name);
-    return { name: t ? `${t} ${g}` : g, instances: l.map((m) => m.name) };
-  });
-}
-function oe(e, a) {
-  const t = a.map((n) => T(n, e.instances));
-  return t.length ? j(O(t, e.axes), e.instances, new Set(t), e.axes).map((n) => n.name) : [];
+  return S;
 }
 export {
-  ae as clampFont,
-  U as compactName,
-  k as convertToWoff,
-  C as convertToWoff2,
-  B as getInstances,
-  ie as planOutputs,
-  oe as unboughtInstances
+  at as clampFont,
+  st as compactName,
+  U as convertToWoff,
+  q as convertToWoff2,
+  z as getInstances,
+  rt as numberKey,
+  lt as planOutputs,
+  E as rangeName,
+  ft as unboughtInstances
 };