@arraypress/covers 1.0.0 → 1.1.0

package/src/type/sfnt.js

@@ -0,0 +1,258 @@
+/**
+ * A small TrueType reader in plain JavaScript: character map, advances,
+ * pair kerning (GPOS pair adjustment, incl. extension lookups, and the old
+ * `kern` table) and glyph outlines (`glyf`, simple and composite).
+ *
+ * It's the outliner where HarfBuzz can't run (a Cloudflare Worker forbids
+ * compiling WebAssembly at runtime, which harfbuzzjs needs), and what
+ * live-text mode measures with. It doesn't do ligatures, complex scripts,
+ * CFF (`OTTO`) outlines or variation deltas (a variable font draws its
+ * default instance); HarfBuzz does all of those where it's available.
+ *
+ * @module type/sfnt
+ */
+
+import { pairKerning } from './kern.js';
+import { familyName } from './name.js';
+
+/**
+ * @typedef {object} JsFace
+ * @property {'js'} kind
+ * @property {number} upem
+ * @property {number} ascender
+ * @property {number} descender
+ * @property {number} capHeight
+ * @property {(gid: number) => string} glyphToPath - Outline in font units, y up.
+ * @property {(text: string) => { gid: number, cluster: number, advance: number }[]} shape - Glyphs with kerned advances, font units.
+ * @property {Record<string, { min: number, default: number, max: number }>} axes - Variation axes (fvar), if any.
+ * @property {string} family - The font's family name (name ID 1/16), if found.
+ */
+
+/**
+ * Parse a TrueType font.
+ *
+ * @param {Uint8Array} bytes - sfnt bytes (decoded from WOFF already).
+ * @returns {JsFace}
+ * @throws {TypeError} On a CFF font or one without the tables it needs.
+ */
+export function parseSfnt(bytes) {
+  const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const tag = v.getUint32(0);
+  if (tag === 0x4f54544f) throw new TypeError('This font has CFF outlines (OTTO), which the JavaScript outliner can\'t draw: use a TrueType (glyf) font here, or HarfBuzz');
+  /** @type {Record<string, number>} */
+  const tables = {};
+  const n = v.getUint16(4);
+  for (let i = 0; i < n; i++) {
+    const o = 12 + i * 16;
+    tables[String.fromCharCode(bytes[o], bytes[o + 1], bytes[o + 2], bytes[o + 3])] = v.getUint32(o + 8);
+  }
+  for (const t of ['head', 'hhea', 'hmtx', 'maxp', 'cmap', 'loca', 'glyf']) if (tables[t] == null) throw new TypeError(`Font has no ${t} table`);
+  const u16 = (/** @type {number} */ o) => v.getUint16(o);
+  const i16 = (/** @type {number} */ o) => v.getInt16(o);
+  const u32 = (/** @type {number} */ o) => v.getUint32(o);
+
+  const upem = u16(tables.head + 18);
+  const longLoca = i16(tables.head + 50) === 1;
+  const ascender = i16(tables.hhea + 4);
+  const descender = i16(tables.hhea + 6);
+  const numH = u16(tables.hhea + 34);
+  const numGlyphs = u16(tables.maxp + 4);
+  let capHeight = 0;
+  if (tables['OS/2'] != null && u16(tables['OS/2']) >= 2) capHeight = i16(tables['OS/2'] + 88);
+
+  const advance = (/** @type {number} */ g) => u16(tables.hmtx + 4 * Math.min(g, numH - 1));
+
+  // cmap: prefer a full-repertoire (format 12) subtable, else BMP (format 4).
+  /** @type {(cp: number) => number} */
+  let cmap = () => 0;
+  {
+    const base = tables.cmap;
+    const count = u16(base + 2);
+    let best = -1;
+    let bestRank = -1;
+    for (let i = 0; i < count; i++) {
+      const pid = u16(base + 4 + i * 8);
+      const eid = u16(base + 6 + i * 8);
+      const off = base + u32(base + 8 + i * 8);
+      const fmt = u16(off);
+      const rank = fmt === 12 && (pid === 3 || pid === 0) ? 3 : fmt === 4 && ((pid === 3 && (eid === 1 || eid === 10)) || pid === 0) ? 2 : -1;
+      if (rank > bestRank) { bestRank = rank; best = off; }
+    }
+    if (best >= 0 && u16(best) === 4) {
+      const segX2 = u16(best + 6);
+      const ends = best + 14;
+      const starts = ends + segX2 + 2;
+      const deltas = starts + segX2;
+      const ranges = deltas + segX2;
+      cmap = (cp) => {
+        if (cp > 0xffff) return 0;
+        for (let s = 0; s < segX2; s += 2) {
+          if (cp > u16(ends + s)) continue;
+          const start = u16(starts + s);
+          if (cp < start) return 0;
+          const ro = u16(ranges + s);
+          if (!ro) return (cp + i16(deltas + s)) & 0xffff;
+          const g = u16(ranges + s + ro + (cp - start) * 2);
+          return g ? (g + i16(deltas + s)) & 0xffff : 0;
+        }
+        return 0;
+      };
+    } else if (best >= 0) {
+      const groups = u32(best + 12);
+      cmap = (cp) => {
+        let lo = 0;
+        let hi = groups - 1;
+        while (lo <= hi) {
+          const mid = (lo + hi) >> 1;
+          const g = best + 16 + mid * 12;
+          if (cp < u32(g)) hi = mid - 1;
+          else if (cp > u32(g + 4)) lo = mid + 1;
+          else return u32(g + 8) + (cp - u32(g));
+        }
+        return 0;
+      };
+    }
+  }
+
+  const kern = pairKerning(v, tables);
+
+  /** @param {number} g @returns {[number, number]} */
+  const locaRange = (g) => (longLoca
+    ? [u32(tables.loca + g * 4), u32(tables.loca + g * 4 + 4)]
+    : [u16(tables.loca + g * 2) * 2, u16(tables.loca + g * 2 + 2) * 2]);
+
+  /**
+   * A glyph's contours as points `[x, y, onCurve]`, composites resolved.
+   *
+   * @param {number} g
+   * @param {number} depth
+   * @returns {[number, number, boolean][][]}
+   */
+  const contours = (g, depth = 0) => {
+    if (g >= numGlyphs || depth > 8) return [];
+    const [start, end] = locaRange(g);
+    if (end <= start) return [];
+    const o = tables.glyf + start;
+    const nc = i16(o);
+    if (nc >= 0) {
+      const endPts = [];
+      for (let i = 0; i < nc; i++) endPts.push(u16(o + 10 + i * 2));
+      const count = nc ? endPts[nc - 1] + 1 : 0;
+      let p = o + 10 + nc * 2;
+      p += 2 + u16(p);
+      const flags = [];
+      while (flags.length < count) {
+        const f = bytes[p++];
+        flags.push(f);
+        if (f & 8) { let r = bytes[p++]; while (r--) flags.push(f); }
+      }
+      const xs = [];
+      let x = 0;
+      for (const f of flags) {
+        if (f & 2) { const d = bytes[p++]; x += f & 16 ? d : -d; } else if (!(f & 16)) { x += i16(p); p += 2; }
+        xs.push(x);
+      }
+      const ys = [];
+      let y = 0;
+      for (const f of flags) {
+        if (f & 4) { const d = bytes[p++]; y += f & 32 ? d : -d; } else if (!(f & 32)) { y += i16(p); p += 2; }
+        ys.push(y);
+      }
+      const out = [];
+      let s = 0;
+      for (const e of endPts) {
+        const c = [];
+        for (let i = s; i <= e; i++) c.push(/** @type {[number, number, boolean]} */ ([xs[i], ys[i], Boolean(flags[i] & 1)]));
+        out.push(c);
+        s = e + 1;
+      }
+      return out;
+    }
+    // Composite.
+    const out = [];
+    let p = o + 10;
+    for (;;) {
+      const f = u16(p);
+      const gi = u16(p + 2);
+      p += 4;
+      let dx;
+      let dy;
+      if (f & 1) { dx = f & 2 ? i16(p) : 0; dy = f & 2 ? i16(p + 2) : 0; p += 4; } else { dx = f & 2 ? v.getInt8(p) : 0; dy = f & 2 ? v.getInt8(p + 1) : 0; p += 2; }
+      let a = 1; let b = 0; let c = 0; let d = 1;
+      const f2 = (/** @type {number} */ q) => i16(q) / 16384;
+      if (f & 8) { a = d = f2(p); p += 2; } else if (f & 0x40) { a = f2(p); d = f2(p + 2); p += 4; } else if (f & 0x80) { a = f2(p); b = f2(p + 2); c = f2(p + 4); d = f2(p + 6); p += 8; }
+      for (const contour of contours(gi, depth + 1)) {
+        out.push(contour.map(([px, py, on]) => /** @type {[number, number, boolean]} */ ([px * a + py * c + dx, px * b + py * d + dy, on])));
+      }
+      if (!(f & 0x20)) break;
+    }
+    return out;
+  };
+
+  /** @type {Map<number, string>} */
+  const paths = new Map();
+  /** @param {number} g @returns {string} */
+  const glyphToPath = (g) => {
+    let d = paths.get(g);
+    if (d !== undefined) return d;
+    d = '';
+    for (const pts of contours(g)) {
+      if (!pts.length) continue;
+      // Start on an on-curve point (or the midpoint of two off-curve ones).
+      let first = pts.findIndex((q) => q[2]);
+      /** @type {[number, number]} */
+      let start;
+      if (first < 0) { start = [(pts[0][0] + pts[1 % pts.length][0]) / 2, (pts[0][1] + pts[1 % pts.length][1]) / 2]; first = 0; } else start = [pts[first][0], pts[first][1]];
+      d += `M${start[0]},${start[1]}`;
+      const n = pts.length;
+      /** @type {[number, number] | null} */
+      let ctrl = null;
+      for (let k = 1; k <= n; k++) {
+        const q = pts[(first + k) % n];
+        if (q[2]) {
+          d += ctrl ? `Q${ctrl[0]},${ctrl[1]} ${q[0]},${q[1]}` : `L${q[0]},${q[1]}`;
+          ctrl = null;
+        } else {
+          if (ctrl) {
+            const mx = (ctrl[0] + q[0]) / 2;
+            const my = (ctrl[1] + q[1]) / 2;
+            d += `Q${ctrl[0]},${ctrl[1]} ${mx},${my}`;
+          }
+          ctrl = [q[0], q[1]];
+        }
+      }
+      if (ctrl) d += `Q${ctrl[0]},${ctrl[1]} ${start[0]},${start[1]}`;
+      d += 'Z';
+    }
+    paths.set(g, d);
+    return d;
+  };
+
+  /** @param {string} text */
+  const shape = (text) => {
+    const out = [];
+    let i = 0;
+    for (const ch of text) {
+      out.push({ gid: cmap(/** @type {number} */ (ch.codePointAt(0))), cluster: i, advance: 0 });
+      i += ch.length;
+    }
+    for (let k = 0; k < out.length; k++) out[k].advance = advance(out[k].gid) + (k + 1 < out.length ? kern(out[k].gid, out[k + 1].gid) : 0);
+    return out;
+  };
+
+  /** @type {Record<string, { min: number, default: number, max: number }>} */
+  const axes = {};
+  if (tables.fvar != null) {
+    const f = tables.fvar;
+    const off = u16(f + 4);
+    const count = u16(f + 8);
+    const size = u16(f + 10);
+    const fixed = (/** @type {number} */ q) => v.getInt32(q) / 65536;
+    for (let k = 0; k < count; k++) {
+      const a = f + off + k * size;
+      axes[String.fromCharCode(bytes[a], bytes[a + 1], bytes[a + 2], bytes[a + 3])] = { min: fixed(a + 4), default: fixed(a + 8), max: fixed(a + 12) };
+    }
+  }
+
+  return { kind: 'js', upem, ascender, descender, capHeight, glyphToPath, shape, axes, family: familyName(v, bytes, tables.name) };
+}

