feat: new ui (#1455)

This commit is contained in:
Levi authored and GitHub committed 2026-09-05 19:53:41 +08:00
1 parent 3be8db664c
commit 177c225f16
742 files changed
+59951 -5934

No files matched your search

@@ -0,0 +1,3 @@
.venv/
.build/
__pycache__/
@@ -0,0 +1,59 @@
---
name: gopeed-file-category-icons
description: Design or revise Gopeed file-classification icons as one cohesive SVG-to-Flutter icon font. Use for file types, generic and protocol-marked folders, unknown files, and extension-to-icon taxonomy; do not use for launcher, navigation, action, or status icons.
---
# Gopeed File Category Icons
Maintain Gopeed's file-classification visual language and its deterministic SVG → TTF → Flutter `IconData` pipeline.
The canonical editable materials live in `design/file-category-icons/`, outside the Flutter project. Read its `README.md` before changing any source. Do not add that directory to Flutter assets.
## Classification grammar
- A directory is always a folder outline. Add a classification or protocol mark only when one is known; otherwise leave the folder empty.
- A non-directory is always a file outline plus its classification mark.
- An unknown file is an empty file outline. Do not invent a generic interior mark.
- Transfer state is separate from classification. Never replace a file glyph with paused, failed, completed, or downloading artwork.
- Keep this skill scoped to file browsing, task assets, extension classification, and the font that renders those categories.
## Workflow
1. Read `design/file-category-icons/README.md`, then inspect its manifest, the classification mapping, real task-card size, and file-tree size. Read [references/style-guide.md](references/style-guide.md) for every visual revision.
2. Preserve the shared file or folder shell. Redraw only the classification mark unless the task explicitly revises the complete system.
3. Create 24×24 SVG sources containing only closed, filled `<path>` geometry. Convert strokes and lettering to paths; never leave `<text>`, live strokes, masks, clipping, filters, or external references.
4. Keep every decorated mark inside the documented safe area. Reject any mark that touches or visually merges with the shell at 16 or 20 px.
5. Preserve existing names and codepoints. Omit the codepoint only for a new category, then allocate it with the builder. Bump the font version for a visual revision.
6. Rebuild the complete TTF and generated Dart class, then generate the multi-size contact sheet.
7. Inspect 16, 20, 24, and 32 px in light and dark swatches. Check the actual Flutter task card and task-detail file tree when their sizes differ from the sheet.
8. Run the relevant classification tests, `flutter analyze`, and `flutter test` after integration changes.
## Tool setup
The scripts require the pinned packages in `scripts/requirements.txt`. Keep the environment local and untracked:
```bash
python3 -m venv .agent/skills/gopeed-file-category-icons/.venv
.agent/skills/gopeed-file-category-icons/.venv/bin/pip install -r .agent/skills/gopeed-file-category-icons/scripts/requirements.txt
```
Build and preview a manifest:
```bash
.agent/skills/gopeed-file-category-icons/.venv/bin/python .agent/skills/gopeed-file-category-icons/scripts/build_icon_font.py --manifest design/file-category-icons/manifest.json --allocate-codepoints
.agent/skills/gopeed-file-category-icons/.venv/bin/python .agent/skills/gopeed-file-category-icons/scripts/preview_icon_font.py --manifest design/file-category-icons/manifest.json
```
Use [assets/manifest.example.json](assets/manifest.example.json) and [assets/folder-symbol-template.svg](assets/folder-symbol-template.svg) only as structural starting points.
## Invariants
- Existing codepoints are API: never renumber or reuse one unless the user explicitly approves a breaking migration.
- `design/file-category-icons/` is the sole editable source of truth. Flutter keeps only the generated runtime TTF and Dart constants.
- Never add the design-material directory to `pubspec.yaml`; it must remain outside the packaged Flutter asset graph.
- The manifest is the source of truth. Do not hand-edit generated Dart constants or patch the binary font.
- Keep icon names lowercase `snake_case`; the generator emits lowerCamelCase Dart fields.
- File and folder shells in the same revision must share outline weight, baseline, fold/tab geometry, and optical scale.
- Prefer a recognizable classification symbol over lettering. If lettering is necessary, convert it to geometry and prove it remains legible at 16 px; PDF-like multi-letter marks need deliberate spacing rather than scaling text into the available area.
- New classification groups require both an extension/domain mapping and a glyph. Do not add a glyph that no classifier can reach.
- Rebuild the complete font after every source change so all platforms consume the same binary.
@@ -0,0 +1,4 @@
interface:
display_name: "Gopeed File Category Icons"
short_description: "Design cohesive Gopeed file-classification icons"
default_prompt: "Use $gopeed-file-category-icons to update the source materials and regenerate a consistent Gopeed file-category icon."
@@ -0,0 +1,4 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
<path d="M2 4C2 3.17 2.67 2.5 3.5 2.5H9.25L11.25 4.5H20.5C21.33 4.5 22 5.17 22 6V7.5H2V4ZM2 5.5H4V20H2V5.5ZM20 5.5H22V20H20V5.5ZM2 19.5H22V20C22 20.83 21.33 21.5 20.5 21.5H3.5C2.67 21.5 2 20.83 2 20V19.5Z"/>
<path d="M12 9.25C13.1 9.25 14 10.15 14 11.25C14 12.35 13.1 13.25 12 13.25C10.9 13.25 10 12.35 10 11.25C10 10.15 10.9 9.25 12 9.25ZM7.25 14.25C8.35 14.25 9.25 15.15 9.25 16.25C9.25 17.35 8.35 18.25 7.25 18.25C6.15 18.25 5.25 17.35 5.25 16.25C5.25 15.15 6.15 14.25 7.25 14.25ZM16.75 14.25C17.85 14.25 18.75 15.15 18.75 16.25C18.75 17.35 17.85 18.25 16.75 18.25C15.65 18.25 14.75 17.35 14.75 16.25C14.75 15.15 15.65 14.25 16.75 14.25ZM10.35 12L11.35 13.4L8.9 15.15L7.9 13.75L10.35 12ZM13.65 12L16.1 13.75L15.1 15.15L12.65 13.4L13.65 12Z"/>
</svg>

After

Width:  |  Height:  |  Size: 818 B

@@ -0,0 +1,20 @@
{
"fontFamily": "GopeedIcons",
"fontOutput": "../.build/GopeedIcons.ttf",
"dartOutput": "../.build/gopeed_icons.dart",
"previewOutput": "../.build/gopeed_icons_preview.png",
"dartClass": "GopeedIcons",
"codepointStart": "0xE900",
"unitsPerEm": 1024,
"ascent": 896,
"descent": -128,
"padding": 0,
"version": "1.0.0",
"icons": [
{
"name": "file_category_template",
"source": "folder-symbol-template.svg",
"codepoint": "0xE900"
}
]
}
@@ -0,0 +1,44 @@
# Gopeed file-category icon style
## Composition
- Unknown file: empty file shell.
- Known file: file shell plus one classification mark.
- Generic folder: empty folder shell.
- Known or protocol folder: folder shell plus one classification mark.
- Status and actions never belong inside a classification glyph.
## Geometry
- Use a `0 0 24 24` viewBox and keep the optical drawing inside `2…22` on both axes.
- Use the current shared shell as the source of truth. The established file shell spans roughly `x=3…21` with a 1.5-unit outline; do not silently introduce a heavier one-off border.
- Keep decorated marks approximately inside `x=6.2…17.8` and `y=9.2…19`. Preserve at least 1.5 units of visible separation from the shell wherever its interior edge is closer.
- Prefer radii around 1.5–2 units, consistent terminal shapes, and simple silhouettes. Avoid details or gaps below 1.25 units.
- Center by optical mass rather than bounding-box arithmetic when the shape has a tab, arrow, or asymmetric label.
- Use non-zero winding for counters and holes; reverse inner-contour direction where a cutout is required.
## Classification marks
- Use one dominant mark, not several miniature objects.
- Prefer semantic geometry: play for video, note for audio, image silhouette for images, grid for spreadsheets, a zipper for archive/compressed files, and a cylinder for databases.
- Avoid lettering when a semantic mark is clearer. When a conventional label such as PDF is retained, build each letter as filled geometry with at least 1.25-unit stems and explicit inter-letter gaps.
- Keep an empty file truly empty. A question mark, star, or extension text changes its meaning.
## Protocol-marked folders
- Keep the folder silhouette recognizable before adding the protocol symbol.
- Place a simple filled protocol symbol in the lower folder body with clear space from every edge.
- Prefer semantic marks such as a magnet/swarm for BitTorrent or a donkey/server-network mark for ED2K. Do not default to acronym lettering.
- Let the visible folder occupy about 80–85% of the 24-unit canvas. Avoid adding generator padding on top of the SVG optical margin; double padding makes Flutter icons look undersized.
- Compare optical center and occupied area against Flutter's `folder_outlined` at the actual widget size, not only in an enlarged preview.
## Consistency checks
- Compare new icons beside at least one existing folder icon and one file-type icon.
- Inspect the generated contact sheet at 16, 20, 24, and 32 px on light and dark swatches.
- Reject icons that depend on color, contain live text/strokes, have inconsistent baseline/weight, drift off center, become ambiguous at 16 px, or leave less than the shared safe-area separation from the shell.
- Compare decorated icons against both empty shells. Interior marks must not make the shell look heavier by merging into its border.
## Flutter usage
Register the generated TTF under `flutter.fonts` using the exact `fontFamily` from the manifest. Use the generated Dart constants rather than raw codepoints. Render icon-font glyphs with `Icon`; do not use `Text` because icon sizing and semantics should follow Flutter's icon pipeline.
@@ -0,0 +1,298 @@
#!/usr/bin/env python3
"""Build a deterministic Gopeed file-category font and Flutter IconData class from SVG paths."""
from __future__ import annotations
import argparse
import json
import re
import sys
import xml.etree.ElementTree as ET
from pathlib import Path
try:
from fontTools.fontBuilder import FontBuilder
from fontTools.pens.boundsPen import BoundsPen
from fontTools.pens.cu2quPen import Cu2QuPen
from fontTools.pens.transformPen import TransformPen
from fontTools.pens.ttGlyphPen import TTGlyphPen
from fontTools.svgLib.path import SVGPath
except ImportError as error:
raise SystemExit("Missing fonttools; install scripts/requirements.txt in the skill's .venv") from error
NAME_PATTERN = re.compile(r"^[a-z][a-z0-9_]*$")
DART_NAME_PATTERN = re.compile(r"^[A-Za-z][A-Za-z0-9]*$")
PRIVATE_USE_START = 0xE000
PRIVATE_USE_END = 0xF8FF
ALLOWED_SVG_TAGS = {"svg", "g", "path"}
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--manifest", required=True, type=Path)
parser.add_argument("--allocate-codepoints", action="store_true")
return parser.parse_args()
def local_name(tag: str) -> str:
return tag.rsplit("}", 1)[-1]
def parse_number(value: object, field: str) -> int:
if isinstance(value, int):
return value
if isinstance(value, str):
try:
return int(value, 0)
except ValueError as error:
raise ValueError(f"{field} must be an integer or 0x-prefixed integer") from error
raise ValueError(f"{field} must be an integer or string")
def parse_view_box(svg_text: str, source: Path) -> tuple[float, float, float, float]:
try:
root = ET.fromstring(svg_text)
except ET.ParseError as error:
raise ValueError(f"{source}: invalid XML: {error}") from error
if local_name(root.tag) != "svg":
raise ValueError(f"{source}: root element must be <svg>")
values = re.split(r"[\s,]+", root.attrib.get("viewBox", "").strip())
if len(values) != 4:
raise ValueError(f"{source}: viewBox must contain four numbers")
try:
min_x, min_y, width, height = (float(value) for value in values)
except ValueError as error:
raise ValueError(f"{source}: viewBox contains a non-numeric value") from error
if width <= 0 or height <= 0:
raise ValueError(f"{source}: viewBox dimensions must be positive")
if abs(width - height) > 1e-6:
raise ValueError(f"{source}: icon viewBox must be square")
path_count = 0
for element in root.iter():
tag = local_name(element.tag)
if tag not in ALLOWED_SVG_TAGS:
raise ValueError(f"{source}: unsupported <{tag}>; convert everything to filled paths")
style = element.attrib.get("style", "").replace(" ", "").lower()
stroke = element.attrib.get("stroke", "none").lower()
if stroke != "none" or ("stroke:" in style and "stroke:none" not in style):
raise ValueError(f"{source}: live strokes are not allowed; expand strokes to paths")
if tag == "path":
if not element.attrib.get("d", "").strip():
raise ValueError(f"{source}: every <path> needs path data")
if element.attrib.get("fill", "").lower() == "none" or "fill:none" in style:
raise ValueError(f"{source}: paths must be filled outlines")
path_count += 1
if path_count == 0:
raise ValueError(f"{source}: no paths found")
return min_x, min_y, width, height
def dart_name(icon: dict[str, object]) -> str:
explicit = icon.get("dartName")
if explicit is not None:
value = str(explicit)
else:
parts = str(icon["name"]).split("_")
value = parts[0] + "".join(part.capitalize() for part in parts[1:])
if not DART_NAME_PATTERN.fullmatch(value):
raise ValueError(f"invalid Dart field name: {value}")
return value
def allocate_codepoints(manifest: dict[str, object], allow_allocation: bool) -> bool:
icons = manifest.get("icons")
if not isinstance(icons, list) or not icons:
raise ValueError("manifest.icons must be a non-empty list")
used = {
parse_number(icon["codepoint"], f"icons[{index}].codepoint")
for index, icon in enumerate(icons)
if isinstance(icon, dict) and icon.get("codepoint") is not None
}
next_codepoint = parse_number(manifest.get("codepointStart", "0xE900"), "codepointStart")
changed = False
for index, icon in enumerate(icons):
if not isinstance(icon, dict):
raise ValueError(f"icons[{index}] must be an object")
if icon.get("codepoint") is not None:
continue
if not allow_allocation:
raise ValueError(f"icons[{index}] has no codepoint; rerun with --allocate-codepoints")
while next_codepoint in used:
next_codepoint += 1
if next_codepoint > PRIVATE_USE_END:
raise ValueError("no codepoints remain in the BMP private-use area")
icon["codepoint"] = f"0x{next_codepoint:04X}"
used.add(next_codepoint)
next_codepoint += 1
changed = True
return changed
def validate_icons(manifest: dict[str, object], manifest_dir: Path) -> list[dict[str, object]]:
icons = manifest["icons"]
assert isinstance(icons, list)
names: set[str] = set()
dart_names: set[str] = set()
codepoints: set[int] = set()
validated: list[dict[str, object]] = []
for index, raw_icon in enumerate(icons):
assert isinstance(raw_icon, dict)
name = str(raw_icon.get("name", ""))
if not NAME_PATTERN.fullmatch(name):
raise ValueError(f"icons[{index}].name must be lowercase snake_case")
field_name = dart_name(raw_icon)
codepoint = parse_number(raw_icon.get("codepoint"), f"icons[{index}].codepoint")
if not PRIVATE_USE_START <= codepoint <= PRIVATE_USE_END:
raise ValueError(f"{name}: codepoint must be in U+E000…U+F8FF")
source_value = raw_icon.get("source")
if not isinstance(source_value, str) or not source_value:
raise ValueError(f"{name}: source must be a relative SVG path")
source = (manifest_dir / source_value).resolve()
if source.suffix.lower() != ".svg" or not source.is_file():
raise ValueError(f"{name}: SVG source does not exist: {source}")
if name in names or field_name in dart_names or codepoint in codepoints:
raise ValueError(f"{name}: duplicate name, Dart field, or codepoint")
names.add(name)
dart_names.add(field_name)
codepoints.add(codepoint)
validated.append(
{
**raw_icon,
"name": name,
"glyphName": f"icon_{name}",
"dartName": field_name,
"codepoint": codepoint,
"sourcePath": source,
}
)
return sorted(validated, key=lambda icon: int(icon["codepoint"]))
def build_font(manifest: dict[str, object], manifest_dir: Path, icons: list[dict[str, object]]) -> Path:
family = str(manifest.get("fontFamily", "GopeedIcons"))
units_per_em = parse_number(manifest.get("unitsPerEm", 1024), "unitsPerEm")
ascent = parse_number(manifest.get("ascent", 896), "ascent")
descent = parse_number(manifest.get("descent", -128), "descent")
padding = parse_number(manifest.get("padding", 96), "padding")
if ascent <= 0 or descent >= 0 or ascent - descent != units_per_em:
raise ValueError("ascent must be positive, descent negative, and their span must equal unitsPerEm")
if padding < 0 or padding * 2 >= units_per_em:
raise ValueError("padding must leave positive drawing space")
glyph_order = [".notdef", *(str(icon["glyphName"]) for icon in icons)]
glyphs = {}
metrics = {".notdef": (units_per_em, 0)}
empty_pen = TTGlyphPen(None)
glyphs[".notdef"] = empty_pen.glyph()
for icon in icons:
source = icon["sourcePath"]
assert isinstance(source, Path)
svg_text = source.read_text(encoding="utf-8")
min_x, min_y, width, height = parse_view_box(svg_text, source)
available = units_per_em - padding * 2
scale = min(available / width, available / height)
glyph_width = width * scale
glyph_height = height * scale
left = (units_per_em - glyph_width) / 2
bottom = descent + (units_per_em - glyph_height) / 2
transform = (scale, 0, 0, -scale, left - scale * min_x, bottom + glyph_height + scale * min_y)
glyph_pen = TTGlyphPen(None)
quadratic_pen = Cu2QuPen(glyph_pen, max_err=1.0, reverse_direction=False)
transformed_pen = TransformPen(quadratic_pen, transform)
SVGPath.fromstring(svg_text).draw(transformed_pen)
glyphs[str(icon["glyphName"])] = glyph_pen.glyph()
bounds_pen = BoundsPen(None)
SVGPath.fromstring(svg_text).draw(TransformPen(bounds_pen, transform))
if bounds_pen.bounds is None:
raise ValueError(f"{source}: icon produced no drawable bounds")
metrics[str(icon["glyphName"])] = (units_per_em, round(bounds_pen.bounds[0]))
builder = FontBuilder(units_per_em, isTTF=True)
builder.setupGlyphOrder(glyph_order)
builder.setupCharacterMap({int(icon["codepoint"]): str(icon["glyphName"]) for icon in icons})
builder.setupGlyf(glyphs)
builder.setupHorizontalMetrics(metrics)
builder.setupHorizontalHeader(ascent=ascent, descent=descent)
version = str(manifest.get("version", "1.0.0"))
postscript_name = re.sub(r"[^A-Za-z0-9-]", "", family.replace(" ", "-")) or "GopeedIcons"
builder.setupNameTable(
{
"familyName": family,
"styleName": "Regular",
"uniqueFontIdentifier": f"{family};{version}",
"fullName": family,
"psName": postscript_name,
"version": f"Version {version}",
}
)
builder.setupOS2(
sTypoAscender=ascent,
sTypoDescender=descent,
usWinAscent=ascent,
usWinDescent=-descent,
usWeightClass=400,
usWidthClass=5,
)
builder.setupPost()
builder.setupMaxp()
output = (manifest_dir / str(manifest["fontOutput"])).resolve()
output.parent.mkdir(parents=True, exist_ok=True)
builder.save(output)
return output
def write_dart(manifest: dict[str, object], manifest_dir: Path, icons: list[dict[str, object]]) -> Path:
family = str(manifest.get("fontFamily", "GopeedIcons"))
class_name = str(manifest.get("dartClass", "GopeedIcons"))
if not DART_NAME_PATTERN.fullmatch(class_name):
raise ValueError("dartClass must be a valid Dart class name")
package = manifest.get("fontPackage")
package_argument = "" if package in (None, "") else f", fontPackage: '{package}'"
lines = [
"// Generated by gopeed-file-category-icons. Do not edit by hand.",
"import 'package:flutter/widgets.dart';",
"",
f"abstract final class {class_name} {{",
f" static const String _fontFamily = '{family}';",
]
for icon in icons:
lines.append(
f" static const IconData {icon['dartName']} = IconData(0x{int(icon['codepoint']):04x}, fontFamily: _fontFamily{package_argument});"
)
lines.extend(["}", ""])
output = (manifest_dir / str(manifest["dartOutput"])).resolve()
output.parent.mkdir(parents=True, exist_ok=True)
output.write_text("\n".join(lines), encoding="utf-8")
return output
def main() -> int:
args = parse_args()
manifest_path = args.manifest.resolve()
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
if allocate_codepoints(manifest, args.allocate_codepoints):
manifest_path.write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
manifest_dir = manifest_path.parent
icons = validate_icons(manifest, manifest_dir)
for required in ("fontOutput", "dartOutput"):
if not isinstance(manifest.get(required), str) or not manifest[required]:
raise ValueError(f"manifest.{required} must be a path")
font_output = build_font(manifest, manifest_dir, icons)
dart_output = write_dart(manifest, manifest_dir, icons)
print(f"Built {len(icons)} icons")
print(f"Font: {font_output}")
print(f"Dart: {dart_output}")
return 0
if __name__ == "__main__":
try:
raise SystemExit(main())
except (KeyError, OSError, ValueError, json.JSONDecodeError) as error:
print(f"error: {error}", file=sys.stderr)
raise SystemExit(1)
@@ -0,0 +1,106 @@
#!/usr/bin/env python3
"""Render a light/dark multi-size contact sheet for a generated file-category font."""
from __future__ import annotations
import argparse
import json
import sys
from pathlib import Path
try:
from PIL import Image, ImageDraw, ImageFont
except ImportError as error:
raise SystemExit("Missing Pillow; install scripts/requirements.txt in the skill's .venv") from error
def parse_number(value: object) -> int:
return value if isinstance(value, int) else int(str(value), 0)
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--manifest", required=True, type=Path)
parser.add_argument("--sizes", default="16,20,24,32")
return parser.parse_args()
def draw_centered(
draw: ImageDraw.ImageDraw,
center: tuple[float, float],
char: str,
font: ImageFont.FreeTypeFont,
fill: str,
) -> None:
bounds = draw.textbbox((0, 0), char, font=font)
height = bounds[3] - bounds[1]
advance = draw.textlength(char, font=font)
draw.text(
(center[0] - advance / 2, center[1] - height / 2 - bounds[1]),
char,
font=font,
fill=fill,
)
def main() -> int:
args = parse_args()
manifest_path = args.manifest.resolve()
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
manifest_dir = manifest_path.parent
font_path = (manifest_dir / str(manifest["fontOutput"])).resolve()
if not font_path.is_file():
raise ValueError(f"font does not exist; run the builder first: {font_path}")
sizes = [int(value) for value in args.sizes.split(",") if value.strip()]
if not sizes or any(size <= 0 for size in sizes):
raise ValueError("sizes must contain positive integers")
icons = sorted(manifest["icons"], key=lambda icon: parse_number(icon["codepoint"]))
label_width = 210
cell_width = 112
header_height = 44
row_height = 78
image = Image.new(
"RGB",
(label_width + cell_width * len(sizes), header_height + row_height * len(icons)),
"#F8FAFC",
)
draw = ImageDraw.Draw(image)
label_font = ImageFont.load_default()
draw.text((12, 15), "icon / codepoint", font=label_font, fill="#111827")
for column, size in enumerate(sizes):
x = label_width + column * cell_width
draw.text((x + 42, 15), f"{size}px", font=label_font, fill="#111827")
for row, icon in enumerate(icons):
y = header_height + row * row_height
codepoint = parse_number(icon["codepoint"])
draw.text(
(12, y + 29),
f"{icon['name']} U+{codepoint:04X}",
font=label_font,
fill="#111827",
)
for column, size in enumerate(sizes):
x = label_width + column * cell_width
midpoint = x + cell_width // 2
draw.rectangle((x, y, midpoint, y + row_height), fill="#FFFFFF")
draw.rectangle((midpoint, y, x + cell_width, y + row_height), fill="#111827")
font = ImageFont.truetype(str(font_path), size=size)
draw_centered(draw, (x + cell_width * 0.25, y + row_height / 2), chr(codepoint), font, "#111827")
draw_centered(draw, (x + cell_width * 0.75, y + row_height / 2), chr(codepoint), font, "#F8FAFC")
output_value = manifest.get("previewOutput", "file-category-icons-preview.png")
output = (manifest_dir / str(output_value)).resolve()
output.parent.mkdir(parents=True, exist_ok=True)
image.save(output)
print(f"Preview: {output}")
return 0
if __name__ == "__main__":
try:
raise SystemExit(main())
except (KeyError, OSError, ValueError, json.JSONDecodeError) as error:
print(f"error: {error}", file=sys.stderr)
raise SystemExit(1)
@@ -0,0 +1,2 @@
fonttools==4.59.2
Pillow==11.3.0