Picked points, object snaps and viewport views

toWorld(sx, sy) {
  const u = (sx - this.w / 2) / this.zoom, v = (this.h / 2 - sy) / this.zoom;
  if (!this.tw) return { x: u + this.cx, y: v + this.cy };
  const c = Math.cos(this.tw), s = Math.sin(this.tw);
  return { x: this.cx + c * u - s * v, y: this.cy + s * u + c * v };
}

/** The best object snap within the aperture (px) of p. */
snap(p, { kinds, base = null, px = 10 }) {
  if (!kinds || !kinds.size) return null;
  const r = px / this.zoom;
  const bounds = this.ensureCache().bounds;
  const nearby = [], frz = this.enteredFrozen();
  for (const e of this.doc.entities.values()) {
    if (!this.doc.visible(e) || this.hiddenHere(e, frz)) continue;
    const b = bounds.get(e.id);
    if (!b || (UNBOUNDED.has(e.type) ? distToEntity(e, p, null) > r : (p.x < b.minX - r || p.x > b.maxX + r || p.y < b.minY - r || p.y > b.maxY + r))) continue;
    nearby.push(e);
    if (nearby.length > 400) break;
  }
  let best = null;
  const consider = (c) => {
    const d = Math.hypot(c.x - p.x, c.y - p.y);
    if (d > r) return;
    const pr = c.pr ?? SNAP_PRIORITY[c.kind] ?? 5;
    if (!best || pr < best.pr || (pr === best.pr && d < best.d)) best = { ...c, d, pr };
  };
  for (const e of nearby) for (const c of snapPoints(e, p, r, kinds, this.doc.blocks, base)) consider(c);
  if (kinds.has('int') && nearby.length > 1) {
    const ps = nearby.slice(0, 60).map((e) => prims(e, this.doc.blocks).filter((q) => !q.box && nearPrim(q, p, r)));
    for (let i = 0; i < ps.length; i++) for (let j = i + 1; j < ps.length; j++) {
      for (const a of ps[i]) for (const b of ps[j]) for (const x of intersect(a, b)) consider({ kind: 'int', x: x.x, y: x.y });
    }
  }
  if (this.snapUnder) for (const c of this.snapUnder(p, r, kinds) || []) consider(c);   // a PDF underlay's own lines (0.7 D7.24)
  if (kinds.has('node') && this.snapExtra) { const c = this.snapExtra(p, r); if (c) consider(c); }   // a point cloud's points (SG.1)
  return best;
}

/** The view the entered (not locked) viewport has on screen when it differs from the doc's: { lay, vp, cx, cy, s }, else null. */
pendingViewport() {
  const ev = this.enteredViewport();
  if (!ev || ev.vp.locked) return null;
  const M = this.enteredMatrix(), s = Math.hypot(M[0], M[1]), tw = normTurn(Math.atan2(M[1], M[0]));
  const c = ap(inverse(M), ev.vp.x, ev.vp.y);
  const same = (a, b) => Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b));
  if (same(c.x, ev.vp.cx) && same(c.y, ev.vp.cy) && same(s, ev.vp.s) && same(tw, normTurn(ev.vp.tw || 0))) return null;
  return { ...ev, cx: c.x, cy: c.y, s, ...(tw || ev.vp.tw ? { tw } : {}) };
}

/** A view { cx, cy, zoom, tw } → its world → CSS px affine for a w × h pane (DR.8: turned by −tw on screen). */
export function affineOf(v, w, h) {
  const z = v.zoom, c = Math.cos(v.tw || 0), s = Math.sin(v.tw || 0);
  return [z * c, z * s, z * s, -z * c, w / 2 - z * (c * v.cx + s * v.cy), h / 2 + z * (-s * v.cx + c * v.cy)];
}

/** … and back: an affine of that shape (a similarity with y flipped) → { cx, cy, zoom, tw }. */
export function viewOf(A, w, h) {
  const zoom = Math.hypot(A[0], A[1]), tw = normTurn(Math.atan2(A[1], A[0]));
  const c = ap(inverse(A), w / 2, h / 2);
  return { cx: c.x, cy: c.y, zoom, tw };
}

function inverse(m) {
  const det = m[0] * m[3] - m[1] * m[2];
  return [m[3] / det, -m[1] / det, -m[2] / det, m[0] / det, (m[2] * m[5] - m[3] * m[4]) / det, (m[1] * m[4] - m[0] * m[5]) / det];
}

/** An angle in (−π, π], with the tiny ones (float noise) as 0. */
function normTurn(a) { let r = Math.atan2(Math.sin(a), Math.cos(a)); if (Math.abs(r) < 1e-12) r = 0; return r; }