package/src/type/spans.d.ts

@@ -0,0 +1,33 @@
+// Mixed runs in one text layer.
+import type { LoadedFont } from '../fonts.js';
+import type { Shaped } from '../text.js';
+import type { RenderContext } from '../render/context.js';
+import type { Length, Color } from '../index.js';
+
+/** A span as written in a text layer's `spans`. */
+export interface TextSpan {
+  content: string;
+  font?: string; weight?: number; style?: 'normal' | 'italic'; axes?: Record<string, number>;
+  /** Size relative to the layer's (default 1). */
+  scale?: number;
+  /** Size outright. */
+  size?: Length;
+  color?: Color; fill?: Color;
+  /** Em. */
+  letterSpacing?: number;
+  /** Baseline shift (down is positive). */
+  dy?: Length;
+  transform?: 'uppercase' | 'lowercase' | 'none';
+}
+
+/** A resolved span. */
+export interface Span { text: string; face: LoadedFont; scale: number; tracking: number; paint: string | undefined; dy: number }
+
+/** Resolve a layer's spans (faces loaded, sizes relative to `size`). */
+export function loadSpans(layer: { spans: (TextSpan | string)[]; font?: string; weight?: number; style?: string; axes?: Record<string, number>; letterSpacing?: number; transform?: string }, ctx: RenderContext, size: number): Promise<Span[]>;
+/** Spans as lines (split at `\n`, wrapped at `maxWidth`). */
+export function spanLines(spans: Span[], size: number, maxWidth: number, fallbacks: LoadedFont[]): Span[][];
+/** Shape a line of spans as one run. */
+export function shapeSpans(line: Span[], size: number, extra: number, base: LoadedFont | undefined, fallbacks: LoadedFont[]): Shaped;
+/** A line's text. */
+export function spanText(line: Span[]): string;

