Shapes made by the draw commands

export function circle3(a, b, c) {
  const d = 2 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
  if (Math.abs(d) < 1e-12) return null;
  const a2 = a.x * a.x + a.y * a.y, b2 = b.x * b.x + b.y * b.y, c2 = c.x * c.x + c.y * c.y;
  const cx = (a2 * (b.y - c.y) + b2 * (c.y - a.y) + c2 * (a.y - b.y)) / d;
  const cy = (a2 * (c.x - b.x) + b2 * (a.x - c.x) + c2 * (b.x - a.x)) / d;
  return { cx, cy, r: Math.hypot(a.x - cx, a.y - cy) };
}

/** Arc through start, a point on it and end. */
export function arc3(s, m, e) {
  const k = circle3(s, m, e);
  if (!k) return null;
  const c = { x: k.cx, y: k.cy };
  const ccw = (m.x - s.x) * (e.y - s.y) - (m.y - s.y) * (e.x - s.x) > 0;   // a left turn s→m→e travels CCW round the centre
  let a0 = angleOf(c, s), a1 = angleOf(c, e);
  if (!ccw) [a0, a1] = [a1, a0];
  return { ...k, a0: normAngle(a0), a1: normAngle(a1) };
}

const tangent = () => {   // direction at the end of the last segment
  if (pts.length < 2) return null;
  const p = pts[pts.length - 2], q = pts[pts.length - 1];
  if (!p.b) return angleOf(p, q);
  const a = bulgeArc(p, q, p.b);
  const ang = Math.atan2(q.y - a.cy, q.x - a.cx);
  return ang + (p.b > 0 ? Math.PI / 2 : -Math.PI / 2);
};
const arcBulge = (p, q) => {
  const t = tangent() ?? 0;
  let phi = normAngle(angleOf(p, q) - t); if (phi > Math.PI) phi -= TAU;
  return Math.tan(phi / 2);
};

