PDF page vectors and snapping to them

const m = ctm, X = (x, y) => m[0] * x + m[2] * y + m[4], Y = (x, y) => m[1] * x + m[3] * y + m[5];
const subs = [];
let cur = null, sx = 0, sy = 0, px = 0, py = 0;
const ok = (...v) => v.every(Number.isFinite);
for (let k = 0; k < d.length;) {
  const c = d[k];
  if (c === 0) { const x = X(d[k + 1], d[k + 2]), y = Y(d[k + 1], d[k + 2]); if (!ok(x, y)) break; cur = { closed: false, ops: [['M', x, y]] }; subs.push(cur); sx = px = x; sy = py = y; k += 3; }
  else if (c === 1 && cur) { const x = X(d[k + 1], d[k + 2]), y = Y(d[k + 1], d[k + 2]); if (!ok(x, y)) break; cur.ops.push(['L', x, y]); px = x; py = y; k += 3; }
  else if (c === 2 && cur) {
    const c1x = X(d[k + 1], d[k + 2]), c1y = Y(d[k + 1], d[k + 2]), c2x = X(d[k + 3], d[k + 4]), c2y = Y(d[k + 3], d[k + 4]), x = X(d[k + 5], d[k + 6]), y = Y(d[k + 5], d[k + 6]);
    if (!ok(c1x, c1y, c2x, c2y, x, y)) break;
    cur.ops.push(['C', c1x, c1y, c2x, c2y, x, y]); px = x; py = y; k += 7;
  } else if (c === 3 && cur) {   // quadratic → cubic
    const qx = X(d[k + 1], d[k + 2]), qy = Y(d[k + 1], d[k + 2]), x = X(d[k + 3], d[k + 4]), y = Y(d[k + 3], d[k + 4]);
    if (!ok(qx, qy, x, y)) break;
    cur.ops.push(['C', px + 2 / 3 * (qx - px), py + 2 / 3 * (qy - py), x + 2 / 3 * (qx - x), y + 2 / 3 * (qy - y), x, y]); px = x; py = y; k += 5;
  } else if (c === 4 && cur) { cur.closed = true; px = sx; py = sy; k += 1; }
  else break;   // an operator this reader does not know: the rest of the path is dropped

/** The page's lines flattened for snapping: segments [x1,y1,x2,y2,…] and, per segment, 0 straight / 1 chord of a curve (2 first, 4 last). */
export function segmentsOf(pageVec, { maxSegs = 400000 } = {}) {
  let segs = new Float64Array(4096), curve = new Uint8Array(1024), n = 0;
  const push = (ax, ay, bx, by, fl) => {
    if (n >= maxSegs || (ax === bx && ay === by)) return;
    if (n * 4 >= segs.length) { const g = new Float64Array(segs.length * 2); g.set(segs); segs = g; const c2 = new Uint8Array(segs.length / 4); c2.set(curve); curve = c2; }
    segs[n * 4] = ax; segs[n * 4 + 1] = ay; segs[n * 4 + 2] = bx; segs[n * 4 + 3] = by; curve[n] = fl; n++;
  };
  for (const sh of pageVec.shapes) {
    for (const sub of sh.subs) {
      let px = 0, py = 0, sx = 0, sy = 0;
      for (const o of sub.ops) {
        if (o[0] === 'M') { px = sx = o[1]; py = sy = o[2]; }
        else if (o[0] === 'L') { push(px, py, o[1], o[2], 0); px = o[1]; py = o[2]; }
        else {
          let lx = px, ly = py;
          for (let s = 1; s <= CURVE_STEPS; s++) {
            const t = s / CURVE_STEPS, u = 1 - t;
            const x = s === CURVE_STEPS ? o[5] : u * u * u * px + 3 * u * u * t * o[1] + 3 * u * t * t * o[3] + t * t * t * o[5];
            const y = s === CURVE_STEPS ? o[6] : u * u * u * py + 3 * u * u * t * o[2] + 3 * u * t * t * o[4] + t * t * t * o[6];
            push(lx, ly, x, y, 1 | (s === 1 ? 2 : 0) | (s === CURVE_STEPS ? 4 : 0)); lx = x; ly = y;
          }
          px = o[5]; py = o[6];
        }
      }
      if (sub.closed) push(px, py, sx, sy, 0);
    }
  }
  return { segs: segs.subarray(0, n * 4), curve: curve.subarray(0, n), n };
}

function closestOnSeg(p, g, s) {
  const ax = g[s * 4], ay = g[s * 4 + 1], bx = g[s * 4 + 2], by = g[s * 4 + 3];
  const dx = bx - ax, dy = by - ay, L = dx * dx + dy * dy;
  const t = L ? Math.max(0, Math.min(1, ((p.x - ax) * dx + (p.y - ay) * dy) / L)) : 0;
  return { x: ax + dx * t, y: ay + dy * t };
}

/** Where two segments cross (ends included), or null (parallel, or apart). */
export function intersect(g, s, t) {
  const ax = g[s * 4], ay = g[s * 4 + 1], bx = g[s * 4 + 2], by = g[s * 4 + 3];
  const cx = g[t * 4], cy = g[t * 4 + 1], dx = g[t * 4 + 2], dy = g[t * 4 + 3];
  const rx = bx - ax, ry = by - ay, sx = dx - cx, sy = dy - cy;
  const den = rx * sy - ry * sx;
  if (Math.abs(den) < 1e-12 * Math.max(1, Math.hypot(rx, ry) * Math.hypot(sx, sy))) return null;
  const u = ((cx - ax) * sy - (cy - ay) * sx) / den, v = ((cx - ax) * ry - (cy - ay) * rx) / den;
  const e = 1e-9;
  if (u < -e || u > 1 + e || v < -e || v > 1 + e) return null;
  // two pieces that only meet end to end (a corner, a curve's chords) do not cross: that point is an end, or nothing
  const atEnd = (w) => w < e || w > 1 - e;
  if (atEnd(u) && atEnd(v)) return null;
  return { x: ax + rx * u, y: ay + ry * u };
}

snap(p, tol, kinds = {}) {
  const want = { end: true, mid: true, int: true, near: true, ...kinds };
  const g = this.segs, cur = this.curve;
  const cand = this.near(p, tol).filter((s) => distSeg(p, g, s) <= tol);
  if (!cand.length) return null;
  let best = null;
  const RANK = { end: 0, int: 1, mid: 2 };     // the same spot found twice (a crossing at a midpoint): the stronger name
  const offer = (x, y, kind) => {
    const d = Math.hypot(x - p.x, y - p.y);
    if (d > tol) return;
    if (!best || d < best.d - 1e-9 || (Math.abs(d - best.d) <= 1e-9 && RANK[kind] < RANK[best.kind])) best = { x, y, kind, d };
  };
  for (const s of cand) {
    const ax = g[s * 4], ay = g[s * 4 + 1], bx = g[s * 4 + 2], by = g[s * 4 + 3];
    if (want.end) {
      // a flattened curve's inner chord points are not ends; its own two ends are
      if (!cur[s] || cur[s] & 2) offer(ax, ay, 'end');
      if (!cur[s] || cur[s] & 4) offer(bx, by, 'end');
    }
    if (want.mid && !cur[s]) offer((ax + bx) / 2, (ay + by) / 2, 'mid');
  }
  if (want.int) {
    const list = cand.slice(0, 80);
    for (let i = 0; i < list.length; i++) for (let j = i + 1; j < list.length; j++) {
      const q = intersect(g, list[i], list[j]);
      if (q) offer(q.x, q.y, 'int');
    }
  }
  if (best) return best;
  if (!want.near) return null;
  for (const s of cand) {
    const q = closestOnSeg(p, g, s);
    const d = Math.hypot(q.x - p.x, q.y - p.y);
    if (!best || d < best.d) best = { x: q.x, y: q.y, kind: 'near', d };
  }
  return best && best.d <= tol ? best : null;
}