package/src/type/spans.js

@@ -0,0 +1,138 @@
+/**
+ * Mixed runs in one text layer: `spans`, each with its own font, weight,
+ * style, axes, size, colour, tracking and baseline shift, set one after
+ * another on the same lines (a `\n` in a span starts a new line).
+ *
+ * `spans: [{ content, font, weight, style, axes, scale, size, color, letterSpacing, dy }]`;
+ * anything a span leaves out comes from the layer. `scale` sizes a span
+ * relative to the layer (`size` gives it outright).
+ *
+ * @module type/spans
+ */
+
+import { len } from '../geometry.js';
+import { toHex } from '../color.js';
+import { faceFor } from './line.js';
+import { shapeText } from './fallback.js';
+
+/**
+ * @typedef {object} Span
+ * @property {string} text
+ * @property {import('../fonts.js').LoadedFont} face
+ * @property {number} scale - Size relative to the layer's.
+ * @property {number} tracking - Em.
+ * @property {string | undefined} paint - A colour, or the layer's fill.
+ * @property {number} dy - Baseline shift, px at the layer's size (scales with it).
+ */
+
+/**
+ * Resolve a layer's spans: faces loaded, sizes as multiples of the layer's.
+ *
+ * @param {any} layer
+ * @param {import('../layers.js').RenderContext} ctx
+ * @param {number} size - The layer's size, px.
+ * @returns {Promise<Span[]>}
+ */
+export async function loadSpans(layer, ctx, size) {
+  const out = [];
+  for (const given of layer.spans) {
+    const s = typeof given === 'string' ? { content: given } : given;
+    const face = await faceFor(ctx, { font: s.font ?? layer.font, weight: s.weight ?? layer.weight, style: s.style ?? layer.style, axes: { ...layer.axes, ...s.axes } });
+    const kase = s.transform ?? layer.transform;
+    const raw = String(s.content ?? '').replace(/[\t\r ]+/g, ' ');
+    out.push({
+      text: kase === 'uppercase' ? raw.toUpperCase() : kase === 'lowercase' ? raw.toLowerCase() : raw,
+      face,
+      scale: s.size != null ? len(s.size, ctx.canvas) / size : s.scale ?? 1,
+      tracking: s.letterSpacing ?? layer.letterSpacing ?? -0.02,
+      paint: s.color ?? (typeof s.fill === 'string' ? s.fill : undefined) ? toHex(s.color ?? s.fill) : undefined,
+      dy: len(s.dy, ctx.canvas, 0) / size,
+    });
+  }
+  return out;
+}
+
+/**
+ * Spans as lines: split at `\n`, then (with a finite `maxWidth`) wrapped at
+ * spaces, greedily, at `size`.
+ *
+ * @param {Span[]} spans
+ * @param {number} size
+ * @param {number} maxWidth
+ * @param {import('../fonts.js').LoadedFont[]} fallbacks
+ * @returns {Span[][]}
+ */
+export function spanLines(spans, size, maxWidth, fallbacks) {
+  /** @type {Span[][]} */
+  const lines = [[]];
+  for (const s of spans) {
+    s.text.split('\n').forEach((part, i) => {
+      if (i) lines.push([]);
+      if (part) lines[lines.length - 1].push({ ...s, text: part });
+    });
+  }
+  if (!Number.isFinite(maxWidth)) return lines;
+  /** @type {Span[][]} */
+  const out = [];
+  for (const line of lines) {
+    /** @type {Span[]} */
+    let cur = [];
+    let width = 0;
+    for (const s of line) {
+      for (const word of s.text.split(/(?<= )/)) {
+        const piece = { ...s, text: word };
+        const w = shapeSpans([piece], size, 0, undefined, fallbacks).width;
+        if (cur.length && width + w - trailing(piece, size) > maxWidth) {
+          out.push(trim(cur));
+          cur = [];
+          width = 0;
+        }
+        cur.push(piece);
+        width += w;
+      }
+    }
+    out.push(trim(cur));
+  }
+  return out;
+}
+
+/** @param {Span} s @param {number} size @returns {number} The width of a trailing space, px (it may hang past the line). */
+const trailing = (s, size) => (s.text.endsWith(' ') ? size * s.scale * 0.25 : 0);
+
+/** @param {Span[]} line @returns {Span[]} The line with its ends' spaces trimmed. */
+function trim(line) {
+  if (!line.length) return line;
+  const out = line.map((s) => ({ ...s }));
+  out[0].text = out[0].text.replace(/^ +/, '');
+  out[out.length - 1].text = out[out.length - 1].text.replace(/ +$/, '');
+  return out.filter((s) => s.text);
+}
+
+/**
+ * Shape a line of spans as one run: each span in its face and size, its
+ * glyphs carrying them (and their colour as a paint key).
+ *
+ * @param {Span[]} line
+ * @param {number} size - The layer's size, px.
+ * @param {number} extra - Tracking added everywhere, px (justification).
+ * @param {import('../fonts.js').LoadedFont | undefined} base - The layer's face (its glyphs needn't carry it).
+ * @param {import('../fonts.js').LoadedFont[]} fallbacks
+ * @returns {import('../text.js').Shaped}
+ */
+export function shapeSpans(line, size, extra, base, fallbacks) {
+  /** @type {import('../text.js').Shaped['glyphs']} */
+  const glyphs = [];
+  let x = 0;
+  let at = 0;
+  line.forEach((s, i) => {
+    const sz = size * s.scale;
+    const run = shapeText(s.face, s.text, sz, s.tracking * sz + extra, fallbacks);
+    for (const g of run.glyphs) glyphs.push({ ...g, x: g.x + x, y: g.y - s.dy * size, face: g.face ?? s.face, size: sz, paint: s.paint, cluster: (g.cluster ?? 0) + at });
+    x += run.width + (i < line.length - 1 ? s.tracking * sz + extra : 0);
+    at += s.text.length;
+  });
+  return { glyphs, width: x };
+}
+
+/** @param {Span[]} line @returns {string} The line's text. */
+export const spanText = (line) => line.map((s) => s.text).join('');