if (r0.option === '2P') {
  const a = await c.point(t('cmd.circle.specify_first_end_point'));
  c.preview((cur) => [{ type: 'circle', cx: (a.x + cur.x) / 2, cy: (a.y + cur.y) / 2, r: dist(a, cur) / 2 }]);
  const b = await c.point(t('cmd.circle.specify_second_end_point'), { base: a });
  c.add(ent(c, { type: 'circle', cx: (a.x + b.x) / 2, cy: (a.y + b.y) / 2, r: dist(a, b) / 2 }));

if (p0.option === 'C') {
  const center = await c.point(t('cmd.arc.specify_center_point_arc'));
  const s = await c.point(t('cmd.arc.specify_start_point_arc'), { base: center });
  const r = dist(center, s), a0 = angleOf(center, s);
  c.preview((cur) => [{ type: 'arc', cx: center.x, cy: center.y, r, a0, a1: angleOf(center, cur) }]);
  const e = await c.point(t('cmd.arc.specify_end_point_arc'), { base: center });
  c.add(ent(c, { type: 'arc', cx: center.x, cy: center.y, r, a0: normAngle(a0), a1: normAngle(angleOf(center, e)) }));

def('RECTANG', ['REC', 'RECTANGLE'], async (c) => {
  const a = await c.point(t('cmd.area.first'));
  c.preview((cur) => [rect(a, cur)]);
  const b = await c.point(t('cmd.rectang.specify_other_corner_point'), { base: a });
  if (Math.abs(b.x - a.x) < 1e-12 || Math.abs(b.y - a.y) < 1e-12) { c.print(t('cmd.rectang.rectangle_needs_width_height')); return; }
  c.add(ent(c, rect(a, b)));

const sides = Math.round(n);
if (!(sides >= 3 && sides <= 1024)) { c.print(t('cmd.polygon.requires_whole_number_3')); return; }
c.engine.lastSides = sides;
const center = await c.point(t('cmd.polygon.specify_center_polygon'));
const k = await c.keyword(t('cmd.mea.option'), { options: [opt('I', t('cmd.polygon.inscribed_circle')), opt('C', t('cmd.polygon.circumscribed_about_circle'))], default: c.engine.lastPolyMode || 'I' });
const mode = (k && k.option) || (typeof k === 'string' ? k : 'I');
c.engine.lastPolyMode = mode;
const make = (cur) => {
  const r = dist(center, cur), a = angleOf(center, cur);
  const R = mode === 'C' ? r / Math.cos(Math.PI / sides) : r, a0 = mode === 'C' ? a + Math.PI / sides : a;
  return { type: 'poly', closed: true, pts: Array.from({ length: sides }, (_, i) => ({ ...polar(center, a0 + i * TAU / sides, R), b: 0 })) };

const L = Math.hypot(major.x, major.y);
if (L < 1e-12) return;
const make = (half) => ({ type: 'ellipse', cx: center.x, cy: center.y, mx: major.x, my: major.y, ratio: Math.min(Math.max(half / L, 1e-6), 1), t0: 0, t1: TAU });
c.preview((cur) => [make(Math.abs(((cur.x - center.x) * -major.y + (cur.y - center.y) * major.x) / L))]);
const d = await c.distance(t('cmd.ellipse.specify_distance_other_axis'), { base: center });
if (!d) return;
if (d > L) {   // the other axis is the longer one: swap so the ratio stays ≤ 1
  const u = { x: -major.y / L * d, y: major.x / L * d };
  c.add(ent(c, { type: 'ellipse', cx: center.x, cy: center.y, mx: u.x, my: u.y, ratio: L / d, t0: 0, t1: TAU }));
} else c.add(ent(c, make(d)));

  ang = Math.atan2(u.dy, u.dx) + (typeof r === 'number' ? r : 0);
}
return throughPoints(c, 'xline', fixed({ dx: Math.cos(ang), dy: Math.sin(ang) }));

const half = (p) => {
  const u1 = unitDir(p.x - v.x, p.y - v.y);
  if (!u1) return null;
  const b = unitDir(u0.dx + u1.dx, u0.dy + u1.dy) || { dx: -u0.dy, dy: u0.dx };   // opposite rays: the perpendicular
  return { x: v.x, y: v.y, ...b };

const foot = (q) => { const k = (q.x - on.x) * u.dx + (q.y - on.y) * u.dy; return { x: on.x + u.dx * k, y: on.y + u.dy * k }; };
if (through) {
  c.preview((cur) => [{ type: 'xline', x: cur.x, y: cur.y, ...u }]);
  const p = await c.point(t('cmd.xline.through'));
  c.add(ent(c, { type: 'xline', x: p.x, y: p.y, ...u }));
} else {
  const f = foot(pick.point);
  c.preview((cur) => { const g = foot(cur), n = unitDir(cur.x - g.x, cur.y - g.y); return n ? [{ type: 'xline', x: f.x + n.dx * d, y: f.y + n.dy * d, ...u }] : []; });
  const side = await c.point(t('cmd.xline.side'));
  const g = foot(side), n = unitDir(side.x - g.x, side.y - g.y);
  if (!n) { c.print(t('cmd.xline.side_on_line')); continue; }
  c.add(ent(c, { type: 'xline', x: f.x + n.dx * d, y: f.y + n.dy * d, ...u }));

const pos = polar(at, (rot || 0) - Math.PI / 2, y);
c.add(ent(c, { type: 'text', x: pos.x, y: pos.y, h, rot: normAngle(rot || 0), s: line, ha, va, wf: 1 }));
y += h * 1.667;   // DTEXT line spacing

const frame = (b) => {   // the box from corner a to b, in the text's own direction
  const d = { x: b.x - a.x, y: b.y - a.y }, lx = d.x * u().x + d.y * u().y, ly = d.x * n().x + d.y * n().y;
  return { left: Math.min(0, lx), right: Math.max(0, lx), top: Math.max(0, ly), bottom: Math.min(0, ly) };
};
const boxPoly = (f) => ({ type: 'poly', closed: true, pts: [[f.left, f.top], [f.right, f.top], [f.right, f.bottom], [f.left, f.bottom]].map(([x, y]) => ({ x: a.x + u().x * x + n().x * y, y: a.y + u().y * x + n().y * y, b: 0 })) });
let b = null;
for (;;) {
  c.preview((cur) => [boxPoly(frame(cur))]);
  const p = await c.point(t('cmd.mtext.corner'), { base: a, options: [opt('H', t('opt.height')), opt('J', t('opt.justify')), opt('L', t('opt.linespacing')), opt('R', t('opt.rotation')), opt('W', t('opt.width'))] });
  if (p.option === 'H') { const h = await c.distance(t('cmd.mtext.height'), { base: a, default: S.h }); if (h > 0) S.h = h; continue; }
  if (p.option === 'J') {
    const k = await c.keyword(t('cmd.mtext.just'), { options: Object.keys(MTEXT_JUST).map((key) => opt(key, key)), default: S.just });
    const key = k?.option || k; if (MTEXT_JUST[key]) S.just = E.mtextJust = key; continue;
  }
  if (p.option === 'L') { const f = await c.number(t('cmd.mtext.ls'), { default: S.ls }); if (f >= 0.25 && f <= 4) S.ls = E.mtextLs = f; else c.print(t('cmd.mtext.ls.bad')); continue; }
  if (p.option === 'R') { const r = await c.angle(t('cmd.mtext.rot'), { base: a, default: S.rot, ucs: true }); S.rot = normAngle(r || 0); continue; }
  if (p.option === 'W') { const w = await c.distance(t('cmd.mtext.width'), { base: a, default: 0 }); S.width = w || 0; break; }
  b = p; break;
}
c.preview(null);
const [ha, va] = MTEXT_JUST[S.just];
let at = a, ww = S.width ?? 0;
if (b) {
  const f = frame(b);
  ww = f.right - f.left;
  const lx = ha === 'left' ? f.left : ha === 'right' ? f.right : (f.left + f.right) / 2;
  const ly = va === 'top' ? f.top : va === 'bottom' ? f.bottom : (f.top + f.bottom) / 2;
  at = { x: a.x + u().x * lx + n().x * ly, y: a.y + u().y * lx + n().y * ly };
}
const e = ent(c, { type: 'text', x: at.x, y: at.y, h: S.h, rot: S.rot, s: '', ha, va, wf: 1, ...(ww > 1e-9 ? { ww } : {}), ...(S.ls !== 1 ? { ls: S.ls } : {}) });