rotulo 0.1.0__py3-none-any.whl

rotulo/__init__.py

@@ -0,0 +1,4 @@
+from rotulo.build import build_context, build_font
+from rotulo.params import DISPLAY, READING, Params
+
+__all__ = ["DISPLAY", "READING", "Params", "build_context", "build_font"]

rotulo/__main__.py

@@ -0,0 +1,26 @@
+import argparse
+from pathlib import Path
+
+from rotulo.build import build_font
+from rotulo.params import DISPLAY, READING
+from rotulo.variable import build_variable
+from rotulo.web import to_woff2
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="rotulo", description="Build the Rotulo fonts.")
+    parser.add_argument("--out", type=Path, default=Path("build"))
+    parser.add_argument("--no-variable", action="store_true", help="skip the variable font")
+    parser.add_argument("--web", type=Path, help="also write WOFF2 files into this directory")
+    args = parser.parse_args()
+    for params, style, weight_class in ((DISPLAY, "Display", 200), (READING, "Lectura", 500)):
+        print(build_font(params, style, weight_class, args.out))
+    if not args.no_variable:
+        print(build_variable(args.out))
+    if args.web:
+        for path in to_woff2(args.out, args.web):
+            print(path)
+
+
+if __name__ == "__main__":
+    main()

rotulo/accents.py

@@ -0,0 +1,50 @@
+from rotulo.chars import DOTLESS_I
+from rotulo.context import Context
+from rotulo.skeleton import Stroke
+
+
+def add_accents(ctx: Context) -> None:
+    g, xh, pen, sh = ctx.glyphs, ctx.xh, ctx.pen, ctx.sharp
+
+    def compose(ch: str, base: str, extra: list[Stroke]) -> None:
+        b = g[base]
+        ctx.define(ch, b.width, b.left, b.right, b.strokes, [*b.details, *extra], b.ax)
+
+    def grave(x: float, y: float) -> Stroke:
+        return pen().m(x + xh * 0.06, y).l(x - xh * 0.08, y + xh * 0.18)
+
+    def circumflex(x: float, y: float) -> Stroke:
+        return pen(sharp=sh).m(x - xh * 0.12, y).l(x, y + xh * 0.16).l(x + xh * 0.12, y)
+
+    def cedilla(x: float) -> Stroke:
+        y0, r = -(ctx.w + ctx.gap * 0.5), xh * 0.08
+        return pen().m(x, y0).a(x, y0 - r, r, r, 90, -150)
+
+    marks = {
+        "acute": ctx.acute,
+        "grave": grave,
+        "circumflex": circumflex,
+    }
+    lower = {"a": "a", "e": "e", "i": DOTLESS_I, "o": "o", "u": "u"}
+    upper = {"A": "A", "E": "E", "I": "I", "O": "O", "U": "U"}
+    table = {
+        "acute": ("áéíóú", "ÁÉÍÓÚ"),
+        "grave": ("àèìòù", "ÀÈÌÒÙ"),
+        "circumflex": ("âêîôû", "ÂÊÎÔÛ"),
+    }
+    for mark, (low, up) in table.items():
+        draw = marks[mark]
+        for ch, base in zip(low, lower.values(), strict=True):
+            compose(ch, base, [draw(0 if base == DOTLESS_I else g[base].ax, ctx.yt)])
+        for ch, base in zip(up, upper.values(), strict=True):
+            compose(ch, base, [draw(g[base].ax, ctx.yc)])
+    for ch, base in (("ñ", "n"), ("ã", "a"), ("õ", "o")):
+        compose(ch, base, [ctx.tilde(g[base].ax, ctx.yt)])
+    for ch, base in (("Ñ", "N"), ("Ã", "A"), ("Õ", "O")):
+        compose(ch, base, [ctx.tilde(g[base].ax, ctx.yc)])
+    for ch, base in (("ü", "u"), ("ë", "e"), ("ï", DOTLESS_I), ("ÿ", "y")):
+        compose(ch, base, ctx.dieresis(0 if base == DOTLESS_I else g[base].ax, ctx.yt))
+    for ch, base in (("Ü", "U"), ("Ë", "E"), ("Ï", "I")):
+        compose(ch, base, ctx.dieresis(g[base].ax, ctx.yc))
+    compose("ç", "c", [cedilla(g["c"].ax)])
+    compose("Ç", "C", [cedilla(g["C"].ax)])

