@overpunch/vf-clamp 2.2.0 → 2.4.0

package/dist/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const $=require("node:module");var T=typeof document<"u"?document.currentScript:null;const k=$.createRequire(typeof document>"u"?require("url").pathToFileURL(__filename).href:T&&T.tagName.toUpperCase()==="SCRIPT"&&T.src||new URL("index.cjs",document.baseURI).href),{preparePyodide:d,PyodideFile:x}=k("@web-alchemy/fonttools/src/pyodide.js");let b=null;async function C(){return b||(b=d().then(t=>t.runPythonAsync(`
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const M=require("node:module"),p=require("./naming.cjs");var v=typeof document<"u"?document.currentScript:null;const q=M.createRequire(typeof document>"u"?require("url").pathToFileURL(__filename).href:v&&v.tagName.toUpperCase()==="SCRIPT"&&v.src||new URL("index.cjs",document.baseURI).href),{preparePyodide:f,PyodideFile:h}=q("@web-alchemy/fonttools/src/pyodide.js");let b=null;async function W(){return b||(b=f().then(t=>t.runPythonAsync(`
 from fontTools.ttLib import TTFont
 
 def vf_convert_flavor(file_options):
@@ -7,15 +7,16 @@ def vf_convert_flavor(file_options):
     font.save(file_options['output-file'])
 
 vf_convert_flavor
-`))),b}async function P(t,o){const a=await d(),e=new x({pyodide:a}),n=new x({pyodide:a});try{await e.upload(t);const i=new Map([["input-file",e.filename],["output-file",n.filename],["flavor",o]]);return(await C())(i),n.download()}finally{try{e.delete()}catch{}try{n.delete()}catch{}}}async function j(t){return P(t,"woff")}async function M(t){return P(t,"woff2")}let F=null;async function E(){return F||(F=d().then(t=>t.runPythonAsync(`
+`))),b}async function C(t,o){const a=await f(),n=new h({pyodide:a}),e=new h({pyodide:a});try{await n.upload(t);const i=new Map([["input-file",n.filename],["output-file",e.filename],["flavor",o]]);return(await W())(i),e.download()}finally{try{n.delete()}catch{}try{e.delete()}catch{}}}async function B(t){return C(t,"woff")}async function j(t){return C(t,"woff2")}let T=null;async function z(){return T||(T=f().then(t=>t.runPythonAsync(`
 import json
 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']
@@ -39,63 +40,413 @@ 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 ''
 
-get_instances_fn
-`))),F}async function L(t){const o=await d(),a=t instanceof ArrayBuffer?new Uint8Array(t):t,e=new x({pyodide:o});try{await e.upload(a);const i=(await E())(e.filename);return JSON.parse(i)}finally{try{e.delete()}catch{}}}let S=null,I=null,V=null,D=null,O=null;async function z(){return S||(S=d().then(t=>t.runPythonAsync(`
-from fontTools import ttLib
+    return json.dumps({'axes': axes, 'instances': instances, 'family': family, 'labels': labels})
 
-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')
+get_instances_fn
+`))),T}async function E(t){const o=await f(),a=t instanceof ArrayBuffer?new Uint8Array(t):t,n=new h({pyodide:o});try{await n.upload(a);const i=(await z())(n.filename);return JSON.parse(i)}finally{try{n.delete()}catch{}}}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 A=null,I=null,F=null,S=null;function P(){return A||(A=f().then(async t=>{await t.runPythonAsync($)})),A}async function G(){return I||(I=P().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
-`))),S}async function W(){return I||(I=d().then(t=>t.runPythonAsync(`
+vf_clamp_finish
+`))),I}async function Q(){return F||(F=P().then(()=>f()).then(t=>t.runPythonAsync(`
 from fontTools.ttLib import TTFont
 from fontTools.varLib import instancer
 import json
@@ -104,6 +455,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}
 
@@ -120,11 +477,15 @@ 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
-`))),I}async function q(){return V||(V=d().then(t=>t.runPythonAsync(`
+`))),F}async function J(){return S||(S=f().then(t=>t.runPythonAsync(`
 from fontTools.ttLib import TTFont
 
 def vf_clamp_normalize_wght(file_options, new_min_str):
@@ -144,6 +505,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):
@@ -177,111 +542,13 @@ 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 D||(D=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
-`))),D}async function G(){return O||(O=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
-`))),O}function H(t){return t.replace(/[^A-Za-z0-9 -]/g,"").trim().split(/\s+/).join("-").replace(/^-+|-+$/g,"").slice(0,63)}async function J(t,o){if(!o)return t;const a=await d(),e=new x({pyodide:a}),n=new x({pyodide:a});try{const i=H(o);await e.upload(t);const s=new Map([["input-file",e.filename],["output-file",n.filename],["family-name",o],["postscript-name",i]]);return(await z())(s),n.download()}catch(i){throw Object.assign(new Error(`vf-clamp: name table patching failed for "${o}"`),{cause:i})}finally{try{e.delete()}catch{}try{n.delete()}catch{}}}function Z(t){return typeof t=="number"?t:t===null?null:[t.min,t.max]}async function K(t,o){const a=await d(),e=new x({pyodide:a}),n=new x({pyodide:a});try{await e.upload(t);const i=new Map([["input-file",e.filename],["output-file",n.filename]]);return(await W())(i,JSON.stringify(o)),n.download()}finally{try{e.delete()}catch{}try{n.delete()}catch{}}}async function Q(t){const o=await d(),a=new x({pyodide:o}),e=new x({pyodide:o});try{await a.upload(t);const n=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{}}}async function X(t){const o=await d(),a=new x({pyodide:o}),e=new x({pyodide:o});try{await a.upload(t);const n=new Map([["input-file",a.filename],["output-file",e.filename]]);return(await G())(n),e.download()}catch(n){throw Object.assign(new Error("vf-clamp: OS/2 and macStyle update failed"),{cause:n})}finally{try{a.delete()}catch{}try{e.delete()}catch{}}}async function Y(t,o){const a=await d(),e=new x({pyodide:a}),n=new x({pyodide:a});try{await e.upload(t);const i=new Map([["input-file",e.filename],["output-file",n.filename]]);return(await q())(i,String(o)),n.download()}catch(i){throw Object.assign(new Error("vf-clamp: wght normalisation failed"),{cause:i})}finally{try{e.delete()}catch{}try{n.delete()}catch{}}}function tt(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}}const n={};for(const[i,{min:s,max:f}]of Object.entries(e))n[i]=s===f?s:{min:s,max:f};return n}function et(t){return t.length>=4&&t[0]===79&&t[1]===84&&t[2]===84&&t[3]===79}async function nt(t,o){var f,c,w;if(o.outputs.length===0)return[];const a=t instanceof ArrayBuffer?new Uint8Array(t):t,e=o.format??"ttf",{instances:n,axes:i}=await L(a),s=[];for(const m of o.outputs){let _={};if((f=m.instances)!=null&&f.length&&(_=tt(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`)}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));console.warn(`vf-clamp: axis "${p.tag}" default (${p.default}) is outside restricted range [${h.min}, ${h.max}] — will be clamped to ${y}`)}}}const r={};for(const[p,g]of Object.entries(_))g!==null&&(r[p]=Z(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 K(a,r);if(e==="otf"&&!et(l))throw new Error("vf-clamp: format 'otf' needs a CFF/CFF2 source font; this font has TrueType outlines — use 'ttf'");l=await Q(l),o.normalizeWeightAxis&&(l=await Y(l,100)),l=await X(l),l=await J(l,u),e==="woff2"?l=await M(l):e==="woff"&&(l=await j(l)),s.push({name:u,buffer:l,format:e})}return s}function U(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 R(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)}}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 at(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(R(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(R(p,e),n,f,e).length){c[u]=p,c.splice(l,1),r=!0;break t}}}}const w=at(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:U(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(R(e,t.axes),t.instances,new Set(o),t.axes).map(n=>n.name):[]}exports.clampFont=nt;exports.compactName=U;exports.convertToWoff=j;exports.convertToWoff2=M;exports.getInstances=L;exports.planOutputs=it;exports.unboughtInstances=ot;
+`))),S}async function H(t,o){const a=await f(),n=new h({pyodide:a}),e=new h({pyodide:a});try{await n.upload(t);const i=new Map([["input-file",n.filename],["output-file",e.filename]]);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{e.delete()}catch{}}}function K(t){return typeof t=="number"?t:t===null?null:[t.min,t.max]}async function Z(t,o){const a=await f(),n=new h({pyodide:a}),e=new h({pyodide:a});try{await n.upload(t);const i=new Map([["input-file",n.filename],["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{e.delete()}catch{}}}async function X(t,o){const a=await f(),n=new h({pyodide:a}),e=new h({pyodide:a});try{await n.upload(t);const i=new Map([["input-file",n.filename],["output-file",e.filename]]);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{e.delete()}catch{}}}function Y(t,o){const a={};for(const e of t){const i=p.findInstance(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[e,{min:i,max:s}]of Object.entries(a))n[e]=i===s?i:{min:i,max:s};return n}function tt(t){return t.length>=4&&t[0]===79&&t[1]===84&&t[2]===84&&t[3]===79}async function nt(t,o){var V,D;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 E(a),N=[];for(const m of o.outputs){let g={};if((V=m.instances)!=null&&V.length&&(g=Y(m.instances,e)),m.axes&&(g={...g,...m.axes}),o.strict){const l=new Set((m.instances??[]).map(r=>p.findInstance(r,e))),u=e.filter(r=>!l.has(r)&&i.every(x=>{const y=r.coordinates[x.tag]??x.default,_=g[x.tag];return _==null?!0:typeof _=="number"?y===_:y>=_.min&&y<=_.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 l of i){const u=g[l.tag];if(u!=null&&typeof u=="object"){const r=u;if(l.default<r.min||l.default>r.max){const x=Math.max(r.min,Math.min(r.max,l.default));console.warn(`vf-clamp: axis "${l.tag}" default (${l.default}) is outside restricted range [${r.min}, ${r.max}] — will be clamped to ${x}`)}}}const k={};for(const[l,u]of Object.entries(g))u!==null&&(k[l]=K(u));const w=(m.instances??[]).map(l=>p.findInstance(l,e)),L=w.length?p.rangeName(w,e,i,d??{}):"Clamped",R=((D=m.name)==null?void 0:D.trim())||(s?`${s} ${L}`:L),{buffer:U,info:O}=await Z(a,k);let c=U;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'");o.normalizeWeightAxis&&(c=await X(c,100)),c=await H(c,{family:R,style:w.length===1?w[0].name:null,pinned:O.pinned,source:O.source}),n==="woff2"?c=await j(c):n==="woff"&&(c=await B(c)),N.push({name:R,buffer:c,format:n})}return N}exports.compactName=p.compactName;exports.numberKey=p.numberKey;exports.planOutputs=p.planOutputs;exports.rangeName=p.rangeName;exports.unboughtInstances=p.unboughtInstances;exports.clampFont=nt;exports.convertToWoff=B;exports.convertToWoff2=j;exports.getInstances=E;