@overpunch/vf-clamp 2.2.0 → 2.4.0

package/dist/index.js

@@ -1,8 +1,10 @@
 import { createRequire as j } from "node:module";
-const R = j(import.meta.url), { preparePyodide: d, PyodideFile: x } = R("@web-alchemy/fonttools/src/pyodide.js");
-let T = null;
+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 T || (T = d().then(
+  return y || (y = f().then(
     (t) => t.runPythonAsync(`
 from fontTools.ttLib import TTFont
 
@@ -13,38 +15,38 @@ def vf_convert_flavor(file_options):
 
 vf_convert_flavor
 `)
-  )), T;
+  )), y;
 }
-async function P(t, o) {
-  const a = await d(), e = new x({ pyodide: a }), n = new x({ pyodide: a });
+async function O(t, o) {
+  const a = await f(), n = new p({ pyodide: a }), e = new p({ pyodide: a });
   try {
-    await e.upload(t);
+    await n.upload(t);
     const i = /* @__PURE__ */ new Map([
-      ["input-file", e.filename],
-      ["output-file", n.filename],
+      ["input-file", n.filename],
+      ["output-file", e.filename],
       ["flavor", o]
     ]);
-    return (await M())(i), n.download();
+    return (await M())(i), e.download();
   } finally {
     try {
-      e.delete();
+      n.delete();
     } catch {
     }
     try {
-      n.delete();
+      e.delete();
     } catch {
     }
   }
 }
-async function L(t) {
-  return P(t, "woff");
+async function U(t) {
+  return O(t, "woff");
 }
-async function $(t) {
-  return P(t, "woff2");
+async function q(t) {
+  return O(t, "woff2");
 }
-let b = null;
-async function k() {
-  return b || (b = d().then(
+let v = null;
+async function W() {
+  return v || (v = f().then(
     (t) => t.runPythonAsync(`
 import json
 from fontTools.ttLib import TTFont
@@ -52,8 +54,9 @@ from fontTools.ttLib import TTFont
 def get_instances_fn(input_file):
     font = TTFont(input_file)
 
+    family = font['name'].getDebugName(16) or font['name'].getDebugName(1) or ''
     if 'fvar' not in font:
-        return json.dumps({'axes': [], 'instances': []})
+        return json.dumps({'axes': [], 'instances': [], 'family': family})
 
     fvar = font['fvar']
     name_table = font['name']
@@ -77,86 +80,442 @@ def get_instances_fn(input_file):
         for i, inst in enumerate(fvar.instances)
     ]
 
-    return json.dumps({'axes': axes, 'instances': instances})
+    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
 `)
-  )), b;
+  )), v;
 }
-async function E(t) {
-  const o = await d(), a = t instanceof ArrayBuffer ? new Uint8Array(t) : t, e = new x({ pyodide: o });
+async function z(t) {
+  const o = await f(), a = t instanceof ArrayBuffer ? new Uint8Array(t) : t, n = new p({ pyodide: o });
   try {
-    await e.upload(a);
-    const i = (await k())(e.filename);
+    await n.upload(a);
+    const i = (await W())(n.filename);
     return JSON.parse(i);
   } finally {
     try {
-      e.delete();
+      n.delete();
     } catch {
     }
   }
 }
-let F = null, S = null, V = null, I = null, D = null;
-async function U() {
-  return F || (F = d().then(
+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;
+}
+async function G() {
+  return A || (A = C().then(() => f()).then(
     (t) => t.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}
-
-    # 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: 'Regular',
-        3: unique_id,
-        4: family_name,
-        6: ps_name,
-    }
-    if 16 in existing_ids:
-        updates[16] = family_name
-    if 25 in existing_ids:
-        updates[25] = ps_name
-
-    for record in name_table.names:
-        if record.nameID not in updates:
-            continue
-        value = updates[record.nameID]
-        if record.platformID == 3:
-            record.string = value.encode('utf-16-be')
-        elif record.platformID == 1:
-            try:
-                record.string = value.encode('mac_roman')
-            except Exception:
-                record.string = value.encode('ascii', errors='replace')
+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
 `)
-  )), F;
+  )), A;
 }
-async function C() {
-  return S || (S = d().then(
+async function Q() {
+  return T || (T = C().then(() => f()).then(
     (t) => t.runPythonAsync(`
 from fontTools.ttLib import TTFont
 from fontTools.varLib import instancer
@@ -166,6 +525,12 @@ def vf_clamp_instantiate(file_options, axes_json):
     font = TTFont(file_options['input-file'])
     axes_spec = json.loads(axes_json)
 
+    # The bundled fontTools can't restrict avar version 2 or VARC fonts correctly: refuse instead of mis-cutting.
+    if 'avar' in font and getattr(font['avar'], 'majorVersion', 1) >= 2:
+        raise ValueError('vf-clamp: avar version 2 fonts are not supported yet')
+    if 'VARC' in font:
+        raise ValueError('vf-clamp: fonts with a VARC table are not supported yet')
+
     limits = {}
     axes_by_tag = {ax.axisTag: ax for ax in font['fvar'].axes}
 
@@ -182,15 +547,19 @@ 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
 `)
-  )), S;
+  )), T;
 }
-async function z() {
-  return V || (V = d().then(
+async function J() {
+  return I || (I = f().then(
     (t) => t.runPythonAsync(`
 from fontTools.ttLib import TTFont
 
@@ -211,6 +580,10 @@ def vf_clamp_normalize_wght(file_options, new_min_str):
 
     old_min = wght_axis.minValue
     default = wght_axis.defaultValue
+    # With the default at the minimum there is no below-default range to stretch; leave the font as is.
+    if default <= old_min:
+        font.save(file_options['output-file'])
+        return 'skipped'
     scale = (default - new_min) / (default - old_min)
 
     def remap(v):
@@ -244,214 +617,55 @@ def vf_clamp_normalize_wght(file_options, new_min_str):
                     av.NominalValue = remap(av.NominalValue)
                     av.RangeMinValue = remap(av.RangeMinValue)
                     av.RangeMaxValue = remap(av.RangeMaxValue)
+                elif fmt == 4:
+                    for rec in getattr(av, 'AxisValueRecord', []) or []:
+                        if rec.AxisIndex == wght_idx:
+                            rec.Value = remap(rec.Value)
 
     font.save(file_options['output-file'])
+    return 'done'
 
 vf_clamp_normalize_wght
-`)
-  )), V;
-}
-async function B() {
-  return I || (I = d().then(
-    (t) => t.runPythonAsync(`
-from fontTools.ttLib import TTFont
-
-def vf_clamp_prune_stat(file_options):
-    font = TTFont(file_options['input-file'])
-
-    if 'STAT' not in font or 'fvar' not in font:
-        font.save(file_options['output-file'])
-        return
-
-    stat = font['STAT'].table
-    if not getattr(stat, 'DesignAxisRecord', None) or not stat.DesignAxisRecord.Axis:
-        font.save(file_options['output-file'])
-        return
-
-    fvar_tags = {ax.axisTag for ax in font['fvar'].axes}
-    stat_axes = list(stat.DesignAxisRecord.Axis)
-
-    # Map old STAT AxisIndex -> new index after pruning STAT axes that vanish from fvar.
-    surviving_indices = [i for i, ax in enumerate(stat_axes) if ax.AxisTag in fvar_tags]
-    if len(surviving_indices) == len(stat_axes):
-        # No axes removed — nothing to prune.
-        font.save(file_options['output-file'])
-        return
-    old_to_new = {old: new for new, old in enumerate(surviving_indices)}
-
-    # Rewrite the DesignAxisRecord.Axis list to surviving axes only.
-    stat.DesignAxisRecord.Axis = [stat_axes[i] for i in surviving_indices]
-    if hasattr(stat, 'DesignAxisCount'):
-        stat.DesignAxisCount = len(stat.DesignAxisRecord.Axis)
-
-    # Prune AxisValueArray entries that reference removed axes.
-    if stat.AxisValueArray and stat.AxisValueArray.AxisValue:
-        kept = []
-        for av in stat.AxisValueArray.AxisValue:
-            fmt = av.Format
-            if fmt in (1, 2, 3):
-                if av.AxisIndex not in old_to_new:
-                    continue  # references a removed axis
-                av.AxisIndex = old_to_new[av.AxisIndex]
-                kept.append(av)
-            elif fmt == 4:
-                inner = list(getattr(av, 'AxisValueRecord', []) or [])
-                if any(rec.AxisIndex not in old_to_new for rec in inner):
-                    continue  # whole record dies if any inner ref is dead
-                for rec in inner:
-                    rec.AxisIndex = old_to_new[rec.AxisIndex]
-                kept.append(av)
-            else:
-                # Unknown format — keep as-is to be safe.
-                kept.append(av)
-        stat.AxisValueArray.AxisValue = kept
-        if hasattr(stat, 'AxisValueCount'):
-            stat.AxisValueCount = len(kept)
-
-    font.save(file_options['output-file'])
-
-vf_clamp_prune_stat
 `)
   )), I;
 }
-async function W() {
-  return D || (D = d().then(
-    (t) => t.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 None:
-        font.save(file_options['output-file'])
-        return
-
-    new_default = wght_axis.defaultValue
-    # OS/2.usWeightClass valid range is 1..1000.
-    weight_class = int(round(max(1, min(1000, new_default))))
-
-    if 'OS/2' in font:
-        os2 = font['OS/2']
-        os2.usWeightClass = weight_class
-        # fsSelection bits: 0x20 = BOLD, 0x40 = REGULAR.
-        # Mirror the convention: REGULAR when usWeightClass < 600, BOLD when >= 700.
-        fs = os2.fsSelection
-        fs &= ~(0x20 | 0x40)
-        if weight_class >= 700:
-            fs |= 0x20  # BOLD
-        elif weight_class < 600:
-            fs |= 0x40  # REGULAR
-        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
-`)
-  )), D;
-}
-function q(t) {
-  return t.replace(/[^A-Za-z0-9 -]/g, "").trim().split(/\s+/).join("-").replace(/^-+|-+$/g, "").slice(0, 63);
-}
-async function G(t, o) {
-  if (!o) return t;
-  const a = await d(), e = new x({ pyodide: a }), n = new x({ pyodide: a });
+async function H(t, o) {
+  const a = await f(), n = new p({ pyodide: a }), e = new p({ pyodide: a });
   try {
-    const i = q(o);
-    await e.upload(t);
-    const s = /* @__PURE__ */ new Map([
-      ["input-file", e.filename],
-      ["output-file", n.filename],
-      ["family-name", o],
-      ["postscript-name", i]
+    await n.upload(t);
+    const i = /* @__PURE__ */ new Map([
+      ["input-file", n.filename],
+      ["output-file", e.filename]
     ]);
-    return (await U())(s), n.download();
+    return (await G())(i, JSON.stringify(o)), e.download();
   } catch (i) {
-    throw Object.assign(new Error(`vf-clamp: name table patching failed for "${o}"`), { cause: i });
+    throw Object.assign(new Error(`vf-clamp: name table patching failed for "${o.family}"`), { cause: i });
   } finally {
-    try {
-      e.delete();
-    } catch {
-    }
     try {
       n.delete();
     } catch {
     }
-  }
-}
-function H(t) {
-  return typeof t == "number" ? t : t === null ? null : [t.min, t.max];
-}
-async function J(t, o) {
-  const a = await d(), e = new x({ pyodide: a }), n = new x({ pyodide: a });
-  try {
-    await e.upload(t);
-    const i = /* @__PURE__ */ new Map([
-      ["input-file", e.filename],
-      ["output-file", n.filename]
-    ]);
-    return (await C())(i, JSON.stringify(o)), n.download();
-  } finally {
     try {
       e.delete();
     } catch {
     }
-    try {
-      n.delete();
-    } catch {
-    }
   }
 }
-async function Z(t) {
-  const o = await d(), a = new x({ pyodide: o }), e = new x({ pyodide: o });
-  try {
-    await a.upload(t);
-    const n = /* @__PURE__ */ new Map([
-      ["input-file", a.filename],
-      ["output-file", e.filename]
-    ]);
-    return (await B())(n), e.download();
-  } catch (n) {
-    throw Object.assign(new Error("vf-clamp: STAT pruning failed"), { cause: n });
-  } finally {
-    try {
-      a.delete();
-    } catch {
-    }
-    try {
-      e.delete();
-    } catch {
-    }
-  }
+function Z(t) {
+  return typeof t == "number" ? t : t === null ? null : [t.min, t.max];
 }
-async function K(t) {
-  const o = await d(), a = new x({ pyodide: o }), e = new x({ pyodide: o });
+async function K(t, o) {
+  const a = await f(), n = new p({ pyodide: a }), e = new p({ pyodide: a });
   try {
-    await a.upload(t);
-    const n = /* @__PURE__ */ new Map([
-      ["input-file", a.filename],
+    await n.upload(t);
+    const i = /* @__PURE__ */ new Map([
+      ["input-file", n.filename],
       ["output-file", e.filename]
-    ]);
-    return (await W())(n), e.download();
-  } catch (n) {
-    throw Object.assign(new Error("vf-clamp: OS/2 and macStyle update failed"), { cause: n });
+    ]), s = await Q(), d = JSON.parse(s(i, JSON.stringify(o)));
+    return { buffer: e.download(), info: d };
   } finally {
     try {
-      a.delete();
+      n.delete();
     } catch {
     }
     try {
@@ -460,159 +674,88 @@ async function K(t) {
     }
   }
 }
-async function Q(t, o) {
-  const a = await d(), e = 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 e.upload(t);
+    await n.upload(t);
     const i = /* @__PURE__ */ new Map([
-      ["input-file", e.filename],
-      ["output-file", n.filename]
+      ["input-file", n.filename],
+      ["output-file", e.filename]
     ]);
-    return (await z())(i, String(o)), n.download();
+    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 {
-      e.delete();
+      n.delete();
     } catch {
     }
     try {
-      n.delete();
+      e.delete();
     } catch {
     }
   }
 }
-function X(t, o) {
-  const a = new Map(o.map((i) => [i.name, i])), e = {};
-  for (const i of t) {
-    const s = a.get(i);
-    if (!s) throw new Error(`Named instance "${i}" not found in font`);
-    for (const [f, c] of Object.entries(s.coordinates))
-      e[f] ? (e[f].min = Math.min(e[f].min, c), e[f].max = Math.max(e[f].max, c)) : e[f] = { min: c, max: c };
+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: s, max: f }] of Object.entries(e))
-    n[i] = s === f ? s : { min: s, max: f };
+  for (const [e, { min: i, max: s }] of Object.entries(a))
+    n[e] = i === s ? i : { min: i, max: s };
   return n;
 }
-function Y(t) {
+function tt(t) {
   return t.length >= 4 && t[0] === 79 && t[1] === 84 && t[2] === 84 && t[3] === 79;
 }
 async function at(t, o) {
-  var f, c, w;
+  var N, V;
   if (o.outputs.length === 0) return [];
-  const a = t instanceof ArrayBuffer ? new Uint8Array(t) : t, e = o.format ?? "ttf", { instances: n, axes: i } = await E(a), s = [];
+  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 _ = {};
-    if ((f = m.instances) != null && f.length && (_ = X(m.instances, n)), m.axes && (_ = { ..._, ...m.axes }), o.strict && ((c = m.instances) != null && c.length)) {
-      const p = new Set(m.instances), g = n.filter((h) => !p.has(h.name) && i.every((y) => {
-        const A = h.coordinates[y.tag] ?? y.default, v = _[y.tag];
-        return v == null ? !0 : typeof v == "number" ? A === v : A >= v.min && A <= v.max;
-      })).map((h) => h.name);
-      if (g.length)
-        throw new Error(`vf-clamp: output "${m.name || m.instances.join(", ")}" would include unselected instances (${g.join(", ")}); use planOutputs() to split the selection`);
+    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 p of i) {
-      const g = _[p.tag];
-      if (g != null && typeof g == "object") {
-        const h = g;
-        if (p.default < h.min || p.default > h.max) {
-          const y = Math.max(h.min, Math.min(h.max, p.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 "${p.tag}" default (${p.default}) is outside restricted range [${h.min}, ${h.max}] — will be clamped to ${y}`
+            `vf-clamp: axis "${l.tag}" default (${l.default}) is outside restricted range [${r.min}, ${r.max}] — will be clamped to ${_}`
           );
         }
       }
     }
-    const r = {};
-    for (const [p, g] of Object.entries(_))
-      g !== null && (r[p] = H(g));
-    const u = m.name || ((w = m.instances) != null && w.length ? m.instances.length === 1 ? m.instances[0] : `${m.instances[0]}-${m.instances[m.instances.length - 1]}` : "output");
-    let l = await J(a, r);
-    if (e === "otf" && !Y(l))
+    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'");
-    l = await Z(l), o.normalizeWeightAxis && (l = await Q(l, 100)), l = await K(l), l = await G(l, u), e === "woff2" ? l = await $(l) : e === "woff" && (l = await L(l)), s.push({ name: u, buffer: l, format: e });
-  }
-  return s;
-}
-function tt(t, o) {
-  if (t === o) return t;
-  const a = t.split(" "), e = o.split(" ");
-  let n = 0;
-  for (; n < a.length && n < e.length && a[n] === e[n]; )
-    n++;
-  let i = 0;
-  for (; i < a.length - n && i < e.length - n && a[a.length - 1 - i] === e[e.length - 1 - i]; )
-    i++;
-  const s = a.slice(0, n).join(" "), f = a.slice(n, a.length - (i || 0)).join(" "), c = e.slice(n, e.length - (i || 0)).join(" "), w = i > 0 ? a.slice(a.length - i).join(" ") : "", m = f && c ? `${f}-${c}` : f || c;
-  return [s, m, w].filter(Boolean).join(" ");
-}
-function O(t, o) {
-  const a = {};
-  for (const e of o) {
-    const n = t.map((i) => i.coordinates[e.tag] ?? e.default);
-    a[e.tag] = { min: Math.min(...n), max: Math.max(...n) };
+    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 a;
-}
-function N(t, o, a, e) {
-  return o.filter((n) => a.has(n.name) ? !1 : e.every((i) => {
-    const s = n.coordinates[i.tag] ?? i.default, f = t[i.tag];
-    return !f || s >= f.min && s <= f.max;
-  }));
-}
-function et(t) {
-  return t.reduce((o, a) => !o || a.maximum - a.minimum > o.maximum - o.minimum ? a : o, void 0);
-}
-function it(t, o, a) {
-  const { axes: e, instances: n } = t, i = new Map(n.map((r) => [r.name, r])), s = [];
-  for (const r of new Set(o)) {
-    const u = i.get(r);
-    if (!u) throw new Error(`Named instance "${r}" not found in font`);
-    s.push(u);
-  }
-  if (!s.length) return [];
-  const f = new Set(s.map((r) => r.name));
-  let c;
-  if (!N(O(s, e), n, f, e).length)
-    c = [s];
-  else {
-    c = s.map((u) => [u]);
-    let r = !0;
-    for (; r; ) {
-      r = !1;
-      t: for (let u = 0; u < c.length; u++)
-        for (let l = u + 1; l < c.length; l++) {
-          const p = [...c[u], ...c[l]];
-          if (!N(O(p, e), n, f, e).length) {
-            c[u] = p, c.splice(l, 1), r = !0;
-            break t;
-          }
-        }
-    }
-  }
-  const w = et(e), m = w ? [w, ...e.filter((r) => r.tag !== w.tag)] : e, _ = (r, u) => {
-    for (const l of m) {
-      const p = (r.coordinates[l.tag] ?? l.default) - (u.coordinates[l.tag] ?? l.default);
-      if (p) return p;
-    }
-    return 0;
-  };
-  return c = c.map((r) => [...r].sort(_)).sort((r, u) => _(r[0], u[0])), c.map((r) => {
-    const u = r[0], l = r[r.length - 1], p = r.length === 1 ? u.name : tt(u.name, l.name);
-    return { name: a ? `${a} ${p}` : p, instances: r.map((g) => g.name) };
-  });
-}
-function ot(t, o) {
-  const a = new Map(t.instances.map((n) => [n.name, n])), e = o.map((n) => a.get(n)).filter((n) => !!n);
-  return e.length ? N(O(e, t.axes), t.instances, new Set(o), t.axes).map((n) => n.name) : [];
+  return S;
 }
 export {
   at as clampFont,
-  tt as compactName,
-  L as convertToWoff,
-  $ as convertToWoff2,
-  E as getInstances,
-  it as planOutputs,
-  ot as unboughtInstances
+  st as compactName,
+  U as convertToWoff,
+  q as convertToWoff2,
+  z as getInstances,
+  rt as numberKey,
+  lt as planOutputs,
+  E as rangeName,
+  ft as unboughtInstances
 };