rotulo/build.py

@@ -0,0 +1,97 @@
+from pathlib import Path
+from typing import Any
+
+from fontTools.colorLib.builder import ColorPaletteType, buildCOLR, buildCPAL
+from fontTools.feaLib.builder import addOpenTypeFeaturesFromString
+from fontTools.fontBuilder import FontBuilder
+
+from rotulo.glyphset import GlyphSet, build_context, collect, glyph_name
+from rotulo.params import Params
+from rotulo.spacing import kerning
+
+FAMILY = "Rotulo"
+VERSION = "0.1.0"
+LICENSE = "This Font Software is licensed under the SIL Open Font License, Version 1.1."
+LICENSE_URL = "https://openfontlicense.org"
+DETAIL_LIGHT = (0x2F / 255, 0x5D / 255, 0x62 / 255, 1.0)
+DETAIL_DARK = (0x7F / 255, 0xB7 / 255, 0xB5 / 255, 1.0)
+
+__all__ = ["build_context", "build_font", "font_builder", "glyph_name"]
+
+
+def features(gs: GlyphSet) -> str:
+    blocks = []
+    rules = [
+        f"    pos {gs.names[a]} {gs.names[b]} {v};"
+        for (a, b), v in sorted(kerning(gs.ctx).items())
+        if a in gs.names and b in gs.names
+    ]
+    if rules:
+        blocks.append("feature kern {\n" + "\n".join(rules) + "\n} kern;")
+    if gs.alternates:
+        subs = "\n".join(f"    sub {base} by {alt};" for base, alt in gs.alternates.items())
+        blocks.append(
+            'feature ss01 {\n    featureNames { name "Lectura"; };\n' + subs + "\n} ss01;"
+        )
+    return "\n".join(blocks) + "\n"
+
+
+def font_builder(params: Params, style: str, weight_class: int, gs: GlyphSet) -> Any:
+    fb = FontBuilder(1000, isTTF=True)
+    fb.setupGlyphOrder(gs.order)
+    fb.setupCharacterMap(gs.cmap)
+    fb.setupGlyf(gs.glyphs)
+    glyf = fb.font["glyf"]
+    fb.setupHorizontalMetrics({n: (gs.advances[n], getattr(glyf[n], "xMin", 0)) for n in gs.order})
+    y_max = max(getattr(glyf[n], "yMax", 0) for n in gs.order)
+    y_min = min(getattr(glyf[n], "yMin", 0) for n in gs.order)
+    fb.setupHorizontalHeader(ascent=y_max, descent=y_min)
+    ps = f"{FAMILY}-{style}"
+    fb.setupNameTable(
+        {
+            "familyName": FAMILY,
+            "styleName": style,
+            "uniqueFontIdentifier": f"{ps};{VERSION}",
+            "fullName": f"{FAMILY} {style}",
+            "psName": ps,
+            "version": f"Version {VERSION}",
+            "licenseDescription": LICENSE,
+            "licenseInfoURL": LICENSE_URL,
+        }
+    )
+    fb.setupOS2(
+        usWeightClass=weight_class,
+        sTypoAscender=round(params.ascender),
+        sTypoDescender=round(params.descender),
+        sTypoLineGap=200,
+        usWinAscent=y_max,
+        usWinDescent=-y_min,
+        sxHeight=round(params.x_height),
+        sCapHeight=round(params.cap_height),
+        fsType=0,
+    )
+    fb.setupPost()
+    if gs.layers:
+        fb.font["COLR"] = buildCOLR(gs.layers, version=0)
+        fb.font["CPAL"] = buildCPAL(
+            [[DETAIL_LIGHT], [DETAIL_DARK]],
+            paletteTypes=[
+                ColorPaletteType.USABLE_WITH_LIGHT_BACKGROUND,
+                ColorPaletteType.USABLE_WITH_DARK_BACKGROUND,
+            ],
+        )
+    addOpenTypeFeaturesFromString(fb.font, features(gs))
+    return fb
+
+
+def build_font(params: Params, style: str, weight_class: int, out: Path, hint: bool = True) -> Path:
+    gs = collect(params)
+    fb = font_builder(params, style, weight_class, gs)
+    out.mkdir(parents=True, exist_ok=True)
+    path = out / f"{FAMILY}-{style}.ttf"
+    fb.save(str(path))
+    if hint:
+        from ttfautohint import ttfautohint
+
+        ttfautohint(in_file=str(path), out_file=str(path))
+    return path

