SHX font text: strokes and width

const move = (dx, dy) => {
  const nx = st.x + dx * st.mul / st.div, ny = st.y + dy * st.mul / st.div;
  if (st.down) { if (!st.cur) { st.cur = [st.x, st.y]; st.strokes.push(st.cur); } st.cur.push(nx, ny); } else st.cur = null;
  st.x = nx; st.y = ny;
};

const arc = (cx, cy, r, a0, a1) => {   // a1 − a0 signed; the pen ends on the arc
  const n = Math.max(2, Math.ceil(Math.abs(a1 - a0) / ARC_STEP));
  for (let k = 1; k <= n; k++) { const a = a0 + (a1 - a0) * k / n; const x = cx + r * Math.cos(a), y = cy + r * Math.sin(a); if (st.down) put(x, y); st.x = x; st.y = y; }
  if (!st.down) st.cur = null;
};

const bulge = (dx, dy, bl) => {
  const x0 = st.x, y0 = st.y, x1 = x0 + dx * st.mul / st.div, y1 = y0 + dy * st.mul / st.div;
  if (!bl) { move(dx, dy); return; }
  const chord = Math.hypot(x1 - x0, y1 - y0);
  if (chord === 0) return;
  const th = 4 * Math.atan(bl), r = chord / (2 * Math.sin(Math.abs(th) / 2));
  const mx = (x0 + x1) / 2, my = (y0 + y1) / 2, hh = r * Math.cos(th / 2) * Math.sign(bl);   // the centre lies this far to the left of the chord (to the right for a clockwise arc)
  const cx = mx - (y1 - y0) / chord * hh, cy = my + (x1 - x0) / chord * hh;
  const a0 = Math.atan2(y0 - cy, x0 - cx);
  arc(cx, cy, r, a0, a0 + th);
  st.x = x1; st.y = y1;
};

case 0x0a: {
  const r = (bytes[i] ?? 0) * st.mul / st.div, o = bytes[i + 1] ?? 0;
  i += 2;
  const cw = (o & 0x80) !== 0, s0 = (o >> 4) & 7, span = (o & 7) || 8;
  const a0 = s0 * Math.PI / 4, a1 = a0 + (cw ? -1 : 1) * span * Math.PI / 4;
  arc(st.x - r * Math.cos(a0), st.y - r * Math.sin(a0), r, a0, a1);
  break;
}
case 0x0b: {
  const so = bytes[i] ?? 0, eo = bytes[i + 1] ?? 0, r = (((bytes[i + 2] ?? 0) << 8) | (bytes[i + 3] ?? 0)) * st.mul / st.div, o = bytes[i + 4] ?? 0;
  i += 5;
  const cw = (o & 0x80) !== 0, s0 = (o >> 4) & 7, span = (o & 7) || 8;
  const a0 = (s0 + so / 256) * Math.PI / 4, a1 = ((s0 + (cw ? -span : span)) + (cw ? -eo : eo) / 256) * Math.PI / 4;
  arc(st.x - r * Math.cos(a0), st.y - r * Math.sin(a0), r, a0, a1);
  break;
}

export function textStrokes(font, text, h, o = {}) {
  const chars = [...String(text)];
  if (o.reverse) chars.reverse();
  const above = font.above > 0 ? font.above : 1;
  const k = h / above;
  const strokes = [];
  let x = 0, missing = 0;
  for (const ch of chars) {
    if (ch === ' ' || ch === '\t') { const sp = pick(font, ' ', o); x += sp ? sp.g.endX * k : h * 0.5; continue; }
    const r = pick(font, ch, o);
    if (!r) { missing++; x += h * 0.6; continue; }
    const kk = h / (r.font.above > 0 ? r.font.above : 1);
    for (const s of r.g.strokes) { const out = new Array(s.length); for (let i = 0; i < s.length; i += 2) { out[i] = x + s[i] * kk; out[i + 1] = s[i + 1] * kk; } strokes.push(out); }
    x += r.g.endX * kk;
  }
  return { strokes, advance: x, missing };
}

setTextMeasure((s, e) => {
  const f = activeDoc && e && typeof e === 'object' ? styleFont(activeDoc, e) : null;
  return f ? textAdvance(f.font, s, e.h, { reverse: f.reverse, fallback: f.big }) * (e.wf || 1) : null;
});

setShxHook((doc, te) => {
  const f = styleFont(doc, te);
  if (!f || richOf(te)) return null;
  const lay = textLayout(te);
  const wf = te.wf || 1, tan = Math.tan(te.obl || 0), co = Math.cos(te.rot || 0), si = Math.sin(te.rot || 0);
  const prims = [];
  lay.lines.forEach((line, i) => {
    if (!line) return;
    const r = textStrokes(f.font, line, te.h, { reverse: f.reverse, fallback: f.big });
    const adv = r.advance * wf, base = lay.baselines[i];
    const x0 = te.ha === 'center' ? -adv / 2 : te.ha === 'right' ? -adv : 0;
    for (const s of r.strokes) {
      let px = 0, py = 0;
      for (let k = 0; k < s.length; k += 2) {
        const gy = base + s[k + 1], lx = x0 + (s[k] + gy * tan) * wf;
        const X = te.x + lx * co - gy * si, Y = te.y + lx * si + gy * co;
        if (k) prims.push({ k: 'L', x1: px, y1: py, x2: X, y2: Y });
        px = X; py = Y;
      }
    }
  });
  return prims;
});