package/src/type/symbols.d.ts

@@ -0,0 +1,7 @@
+// Built-in symbols, drawn as shapes (the last glyph fallback).
+import type { LoadedFont } from '../fonts.js';
+
+/** The symbol face: ✺ ✦ ✶ ★ ☆ ♥ ♡ ▶ ◀ ● ◆ ■ ♪. */
+export function symbolFace(): LoadedFont;
+/** The characters it draws. */
+export const SYMBOLS: string;

package/src/type/symbols.js

@@ -0,0 +1,89 @@
+/**
+ * A built-in face of a few symbols type often wants and fonts often lack
+ * (✺ ✦ ✶ ★ ☆ ♥ ♡ ▶ ◀ ● ◆ ■ ♪), drawn as shapes. The last fallback when a
+ * text layer's font has no glyph for a character.
+ *
+ * @module type/symbols
+ */
+
+/** Advance, font units (1000 per em). */
+const ADV = 820;
+/** Centre of a symbol: half the advance across, about the middle of a capital up. */
+const CX = ADV / 2;
+const CY = 340;
+const R = 360;
+
+/** @param {[number, number][]} pts @returns {string} A closed polygon, font units (y up). */
+const poly = (pts) => `M${pts.map(([x, y]) => `${x.toFixed(1)},${y.toFixed(1)}`).join('L')}Z`;
+
+/** @param {number} n @param {number} inner @param {number} [turn=0] @returns {[number, number][]} A star's points (clockwise from the top). */
+function star(n, inner, turn = 0) {
+  return Array.from({ length: n * 2 }, (_, i) => {
+    const a = (i / (n * 2)) * Math.PI * 2 + turn;
+    const r = i % 2 ? R * inner : R;
+    return /** @type {[number, number]} */ ([CX + r * Math.sin(a), CY + r * Math.cos(a)]);
+  });
+}
+
+/** @param {number} k - Size, 0–1. @returns {[number, number][]} A heart, clockwise. */
+function heart(k) {
+  return Array.from({ length: 72 }, (_, i) => {
+    const t = (i / 72) * Math.PI * 2;
+    const x = 16 * Math.sin(t) ** 3;
+    const y = 13 * Math.cos(t) - 5 * Math.cos(2 * t) - 2 * Math.cos(3 * t) - Math.cos(4 * t);
+    return /** @type {[number, number]} */ ([CX + x * 22 * k, CY + 30 + y * 22 * k]);
+  });
+}
+
+/** @param {number} r @param {number} [n=48] @returns {[number, number][]} */
+const circle = (r, n = 48) => Array.from({ length: n }, (_, i) => /** @type {[number, number]} */ ([CX + r * Math.sin((i / n) * Math.PI * 2), CY + r * Math.cos((i / n) * Math.PI * 2)]));
+
+/** Outlines by character. An inner contour runs the other way (a hole). */
+const SHAPES = /** @type {Record<string, string>} */ ({
+  '✺': poly(star(16, 0.5)),
+  '✦': poly(star(4, 0.32)),
+  '✶': poly(star(6, 0.45)),
+  '★': poly(star(5, 0.4)),
+  '☆': poly(star(5, 0.4)) + poly(star(5, 0.4).map(([x, y]) => /** @type {[number, number]} */ ([CX + (x - CX) * 0.7, CY + (y - CY) * 0.7])).reverse()),
+  '♥': poly(heart(1)),
+  '♡': poly(heart(1)) + poly(heart(0.72).map(([x, y]) => /** @type {[number, number]} */ ([x, y + 28])).reverse()),
+  '▶': poly([[CX - R * 0.8, CY + R], [CX + R, CY], [CX - R * 0.8, CY - R]]),
+  '◀': poly([[CX + R * 0.8, CY + R], [CX + R * 0.8, CY - R], [CX - R, CY]]),
+  '●': poly(circle(R * 0.8)),
+  '◆': poly([[CX, CY + R], [CX + R * 0.8, CY], [CX, CY - R], [CX - R * 0.8, CY]]),
+  '■': poly([[CX - R * 0.75, CY + R * 0.75], [CX + R * 0.75, CY + R * 0.75], [CX + R * 0.75, CY - R * 0.75], [CX - R * 0.75, CY - R * 0.75]]),
+  '♪': poly([[CX - 40, CY + R], [CX + 220, CY + R * 0.7], [CX + 220, CY + R * 0.45], [CX + 20, CY + R * 0.72], [CX + 20, CY - R * 0.55], [CX - 40, CY - R * 0.55]]) + poly(circle(110).map(([x, y]) => /** @type {[number, number]} */ ([x - 120, y - R * 0.6]))),
+});
+
+const CHARS = Object.keys(SHAPES);
+
+/** @type {any} */
+let face;
+
+/**
+ * The symbol face (shaped and outlined in JavaScript).
+ *
+ * @returns {import('../fonts.js').LoadedFont}
+ */
+export function symbolFace() {
+  face ??= {
+    name: 'symbols',
+    weight: 400,
+    style: 'normal',
+    font: null,
+    upem: 1000,
+    ascender: 800,
+    descender: -200,
+    capHeight: 700,
+    paths: new Map(),
+    axes: {},
+    variations: {},
+    source: { name: 'symbols', src: 'covers:symbols', weight: 400 },
+    glyphToPath: (/** @type {number} */ gid) => SHAPES[CHARS[gid - 1]] ?? '',
+    shapeRun: (/** @type {string} */ text) => Array.from(text).map((ch, i) => ({ gid: CHARS.indexOf(ch) + 1, cluster: i, xAdvance: ADV, xOffset: 0, yOffset: 0 })),
+  };
+  return face;
+}
+
+/** The characters the symbol face draws. */
+export const SYMBOLS = Object.freeze(CHARS.join(''));

package/src/type/typeset.d.ts

@@ -0,0 +1,10 @@
+// The text layer with its 1.1 options.
+import type { TextLayer } from '../index.js';
+import type { RenderContext, Markup } from '../render/context.js';
+
+/** The options that switch a text layer onto the poster typesetter. */
+export const TYPE_OPTIONS: readonly (keyof TextLayer)[];
+/** Whether a text layer uses any of them. */
+export function wantsType(layer: TextLayer): boolean;
+/** Draw a text layer with its 1.1 options. */
+export function typeset(layer: TextLayer, ctx: RenderContext): Promise<Markup>;