rotulo/capsule.py

@@ -0,0 +1,104 @@
+import math
+from collections.abc import Sequence
+
+from rotulo.skeleton import Point, Stroke
+
+Cubic = tuple[Point, Point, Point, Point]
+Contour = list[Cubic]
+
+KAPPA = 4 / 3 * math.tan(math.pi / 8)
+
+
+def _sub(a: Point, b: Point) -> Point:
+    return (a[0] - b[0], a[1] - b[1])
+
+
+def _add(a: Point, b: Point, s: float = 1.0) -> Point:
+    return (a[0] + b[0] * s, a[1] + b[1] * s)
+
+
+def _unit(v: Point) -> Point:
+    n = math.hypot(*v)
+    return (v[0] / n, v[1] / n) if n > 1e-9 else (1.0, 0.0)
+
+
+def _normal(t: Point) -> Point:
+    return (-t[1], t[0])
+
+
+def _split(c: Cubic) -> tuple[Cubic, Cubic]:
+    p0, p1, p2, p3 = c
+
+    def mid(a: Point, b: Point) -> Point:
+        return ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2)
+
+    a, b, e = mid(p0, p1), mid(p1, p2), mid(p2, p3)
+    f, g = mid(a, b), mid(b, e)
+    h = mid(f, g)
+    return (p0, a, f, h), (h, g, e, p3)
+
+
+def _tangents(c: Cubic) -> tuple[Point, Point]:
+    p0, p1, p2, p3 = c
+    start = _sub(p1, p0) if math.hypot(*_sub(p1, p0)) > 1e-6 else _sub(p2, p0)
+    end = _sub(p3, p2) if math.hypot(*_sub(p3, p2)) > 1e-6 else _sub(p3, p1)
+    return _unit(start), _unit(end)
+
+
+def _offset(c: Cubic, h: float) -> Cubic:
+    p0, p1, p2, p3 = c
+    t0, t3 = _tangents(c)
+    turn = math.acos(max(-1.0, min(1.0, t0[0] * t3[0] + t0[1] * t3[1])))
+    chord = math.hypot(*_sub(p3, p0))
+    if turn > 1e-3 and chord > 1e-6:
+        radius = chord / (2 * math.sin(turn / 2))
+        cross = t0[0] * t3[1] - t0[1] * t3[0]
+        if (cross > 0) == (h > 0):
+            h = math.copysign(min(abs(h), radius * 0.95), h)
+    q0 = _add(p0, _normal(t0), h)
+    q3 = _add(p3, _normal(t3), h)
+    scale = math.hypot(*_sub(q3, q0)) / chord if chord > 1e-6 else 1.0
+    return q0, _add(q0, _sub(p1, p0), scale), _add(q3, _sub(p2, p3), scale), q3
+
+
+def _cap(center: Point, tangent: Point, h: float) -> list[Cubic]:
+    n = _normal(tangent)
+    left, tip, right = _add(center, n, h), _add(center, tangent, h), _add(center, n, -h)
+    k = KAPPA * h
+    return [
+        (left, _add(left, tangent, k), _add(tip, n, k), tip),
+        (tip, _add(tip, n, -k), _add(right, tangent, k), right),
+    ]
+
+
+def _piece(c: Cubic, h: float) -> Contour:
+    t0, t3 = _tangents(c)
+    left = _offset(c, h)
+    right = _offset(c, -h)
+    back: Cubic = (right[3], right[2], right[1], right[0])
+    return [left, *_cap(c[3], t3, h), back, *_cap(c[0], (-t0[0], -t0[1]), h)]
+
+
+def _cubics(stroke: Stroke, dx: float) -> list[Cubic]:
+    out: list[Cubic] = []
+    cur: Point | None = None
+    for kind, pts in stroke.finish():
+        moved = [(x + dx, y) for x, y in pts]
+        if kind == "M":
+            cur = moved[0]
+            continue
+        assert cur is not None
+        if kind == "L":
+            end = moved[0]
+            d = _sub(end, cur)
+            out.append((cur, _add(cur, d, 1 / 3), _add(cur, d, 2 / 3), end))
+        else:
+            c1, c2, end = moved
+            out.extend(_split((cur, c1, c2, end)))
+        cur = moved[-1]
+    return out
+
+
+def capsules(strokes: Sequence[Stroke], weight: float, dx: float) -> list[Contour]:
+    h = weight / 2
+    return [_piece(c, h) for stroke in strokes for c in _cubics(stroke, dx)]

