localtools-font-subsetter 1.0.0__tar.gz

localtools_font_subsetter-1.0.0/.gitignore

@@ -0,0 +1,8 @@
+dist/
+/*.exe
+node_modules/
+test-results/
+playwright-report/
+__pycache__/
+*.egg-info/
+.venv/

localtools_font_subsetter-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chaitanya Prabuddha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

localtools_font_subsetter-1.0.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.5
+Name: localtools-font-subsetter
+Version: 1.0.0
+Summary: Subset fonts to the characters you use, instance variable fonts, and convert to WOFF2 (localtools, offline, fontTools)
+Project-URL: Source, https://github.com/chayprabs/localtools
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: brotli>=1.1
+Requires-Dist: fonttools>=4.60
+Requires-Dist: multipart>=1.2
+Description-Content-Type: text/markdown
+
+# localtools-font-subsetter
+
+Make web fonts small, on your machine: subset TTF/OTF/WOFF/WOFF2 fonts to the characters you actually use (Unicode
+presets, your own text, or Unicode ranges), keep or drop OpenType features, drop hinting, pin or limit variable-font axes
+(e.g. `wght` 400 to 700), and write WOFF2, WOFF or TTF/OTF. Each result shows before/after size and glyph count, a coverage
+report (which requested characters the font does not have), font metadata (family, style, axes, license, fsType embedding
+bits, with a warning when they forbid embedding or subsetting), a live preview rendered with the subset font, and a
+ready-to-paste `@font-face` rule with the exact `unicode-range`. Nothing leaves your computer.
+
+## Install
+
+| OS | command |
+|---|---|
+| Windows (PowerShell) | `irm https://raw.githubusercontent.com/chayprabs/localtools/main/font-subsetter/install.ps1 \| iex` |
+| macOS / Linux | `curl -fsSL https://raw.githubusercontent.com/chayprabs/localtools/main/font-subsetter/install.sh \| bash` |
+| PyPI (Python 3.10+) | `pipx install localtools-font-subsetter` |
+
+The installer unpacks a portable build with its own Python 3.13 (17 MB zip on Windows, 24 to 39 MB on macOS/Linux).
+
+## Use
+
+**UI:** run `localtools-font-subsetter` (or the Start menu / Applications launcher). It opens `http://127.0.0.1:47129`.
+Drop one or more fonts, tick presets (Latin, Latin Ext, Cyrillic, Cyrillic Ext, Greek, Greek Ext, Vietnamese, or Keep all)
+and/or type sample text, optionally Unicode ranges, layout features and axes, pick a format, press Subset. The preview line
+is editable. Copy CSS and Download sit on each result.
+
+- Presets use the same ranges Google Fonts serves, so `unicode-range` splitting works the way the web expects.
+- Layout features: `default` (fontTools' set: kern, liga, calt, mark, mkmk, locl, ...), `all`, `none`, an exact list
+  (`kern,liga`) or edits to the default (`+ss01,+tnum,-liga`).
+- Axes use fontTools instancer syntax: `wght=400` pins, `wght=400:700` limits, `wght=300:400:700` limits and moves the
+  default, `opsz=drop` pins to the default. Pin every axis to get a static font.
+- Hinting is dropped by default (smaller files; browsers on modern systems barely use it). Tick Keep hinting to keep it.
+
+**CLI:**
+
+```sh
+localtools-font-subsetter subset Inter.ttf --preset latin --text "Ωμέγα" --format woff2 -o out/
+localtools-font-subsetter subset RobotoFlex.ttf --preset latin,latin-ext --axes "wght=400:700 opsz=drop" -o out/ --css > fonts.css
+localtools-font-subsetter subset *.otf --text-file page.html --features +tnum --format woff -o out/ --json
+```
+
+Output files are `<name>-subset.<ext>`. Missing characters and license warnings go to stderr; `--css` prints the
+`@font-face` rules, `--json` the full report.
+
+**API:** `POST /api/subset`, multipart: `file` (repeat for several fonts), `preset` (comma list), `text`, `unicodes`,
+`features`, `hinting` (`1`), `axes`, `format` (`woff2 woff ttf otf`). One font returns the font file, several return a zip
+with `fonts.css`. `POST /api/report` takes the same fields and returns JSON (sizes, glyphs, axes, metadata, coverage,
+warnings, CSS, base64 font). Errors: `400 {"error": "..."}`.
+
+```sh
+curl -F file=@Inter.ttf -F preset=latin -F text=Hello -F format=woff2 -o Inter-subset.woff2 http://127.0.0.1:47129/api/subset
+```
+
+## Engine
+
+[fontTools](https://github.com/fonttools/fonttools) (MIT): `fontTools.subset` is pyftsubset, and `fontTools.varLib.instancer`
+is the reference variable-font instancer; Google Fonts and most font foundries build with them. WOFF2 uses Google's
+[brotli](https://github.com/google/brotli) (MIT). The font is subset first and instanced second: that is faster, and it
+avoids a fontTools failure when subsetting an already partially-instanced font in memory. The full name table (copyright,
+license, instance names) is kept.
+
+## Not included
+
+- Font collections (`.ttc`/`.otc`): refused with a clear error; extract a single font first.
+- EOT and SVG fonts: obsolete web formats.
+- Instancing large variable fonts is slow (a 2 MB, 4,500-glyph font takes about 20 s). Subsetting first helps a lot.
+
+## Update / uninstall
+
+`localtools-font-subsetter update` / `localtools-font-subsetter uninstall` (installer builds). For PyPI installs:
+`pipx upgrade localtools-font-subsetter` / `pipx uninstall localtools-font-subsetter`.
+
+## License
+
+MIT. Test fonts in `samples/` are subsets of Inter, Roboto Flex and Noto Sans (SIL OFL 1.1, see `samples/licenses/`).

localtools_font_subsetter-1.0.0/README.md

@@ -0,0 +1,75 @@
+# localtools-font-subsetter
+
+Make web fonts small, on your machine: subset TTF/OTF/WOFF/WOFF2 fonts to the characters you actually use (Unicode
+presets, your own text, or Unicode ranges), keep or drop OpenType features, drop hinting, pin or limit variable-font axes
+(e.g. `wght` 400 to 700), and write WOFF2, WOFF or TTF/OTF. Each result shows before/after size and glyph count, a coverage
+report (which requested characters the font does not have), font metadata (family, style, axes, license, fsType embedding
+bits, with a warning when they forbid embedding or subsetting), a live preview rendered with the subset font, and a
+ready-to-paste `@font-face` rule with the exact `unicode-range`. Nothing leaves your computer.
+
+## Install
+
+| OS | command |
+|---|---|
+| Windows (PowerShell) | `irm https://raw.githubusercontent.com/chayprabs/localtools/main/font-subsetter/install.ps1 \| iex` |
+| macOS / Linux | `curl -fsSL https://raw.githubusercontent.com/chayprabs/localtools/main/font-subsetter/install.sh \| bash` |
+| PyPI (Python 3.10+) | `pipx install localtools-font-subsetter` |
+
+The installer unpacks a portable build with its own Python 3.13 (17 MB zip on Windows, 24 to 39 MB on macOS/Linux).
+
+## Use
+
+**UI:** run `localtools-font-subsetter` (or the Start menu / Applications launcher). It opens `http://127.0.0.1:47129`.
+Drop one or more fonts, tick presets (Latin, Latin Ext, Cyrillic, Cyrillic Ext, Greek, Greek Ext, Vietnamese, or Keep all)
+and/or type sample text, optionally Unicode ranges, layout features and axes, pick a format, press Subset. The preview line
+is editable. Copy CSS and Download sit on each result.
+
+- Presets use the same ranges Google Fonts serves, so `unicode-range` splitting works the way the web expects.
+- Layout features: `default` (fontTools' set: kern, liga, calt, mark, mkmk, locl, ...), `all`, `none`, an exact list
+  (`kern,liga`) or edits to the default (`+ss01,+tnum,-liga`).
+- Axes use fontTools instancer syntax: `wght=400` pins, `wght=400:700` limits, `wght=300:400:700` limits and moves the
+  default, `opsz=drop` pins to the default. Pin every axis to get a static font.
+- Hinting is dropped by default (smaller files; browsers on modern systems barely use it). Tick Keep hinting to keep it.
+
+**CLI:**
+
+```sh
+localtools-font-subsetter subset Inter.ttf --preset latin --text "Ωμέγα" --format woff2 -o out/
+localtools-font-subsetter subset RobotoFlex.ttf --preset latin,latin-ext --axes "wght=400:700 opsz=drop" -o out/ --css > fonts.css
+localtools-font-subsetter subset *.otf --text-file page.html --features +tnum --format woff -o out/ --json
+```
+
+Output files are `<name>-subset.<ext>`. Missing characters and license warnings go to stderr; `--css` prints the
+`@font-face` rules, `--json` the full report.
+
+**API:** `POST /api/subset`, multipart: `file` (repeat for several fonts), `preset` (comma list), `text`, `unicodes`,
+`features`, `hinting` (`1`), `axes`, `format` (`woff2 woff ttf otf`). One font returns the font file, several return a zip
+with `fonts.css`. `POST /api/report` takes the same fields and returns JSON (sizes, glyphs, axes, metadata, coverage,
+warnings, CSS, base64 font). Errors: `400 {"error": "..."}`.
+
+```sh
+curl -F file=@Inter.ttf -F preset=latin -F text=Hello -F format=woff2 -o Inter-subset.woff2 http://127.0.0.1:47129/api/subset
+```
+
+## Engine
+
+[fontTools](https://github.com/fonttools/fonttools) (MIT): `fontTools.subset` is pyftsubset, and `fontTools.varLib.instancer`
+is the reference variable-font instancer; Google Fonts and most font foundries build with them. WOFF2 uses Google's
+[brotli](https://github.com/google/brotli) (MIT). The font is subset first and instanced second: that is faster, and it
+avoids a fontTools failure when subsetting an already partially-instanced font in memory. The full name table (copyright,
+license, instance names) is kept.
+
+## Not included
+
+- Font collections (`.ttc`/`.otc`): refused with a clear error; extract a single font first.
+- EOT and SVG fonts: obsolete web formats.
+- Instancing large variable fonts is slow (a 2 MB, 4,500-glyph font takes about 20 s). Subsetting first helps a lot.
+
+## Update / uninstall
+
+`localtools-font-subsetter update` / `localtools-font-subsetter uninstall` (installer builds). For PyPI installs:
+`pipx upgrade localtools-font-subsetter` / `pipx uninstall localtools-font-subsetter`.
+
+## License
+
+MIT. Test fonts in `samples/` are subsets of Inter, Roboto Flex and Noto Sans (SIL OFL 1.1, see `samples/licenses/`).

localtools_font_subsetter-1.0.0/localtools_font_subsetter/__main__.py

@@ -0,0 +1,156 @@
+import argparse
+import base64
+import io
+import json
+import sys
+import zipfile
+from pathlib import Path
+
+import multipart
+
+from .engine import FORMATS, PRESETS, FontError, Options, process
+from .localtools import HTTPError, Tool, main as run
+
+USAGE = f"""localtools-font-subsetter: subset, instance and convert fonts for the web, offline (fontTools).
+
+Usage:
+  localtools-font-subsetter [serve] [--port N] [--no-open]   start the web UI (default port 47129)
+  localtools-font-subsetter subset FONT... [options]          subset fonts from the command line
+      --preset P[,P]     {", ".join(PRESETS)}
+      --text TEXT        keep the glyphs of this text      --text-file FILE   same, from a UTF-8 file
+      --unicodes U       Unicode ranges, e.g. "U+0020-007E, U+2014"
+      --features F       default | all | none | kern,liga | +ss01,-liga   (OpenType layout features)
+      --hinting          keep hinting (dropped by default: smaller web fonts)
+      --axes A           variable fonts: pin or limit axes, e.g. "wght=400:700 wdth=100 opsz=drop"
+      --format F         woff2 (default) | woff | ttf | otf
+      -o DIR             output folder (default: current folder)
+      --css              print @font-face rules     --json   print the full report as JSON
+  localtools-font-subsetter update | uninstall               re-run the installer / remove the tool
+  localtools-font-subsetter --version | --help
+
+API: POST /api/subset (multipart: file..., preset, text, unicodes, features, hinting, axes, format)
+     returns the font (one file) or a zip with fonts.css (several); POST /api/report returns the JSON report.
+"""
+
+UI = Path(__file__).with_name("ui")  # wheel: packaged ui/; source checkout: repo-root ui/
+if not UI.is_dir():
+    UI = Path(__file__).parents[1] / "ui"
+MAX_UPLOAD = 256 << 20
+
+
+def read_form(req):
+    """Like localtools.form(), but keeps every uploaded file (the UI sends several under "file")."""
+    ctype, opts = multipart.parse_options_header(req.headers.get("Content-Type", ""))
+    if ctype != "multipart/form-data" or "boundary" not in opts:
+        raise HTTPError(400, "expected multipart/form-data")
+    size = int(req.headers.get("Content-Length") or 0)
+    if size > MAX_UPLOAD:
+        raise HTTPError(413, "upload too large (256 MB max)")
+    try:
+        parts = list(multipart.MultipartParser(req.rfile, opts["boundary"], size))
+    except multipart.MultipartError as e:
+        raise HTTPError(400, f"malformed upload: {e}")
+    try:
+        files = [(p.filename, p.raw) for p in parts if p.filename]
+        fields = {p.name: p.value for p in parts if not p.filename}
+    finally:
+        for p in parts:
+            p.close()
+    if not files:
+        raise HTTPError(400, "upload at least one font (TTF, OTF, WOFF or WOFF2)")
+    return files, options(fields)
+
+
+def options(f):
+    return Options(presets=[p.strip() for p in f.get("preset", "").split(",") if p.strip()],
+                   text=f.get("text", ""), unicodes=f.get("unicodes", ""),
+                   features=f.get("features", "default") or "default",
+                   hinting=f.get("hinting", "").lower() in ("1", "on", "true", "yes"),
+                   axes=f.get("axes", ""), format=(f.get("format") or "woff2").lower())
+
+
+def run_all(files, o):
+    try:
+        return [process(data, name, o) for name, data in files]
+    except FontError as e:
+        raise HTTPError(400, str(e))
+
+
+def api_subset(req):
+    results = run_all(*read_form(req))
+    if len(results) == 1:
+        body, rep = results[0]
+        ctype, filename = rep["mime"], rep["output"]
+    else:
+        buf = io.BytesIO()
+        with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as z:
+            for data, rep in results:
+                z.writestr(rep["output"], data)
+            z.writestr("fonts.css", "\n".join(rep["css"] for _, rep in results))
+        body, ctype, filename = buf.getvalue(), "application/zip", "fonts-subset.zip"
+    req.send_response(200)
+    req.send_header("Content-Type", ctype)
+    req.send_header("Content-Disposition", f'attachment; filename="{filename}"')
+    req.send_header("Content-Length", str(len(body)))
+    req.end_headers()
+    req.wfile.write(body)
+
+
+def api_report(req):
+    results = run_all(*read_form(req))
+    req.send_json(200, {"fonts": [{**rep, "data": base64.b64encode(data).decode()} for data, rep in results]})
+
+
+def kb(n):
+    return f"{n / 1024:.1f} KB"
+
+
+def cli_subset(args):
+    p = argparse.ArgumentParser(prog="localtools-font-subsetter subset")
+    p.add_argument("fonts", nargs="+")
+    p.add_argument("--preset", default="")
+    p.add_argument("--text", default="")
+    p.add_argument("--text-file")
+    p.add_argument("--unicodes", default="")
+    p.add_argument("--features", default="default")
+    p.add_argument("--hinting", action="store_true")
+    p.add_argument("--axes", default="")
+    p.add_argument("--format", default="woff2", choices=list(FORMATS))
+    p.add_argument("-o", "--out", default=".")
+    p.add_argument("--css", action="store_true")
+    p.add_argument("--json", action="store_true")
+    a = p.parse_args(args)
+    for s in (sys.stdout, sys.stderr):  # missing-character lists are Unicode; Windows pipes default to cp1252
+        s.reconfigure(encoding="utf-8")
+    text = a.text + (Path(a.text_file).read_text(encoding="utf-8") if a.text_file else "")
+    o = Options(presets=[x for x in a.preset.split(",") if x], text=text, unicodes=a.unicodes,
+                features=a.features, hinting=a.hinting, axes=a.axes, format=a.format)
+    out = Path(a.out)
+    out.mkdir(parents=True, exist_ok=True)
+    reports = []
+    for f in a.fonts:
+        data, rep = process(Path(f).read_bytes(), Path(f).name, o)
+        (out / rep["output"]).write_bytes(data)
+        reports.append(rep)
+        b, af = rep["before"], rep["after"]
+        print(f"{f} -> {out / rep['output']}  {kb(b['size'])} -> {kb(af['size'])} "
+              f"({(af['size'] - b['size']) * 100 / b['size']:+.0f}%), {b['glyphs']} -> {af['glyphs']} glyphs",
+              file=sys.stderr if a.css or a.json else sys.stdout)
+        for w in rep["warnings"]:
+            print(f"  {w['severity']}: {w['message']}", file=sys.stderr)
+    if a.json:
+        print(json.dumps(reports, indent=2, ensure_ascii=False))
+    elif a.css:
+        print("\n".join(r["css"] for r in reports), end="")
+
+
+tool = Tool(slug="font-subsetter", port=47129, usage=USAGE, ui=UI,
+            routes={"POST /api/subset": api_subset, "POST /api/report": api_report}, cli={"subset": cli_subset})
+
+
+def main():
+    sys.exit(run(tool))
+
+
+if __name__ == "__main__":
+    main()

localtools_font_subsetter-1.0.0/localtools_font_subsetter/engine.py

@@ -0,0 +1,233 @@
+"""Font subsetting, variable-font instancing and conversion with fontTools (pyftsubset + varLib.instancer)."""
+import io
+from itertools import count, groupby
+import re
+from dataclasses import dataclass, field
+
+from fontTools import subset
+from fontTools.ttLib import TTFont
+from fontTools.varLib import instancer
+
+# Same ranges Google Fonts serves in its CSS, so the output matches what the web already uses.
+PRESETS = {
+    "latin": "U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,"
+             "U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD",
+    "latin-ext": "U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+0304,U+0308,U+0329,U+1D00-1DBF,"
+                 "U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF",
+    "cyrillic": "U+0301,U+0400-045F,U+0490-0491,U+04B0-04B1,U+2116",
+    "cyrillic-ext": "U+0460-052F,U+1C80-1C8A,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F",
+    "greek": "U+0370-0377,U+037A-037F,U+0384-038A,U+038C,U+038E-03A1,U+03A3-03FF",
+    "greek-ext": "U+1F00-1FFF",
+    "vietnamese": "U+0102-0103,U+0110-0111,U+0128-0129,U+0168-0169,U+01A0-01A1,U+01AF-01B0,U+0300-0301,"
+                  "U+0303-0304,U+0308-0309,U+0323,U+0329,U+1EA0-1EF9,U+20AB",
+    "all": "",  # keep every character (convert or instance only)
+}
+FORMATS = {"woff2": ("woff2", "font/woff2"), "woff": ("woff", "font/woff"), "ttf": (None, "font/ttf"), "otf": (None, "font/otf")}
+EMBEDDING = {0: "Installable", 2: "Restricted License", 4: "Preview & Print", 8: "Editable"}
+
+
+class FontError(ValueError):
+    pass
+
+
+@dataclass
+class Options:
+    presets: list = field(default_factory=list)
+    text: str = ""
+    unicodes: str = ""
+    features: str = "default"  # default | all | none | tag list | +tag,-tag (relative to default)
+    hinting: bool = False
+    axes: str = ""  # instancer limits: "wght=400:700 wdth=100 opsz=drop"
+    format: str = "woff2"
+
+
+def parse_unicodes(s):
+    try:
+        return set(subset.parse_unicodes(s.replace(";", ",")))
+    except ValueError:
+        raise FontError(f'bad Unicode ranges "{s}" (use e.g. U+0020-007E, U+2014)')
+
+
+def requested(o):
+    """-> (codepoints or None for "keep all", [(label, codepoint set)])"""
+    groups = []
+    for p in o.presets:
+        if p not in PRESETS:
+            raise FontError(f'unknown preset "{p}" (choose from {", ".join(PRESETS)})')
+        if p == "all":
+            return None, []
+        groups.append((p, parse_unicodes(PRESETS[p])))
+    if o.unicodes.strip():
+        groups.append(("ranges", parse_unicodes(o.unicodes)))
+    text = {ord(c) for c in o.text if ord(c) >= 0x20}
+    if text:
+        groups.append(("text", text))
+    if not groups:
+        raise FontError("choose characters: a preset, sample text or Unicode ranges")
+    return set().union(*(g for _, g in groups)), groups
+
+
+def features(spec):
+    s = spec.replace(" ", "").strip(",")
+    default = list(subset.Options().layout_features)
+    if s in ("", "default"):
+        return default
+    if s in ("all", "*"):
+        return ["*"]
+    if s == "none":
+        return []
+    tags = s.split(",")
+    if not all(re.fullmatch(r"[+-]?[A-Za-z0-9 ]{1,4}", t) for t in tags):
+        raise FontError(f'bad feature list "{spec}" (use e.g. kern,liga or +ss01,-liga)')
+    if all(t[0] in "+-" for t in tags):
+        add = [t[1:] for t in tags if t[0] == "+"]
+        return [f for f in default if f"-{f}" not in tags] + add
+    return tags
+
+
+def ranges_css(cps):
+    runs = [list(g) for _, g in groupby(sorted(cps), key=lambda c, n=count(): c - next(n))]
+    return ", ".join(f"U+{r[0]:04X}" + (f"-{r[-1]:04X}" if len(r) > 1 else "") for r in runs)
+
+
+def name(font, *ids):
+    for i in ids:
+        if "name" in font and (n := font["name"].getDebugName(i)):
+            return n
+    return ""
+
+
+def axes(font):
+    if "fvar" not in font:
+        return []
+    return [{"tag": a.axisTag, "name": name(font, a.axisNameID) or a.axisTag,
+             "min": a.minValue, "default": a.defaultValue, "max": a.maxValue} for a in font["fvar"].axes]
+
+
+def kind(font):
+    outlines = "CFF2" if "CFF2" in font else "CFF" if "CFF " in font else "TrueType"
+    return (font.flavor or ("otf" if outlines.startswith("CFF") else "ttf")), outlines
+
+
+def describe(font, size):
+    fmt, outlines = kind(font)
+    return {"size": size, "glyphs": len(font.getGlyphOrder()), "format": fmt, "outlines": outlines,
+            "codepoints": len(font.getBestCmap() or {}), "axes": axes(font)}
+
+
+def metadata(font):
+    os2 = font.get("OS/2")
+    fs = os2.fsType if os2 else 0
+    feats = sorted({fr.FeatureTag for t in ("GSUB", "GPOS") if t in font and font[t].table.FeatureList
+                    for fr in font[t].table.FeatureList.FeatureRecord})
+    return {"family": name(font, 16, 1), "style": name(font, 17, 2), "version": name(font, 5),
+            "vendor": (os2.achVendID.strip() if os2 else ""), "copyright": name(font, 0),
+            "license": name(font, 13), "license_url": name(font, 14), "fsType": fs,
+            "embedding": EMBEDDING.get(fs & 0xF, f"unknown ({fs & 0xF})"), "features": feats}
+
+
+def license_warnings(meta):
+    fs, w = meta["fsType"], []
+    if fs & 0xF == 2:
+        w.append(("error", "fsType says Restricted License embedding: the vendor forbids embedding this font. Check your license before using it on the web."))
+    elif fs & 0xF == 4:
+        w.append(("warn", "fsType says Preview & Print embedding only: editing or modifying the font is not allowed by default."))
+    if fs & 0x100:
+        w.append(("error", "fsType has the No-subsetting bit: the vendor forbids subsetting this font."))
+    if fs & 0x200:
+        w.append(("warn", "fsType has the Bitmap-embedding-only bit: outlines may not be embedded."))
+    lic = (meta["license"] + " " + meta["license_url"]).lower()
+    if "reserved font name" in lic:
+        w.append(("info", "The OFL license reserves the font name: a modified font may need a different family name for redistribution."))
+    return w
+
+
+def load(data, filename=""):
+    if data[:4] == b"ttcf":
+        raise FontError(f"{filename}: font collections (.ttc/.otc) are not supported; extract one font first")
+    try:
+        font = TTFont(io.BytesIO(data))
+        font.getGlyphOrder()
+        font.getBestCmap()
+        return font
+    except Exception as e:
+        raise FontError(f"{filename or 'input'}: not a readable TTF/OTF/WOFF/WOFF2 font ({type(e).__name__}: {e})")
+
+
+def font_face(family, after_font, filename, fmt):
+    a = {x["tag"]: x for x in axes(after_font)}
+    os2 = after_font.get("OS/2")
+    italic = bool(os2 and os2.fsSelection & 1) or ("post" in after_font and after_font["post"].italicAngle != 0)
+    weight = f"{a['wght']['min']:g} {a['wght']['max']:g}" if "wght" in a else str(os2.usWeightClass if os2 else 400)
+    lines = [f'  font-family: "{family}";', f"  font-style: {'italic' if italic else 'normal'};", f"  font-weight: {weight};"]
+    if "wdth" in a:
+        lines.append(f"  font-stretch: {a['wdth']['min']:g}% {a['wdth']['max']:g}%;")
+    css_fmt = {"woff2": "woff2", "woff": "woff", "ttf": "truetype", "otf": "opentype"}[fmt]
+    lines += ["  font-display: swap;", f'  src: url("{filename}") format("{css_fmt}");',
+              f"  unicode-range: {ranges_css((after_font.getBestCmap() or {}).keys())};"]
+    return "@font-face {\n" + "\n".join(lines) + "\n}\n"
+
+
+def process(data, filename, o):
+    """Subset, instance and convert one font. Returns (output bytes, report dict)."""
+    if o.format not in FORMATS:
+        raise FontError(f'unknown format "{o.format}" (woff2, woff, ttf, otf)')
+    cps, groups = requested(o)
+    font = load(data, filename)
+    before, meta = describe(font, len(data)), metadata(font)
+    warnings = license_warnings(meta)
+    cmap = set((font.getBestCmap() or {}).keys())
+
+    limits = None
+    if o.axes.strip():
+        if "fvar" not in font:
+            raise FontError(f"{filename}: not a variable font, so there are no axes to pin or limit")
+        try:
+            limits = instancer.parseLimits(o.axes.replace(",", " ").split())
+        except ValueError as e:
+            raise FontError(f'bad axes "{o.axes}": {e} (use e.g. wght=400:700 wdth=100 opsz=drop)')
+        unknown = set(limits) - {a["tag"] for a in before["axes"]}
+        if unknown:
+            raise FontError(f"{filename}: no axis {', '.join(sorted(unknown))} (font axes: {', '.join(a['tag'] for a in before['axes'])})")
+
+    opts = subset.Options()
+    opts.layout_features = features(o.features)
+    opts.hinting = o.hinting
+    opts.name_IDs = ["*"]  # keep copyright, license and instance names
+    opts.name_languages = ["*"]
+    opts.notdef_outline = True
+    opts.ignore_missing_unicodes = True
+    sub = subset.Subsetter(opts)
+    sub.populate(unicodes=cmap if cps is None else cps)
+    try:
+        sub.subset(font)
+        if limits is not None:  # after subsetting: less to instance, and avoids fontTools' lazy-gvar subsetting bug
+            font = instancer.instantiateVariableFont(font, limits)
+    except Exception as e:
+        raise FontError(f"{filename}: fontTools could not process this font ({type(e).__name__}: {e})")
+
+    flavor, mime = FORMATS[o.format]
+    font.flavor = flavor
+    buf = io.BytesIO()
+    font.save(buf)
+    out = buf.getvalue()
+    after = describe(load(out, filename), len(out))
+    fmt = o.format if flavor else kind(font)[0]
+    stem = re.sub(r"\.(ttf|otf|woff2?)$", "", filename, flags=re.I) or "font"
+    outname = f"{stem}-subset.{fmt}"
+
+    coverage = []
+    for label, g in groups:
+        g = {c for c in g if not (c < 0x20 or 0x7F <= c <= 0x9F)}  # control characters have no glyphs
+        missing = sorted(g - cmap)
+        coverage.append({"group": label, "requested": len(g), "covered": len(g) - len(missing),
+                         "missing": "".join(map(chr, missing[:500])) if label == "text" else ranges_css(missing)})
+    text_missing = next((c["missing"] for c in coverage if c["group"] == "text"), "")
+    if text_missing:
+        warnings.append(("warn", f"{len(text_missing)} character(s) of your text are not in this font: {text_missing}"))
+    return out, {
+        "name": filename, "output": outname, "mime": mime if flavor else f"font/{fmt}",
+        "before": before, "after": after, "meta": meta, "coverage": coverage,
+        "warnings": [{"severity": s, "message": m} for s, m in warnings],
+        "css": font_face(meta["family"] or stem, font, outname, fmt),
+    }