@overpunch/vf-clamp 2.3.0 → 2.4.0

package/dist/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const U=require("node:module");var I=typeof document<"u"?document.currentScript:null;const E=U.createRequire(typeof document>"u"?require("url").pathToFileURL(__filename).href:I&&I.tagName.toUpperCase()==="SCRIPT"&&I.src||new URL("index.cjs",document.baseURI).href),{preparePyodide:d,PyodideFile:x}=E("@web-alchemy/fonttools/src/pyodide.js");let S=null;async function B(){return S||(S=d().then(e=>e.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,7 +7,7 @@ def vf_convert_flavor(file_options):
     font.save(file_options['output-file'])
 
 vf_convert_flavor
-`))),S}async function P(e,a){const t=await d(),n=new x({pyodide:t}),i=new x({pyodide:t});try{await n.upload(e);const o=new Map([["input-file",n.filename],["output-file",i.filename],["flavor",a]]);return(await B())(o),i.download()}finally{try{n.delete()}catch{}try{i.delete()}catch{}}}async function $(e){return P(e,"woff")}async function L(e){return P(e,"woff2")}let A=null;async function W(){return A||(A=d().then(e=>e.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
 
@@ -40,102 +40,413 @@ 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 ''
 
-get_instances_fn
-`))),A}async function M(e){const a=await d(),t=e instanceof ArrayBuffer?new Uint8Array(e):e,n=new x({pyodide:a});try{await n.upload(t);const o=(await W())(n.filename);return JSON.parse(o)}finally{try{n.delete()}catch{}}}function C(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(" ")}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 V=null,N=null,D=null,O=null;async function z(){return V||(V=d().then(e=>e.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}
-
-    # 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
+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
-`))),V}async function q(){return N||(N=d().then(e=>e.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
@@ -166,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
-`))),N}async function H(){return D||(D=d().then(e=>e.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):
@@ -236,50 +551,4 @@ def vf_clamp_normalize_wght(file_options, new_min_str):
     return 'done'
 
 vf_clamp_normalize_wght
-`))),D}async function J(){return O||(O=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
-`))),O}function G(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(/-+$/,"")}-${k(e)}`}function k(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)}async function K(e,a){if(!a)return e;const t=await d(),n=new x({pyodide:t}),i=new x({pyodide:t});try{const o=G(a);await n.upload(e);const r=new Map([["input-file",n.filename],["output-file",i.filename],["family-name",a],["postscript-name",o],["postscript-suffix",k(a)]]);return(await z())(r),i.download()}catch(o){throw Object.assign(new Error(`vf-clamp: name table patching failed for "${a}"`),{cause:o})}finally{try{n.delete()}catch{}try{i.delete()}catch{}}}function Z(e){return typeof e=="number"?e:e===null?null:[e.min,e.max]}async function Q(e,a){const t=await d(),n=new x({pyodide:t}),i=new x({pyodide:t});try{await n.upload(e);const o=new Map([["input-file",n.filename],["output-file",i.filename]]);return(await q())(o,JSON.stringify(a)),i.download()}finally{try{n.delete()}catch{}try{i.delete()}catch{}}}async function X(e){const a=await d(),t=new x({pyodide:a}),n=new x({pyodide:a});try{await t.upload(e);const i=new Map([["input-file",t.filename],["output-file",n.filename]]);return(await J())(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 Y(e,a){const t=await d(),n=new x({pyodide:t}),i=new x({pyodide:t});try{await n.upload(e);const o=new Map([["input-file",n.filename],["output-file",i.filename]]);return(await H())(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})}finally{try{n.delete()}catch{}try{i.delete()}catch{}}}function ee(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}}const n={};for(const[i,{min:o,max:r}]of Object.entries(t))n[i]=o===r?o:{min:o,max:r};return n}function te(e){return e.length>=4&&e[0]===79&&e[1]===84&&e[2]===84&&e[3]===79}async function ne(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 M(t),s=[];for(const f of a.outputs){let l={};if((h=f.instances)!=null&&h.length&&(l=ee(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`)}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));console.warn(`vf-clamp: axis "${_.tag}" default (${_.default}) is outside restricted range [${p.min}, ${p.max}] — will be clamped to ${b}`)}}}const c={};for(const[_,w]of Object.entries(l))w!==null&&(c[_]=Z(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 Q(t,c);if(n==="otf"&&!te(m))throw new Error("vf-clamp: format 'otf' needs a CFF/CFF2 source font; this font has TrueType outlines — use 'ttf'");a.normalizeWeightAxis&&(m=await Y(m,100)),m=await X(m),m=await K(m,g),n==="woff2"?m=await L(m):n==="woff"&&(m=await $(m)),s.push({name:g,buffer:m,format:n})}return s}function R(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)}}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 ae(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(R(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(R(g,n),i,r,n).length){s[c]=g,s.splice(u,1),l=!0;break e}}}}const h=ae(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:C(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(R(t,e.axes),e.instances,new Set(t),e.axes).map(n=>n.name):[]}exports.clampFont=ne;exports.compactName=C;exports.convertToWoff=$;exports.convertToWoff2=L;exports.getInstances=M;exports.planOutputs=ie;exports.unboughtInstances=oe;
+`))),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;