rotulo/chars.py

@@ -0,0 +1,13 @@
+DOTLESS_I = chr(0x131)
+EN_DASH = chr(0x2013)
+EM_DASH = chr(0x2014)
+PRIME = chr(0x2032)
+DOUBLE_PRIME = chr(0x2033)
+LEFT_SINGLE = chr(0x2018)
+RIGHT_SINGLE = chr(0x2019)
+LEFT_DOUBLE = chr(0x201C)
+RIGHT_DOUBLE = chr(0x201D)
+LEFT_GUILLEMET = chr(0xAB)
+RIGHT_GUILLEMET = chr(0xBB)
+ELLIPSIS = chr(0x2026)
+MIDDLE_DOT = chr(0xB7)

rotulo/context.py

@@ -0,0 +1,142 @@
+import math
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from typing import Literal
+
+from rotulo.params import Params
+from rotulo.skeleton import DEG, Point, Stroke, Transform
+
+Side = Literal["h", "o", "v"]
+
+
+@dataclass
+class Glyph:
+    width: float
+    left: Side
+    right: Side
+    strokes: list[Stroke]
+    details: list[Stroke]
+    ax: float
+
+
+@dataclass(frozen=True)
+class BarFillet:
+    th: float
+    c: Point
+    phi: float
+
+
+@dataclass
+class Context:
+    p: Params
+    glyphs: dict[str, Glyph] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        p = self.p
+        self.xh = p.x_height
+        self.cap = p.cap_height
+        self.asc = p.ascender
+        self.desc = p.descender
+        self.w = p.weight
+        self.o = self.xh * p.overshoot / 100
+        self.gap = p.gap
+        self.bowl = self.xh * p.width * 0.96
+        self.nw = self.bowl * 0.9
+        self.h2 = self.nw / 2
+        self.ry = self.xh / 2 + self.o
+        self.yt = self.xh + self.w + self.gap
+        self.yc = self.cap + self.w + self.gap
+        self.dot_len = self.xh * 0.1 + self.w * 0.3
+        self.dv = (
+            0.0 if p.dot == "round" else self.dot_len if p.dot == "line" else self.dot_len * 0.7
+        )
+        self.hr = self.xh * 0.3
+        self.hs = p.tail_close
+        self.hx = self.hr * p.tail
+        self.lr = self.xh * 0.2
+        self.sharp = 0.35
+        self.fig = self.cap * 0.58
+
+    def pen(self, transform: Transform | None = None, sharp: float = 1.0) -> Stroke:
+        return Stroke(self.p.corner * sharp, transform)
+
+    def define(
+        self,
+        ch: str,
+        width: float,
+        left: Side,
+        right: Side,
+        strokes: Sequence[Stroke],
+        details: Sequence[Stroke] = (),
+        ax: float | None = None,
+    ) -> None:
+        self.glyphs[ch] = Glyph(
+            width, left, right, list(strokes), list(details), width / 2 if ax is None else ax
+        )
+
+    def ring(
+        self, cx: float, cy: float, rx: float, ry: float, transform: Transform | None = None
+    ) -> Stroke:
+        return self.pen(transform).a(cx, cy, rx, ry, 90, 450)
+
+    def dot(self, x: float, y: float, transform: Transform | None = None) -> Stroke:
+        s = self.pen(transform)
+        if self.p.dot == "round":
+            return s.m(x, y).l(x + 0.01, y)
+        if self.p.dot == "line":
+            return s.m(x, y).l(x, y + self.dot_len)
+        return s.m(x - self.dot_len * 0.35, y).l(x + self.dot_len * 0.35, y + self.dot_len * 0.7)
+
+    def acute(self, x: float, y: float) -> Stroke:
+        return self.pen().m(x - self.xh * 0.06, y).l(x + self.xh * 0.08, y + self.xh * 0.18)
+
+    def dieresis(self, x: float, y: float) -> list[Stroke]:
+        return [self.dot(x - self.xh * 0.15, y), self.dot(x + self.xh * 0.15, y)]
+
+    def tilde(self, x: float, y: float) -> Stroke:
+        t, a = self.xh * 0.2, self.xh * 0.06
+        return (
+            self.pen().a(x - t / 2, y + a, t / 2, a, 180, 0).a(x + t / 2, y + a, t / 2, a, 180, 360)
+        )
+
+    def soft_tail(
+        self,
+        x: float,
+        top: float,
+        wx: float,
+        sweep: float,
+        base: Stroke | None = None,
+        bottom: float | None = None,
+    ) -> Stroke:
+        bot = self.desc if bottom is None else bottom
+        hr = self.hr
+        ys = bot + hr * 1.6
+        s = base if base is not None else self.pen().m(x, top)
+        return (
+            s.l(x, ys)
+            .c(x, ys - (ys - bot) * 0.55, x - wx * 0.45, bot, x - wx, bot)
+            .a(x - wx, bot + hr, wx * 0.8, hr, -90, -sweep)
+        )
+
+    def bar_fillet(
+        self, cx: float, cy: float, rx: float, ry: float, bar_y: float, r: float, side: int
+    ) -> BarFillet:
+        def at(th: float) -> tuple[Point, Point]:
+            nx, ny = math.cos(th) / rx, math.sin(th) / ry
+            nl = math.hypot(nx, ny)
+            e = (cx + rx * math.cos(th), cy + ry * math.sin(th))
+            return e, (e[0] - r * nx / nl, e[1] - r * ny / nl)
+
+        def f(th: float) -> float:
+            return at(th)[1][1] - (bar_y + side * r)
+
+        lo, hi = (0.0, math.pi / 2) if side > 0 else (-math.pi / 2, 0.0)
+        for _ in range(50):
+            mid = (lo + hi) / 2
+            if math.copysign(1, f(mid)) == math.copysign(1, f(lo)):
+                lo = mid
+            else:
+                hi = mid
+        th = (lo + hi) / 2
+        e, c = at(th)
+        return BarFillet(th / DEG, c, math.atan2(e[1] - c[1], e[0] - c[0]) / DEG)

rotulo/figures.py

@@ -0,0 +1,217 @@
+import math
+
+from rotulo.chars import DOUBLE_PRIME, EN_DASH, PRIME
+from rotulo.context import Context
+from rotulo.skeleton import DEG, Stroke
+
+
+def two_end(cx: float, cy: float, rx: float, ry: float) -> float:
+    def f(deg: float) -> float:
+        t = deg * DEG
+        px, py = cx + rx * math.cos(t), cy + ry * math.sin(t)
+        tx, ty = rx * math.sin(t), -ry * math.cos(t)
+        return tx * (0 - py) - ty * (0 - px)
+
+    prev = 150.0
+    for step in range(1, 300):
+        cur = 150.0 - step
+        if math.copysign(1, f(cur)) != math.copysign(1, f(prev)):
+            lo, hi = cur, prev
+            for _ in range(40):
+                mid = (lo + hi) / 2
+                if math.copysign(1, f(mid)) == math.copysign(1, f(lo)):
+                    lo = mid
+                else:
+                    hi = mid
+            return (lo + hi) / 2
+        prev = cur
+    return -25.0
+
+
+def add_figures(ctx: Context) -> None:
+    p, pen, d = ctx.p, ctx.pen, ctx.define
+    cap, xh, asc, desc, o, w, gap, dot_len, dv, fig = (
+        ctx.cap,
+        ctx.xh,
+        ctx.asc,
+        ctx.desc,
+        ctx.o,
+        ctx.w,
+        ctx.gap,
+        ctx.dot_len,
+        ctx.dv,
+        ctx.fig,
+    )
+
+    def zero_detail() -> list[Stroke]:
+        if p.zero == "plain":
+            return []
+        if p.zero == "dot":
+            return [ctx.dot(fig / 2, cap / 2 - dv / 2)]
+        th = math.atan(1.6)
+        c, s = math.cos(th), math.sin(th)
+        re = 1 / math.sqrt((c / (fig / 2)) ** 2 + (s / (cap / 2)) ** 2)
+        ln = max(12.0, re - w - gap)
+        return [pen().m(fig / 2 - ln * c, cap / 2 - ln * s).l(fig / 2 + ln * c, cap / 2 + ln * s)]
+
+    d("0", fig, "o", "o", [ctx.ring(fig / 2, cap / 2, fig / 2, cap / 2 + o)], zero_detail())
+    if p.one_flag:
+        d(
+            "1",
+            fig,
+            "o",
+            "o",
+            [
+                pen()
+                .m(fig * 0.05, cap * 0.68)
+                .c(fig * 0.3, cap * 0.76, fig * 0.5, cap * 0.86, fig * 0.6, cap)
+                .l(fig * 0.6, 0)
+            ],
+        )
+    else:
+        d("1", fig, "o", "o", [pen().m(fig * 0.2, cap * 0.82).l(fig * 0.6, cap).l(fig * 0.6, 0)])
+    end2 = two_end(fig / 2, cap - fig / 2, fig / 2, fig / 2 + o)
+    d(
+        "2",
+        fig,
+        "o",
+        "o",
+        [pen().a(fig / 2, cap - fig / 2, fig / 2, fig / 2 + o, 155, end2).l(0, 0).l(fig, 0)],
+    )
+    d(
+        "3",
+        fig,
+        "o",
+        "o",
+        [
+            pen()
+            .a(fig / 2, cap * 0.76, fig * 0.45, cap * 0.24, 150, -90)
+            .a(fig / 2, cap * 0.26, fig / 2, cap * 0.26, 90, -150)
+        ],
+    )
+    d(
+        "4",
+        fig,
+        "o",
+        "o",
+        [pen().m(fig * 0.72, 0).l(fig * 0.72, cap).l(0, cap * 0.3).l(fig * 0.72, cap * 0.3)],
+    )
+    d(
+        "5",
+        fig,
+        "o",
+        "o",
+        [
+            pen()
+            .m(fig * 0.9, cap)
+            .l(fig * 0.12, cap)
+            .a(fig / 2, cap * 0.31, fig / 2, cap * 0.31 + o, 140, -145)
+        ],
+    )
+    d(
+        "6",
+        fig,
+        "o",
+        "o",
+        [
+            pen()
+            .m(fig * 0.8, cap)
+            .c(fig * 0.38, cap * 0.98, 0, cap * 0.78, 0, cap * 0.31)
+            .a(fig / 2, cap * 0.31, fig / 2, cap * 0.31 + o, 180, 540)
+        ],
+    )
+    d("7", fig, "o", "o", [pen().m(0, cap).l(fig, cap).l(fig * 0.3, 0)])
+    d(
+        "8",
+        fig,
+        "o",
+        "o",
+        [
+            ctx.ring(fig / 2, cap * 0.76, fig * 0.42, cap * 0.24),
+            ctx.ring(fig / 2, cap * 0.26, fig / 2, cap * 0.26 + o),
+        ],
+    )
+    if p.nine_straight:
+        d(
+            "9",
+            fig,
+            "o",
+            "o",
+            [
+                ctx.ring(fig / 2, cap * 0.69, fig / 2, cap * 0.31 + o),
+                pen().m(fig, cap * 0.69).l(fig, 0),
+            ],
+        )
+    else:
+        d(
+            "9",
+            fig,
+            "o",
+            "o",
+            [pen().a(fig / 2, cap * 0.69, fig / 2, cap * 0.31 + o, -20, 340).l(fig * 0.22, 0)],
+        )
+
+    d(".", 0, "v", "v", [], [ctx.dot(0, 0)])
+    d(",", 0, "v", "v", [], [pen().m(0, dot_len).l(-dot_len * 0.3, -dot_len * 0.8)])
+    d(":", 0, "v", "v", [], [ctx.dot(0, 0), ctx.dot(0, xh - dv)])
+    d(
+        ";",
+        0,
+        "v",
+        "v",
+        [],
+        [pen().m(0, dot_len).l(-dot_len * 0.3, -dot_len * 0.8), ctx.dot(0, xh - dv)],
+    )
+    d("-", xh * 0.4, "v", "v", [pen().m(0, xh * 0.48).l(xh * 0.4, xh * 0.48)])
+    d(EN_DASH, xh * 0.8, "v", "v", [pen().m(0, xh * 0.48).l(xh * 0.8, xh * 0.48)])
+    qw, qs = cap * 0.5, dv + w + gap
+
+    def inv(x: float, y: float) -> tuple[float, float]:
+        return qw - x, xh - y
+
+    d(
+        "?",
+        qw,
+        "o",
+        "o",
+        [pen().a(qw / 2, cap - qw / 2, qw / 2, qw / 2 + o, 160, -90).l(qw / 2, qs)],
+        [ctx.dot(qw / 2, 0)],
+    )
+    d(
+        "¿",
+        qw,
+        "o",
+        "o",
+        [pen(inv).a(qw / 2, cap - qw / 2, qw / 2, qw / 2 + o, 160, -90).l(qw / 2, qs)],
+        [ctx.dot(qw / 2, xh - dv)],
+    )
+    d("!", 0, "o", "o", [pen().m(0, cap).l(0, qs)], [ctx.dot(0, 0)])
+    d("¡", 0, "o", "o", [pen().m(0, xh - qs).l(0, xh - cap)], [ctx.dot(0, xh - dv)])
+    dr = xh * 0.13
+    d("°", dr * 2, "v", "v", [ctx.ring(dr, cap - dr, dr, dr)])
+    d(PRIME, xh * 0.12, "v", "v", [pen().m(xh * 0.12, cap).l(0, cap - xh * 0.3)])
+    d(
+        DOUBLE_PRIME,
+        xh * 0.32,
+        "v",
+        "v",
+        [
+            pen().m(xh * 0.12, cap).l(0, cap - xh * 0.3),
+            pen().m(xh * 0.32, cap).l(xh * 0.2, cap - xh * 0.3),
+        ],
+    )
+    d("'", 0, "v", "v", [pen().m(0, cap).l(0, cap - xh * 0.28)])
+    d(
+        '"',
+        xh * 0.2,
+        "v",
+        "v",
+        [
+            pen().m(0, cap).l(0, cap - xh * 0.28),
+            pen().m(xh * 0.2, cap).l(xh * 0.2, cap - xh * 0.28),
+        ],
+    )
+    pw, pm, ph = xh * 0.24, (asc + desc) / 2, (asc - desc) / 2
+    d("(", pw, "v", "v", [pen().a(pw * 2.4, pm, pw * 2.4, ph, 130, 230)])
+    d(")", pw, "v", "v", [pen().a(-pw * 1.4, pm, pw * 2.4, ph, 50, -50)])
+    d("/", xh * 0.5, "v", "v", [pen().m(0, desc * 0.5).l(xh * 0.5, asc)])