Wide polylines, text masks and ellipses as drawn and plotted

export function polyBands(e) {
  const pts = e.pts || [];
  const g = Number.isFinite(e.w) && e.w > 0 ? e.w : 0;
  if (!g && !pts.some((p) => p.sw > 0 || p.ew > 0)) return null;
  const n = pts.length, segs = e.closed ? n : n - 1;
  const loops = [], plain = [];
  const ends = [];   // per wide segment drawn: its index and both ends { x, y, tx, ty (travel direction), h (half width) }
  for (let i = 0; i < segs; i++) {
    const a = pts[i], q = pts[(i + 1) % n];
    const ws = Number.isFinite(a.sw) ? a.sw : g, we = Number.isFinite(a.ew) ? a.ew : g;
    const one = prims({ type: 'poly', closed: false, pts: [{ x: a.x, y: a.y, b: a.b || 0 }, { x: q.x, y: q.y }] }, null);
    if (!(ws > 0 || we > 0)) { plain.push(...one); continue; }
    const p = one[0];
    if (!p) continue;
    // points along the segment with their unit normals (left side)
    const along = [];
    if (p.k === 'L') {
      const L = Math.hypot(p.x2 - p.x1, p.y2 - p.y1);
      if (!(L > 1e-12)) continue;   // a repeated vertex: no band (and no corner) there
      const nx = -(p.y2 - p.y1) / L, ny = (p.x2 - p.x1) / L;
      along.push([p.x1, p.y1, nx, ny, 0], [p.x2, p.y2, nx, ny, 1]);
    } else {
      // an A primitive runs counter-clockwise from a0 to a1; the polyline may run either way
      let sweep = (p.a1 - p.a0 + TAU) % TAU || TAU;
      const ccw = (a.b || 0) > 0;
      const k = Math.max(2, Math.ceil(sweep / (Math.PI / 18)));
      for (let j = 0; j <= k; j++) {
        const t = j / k, ang = ccw ? p.a0 + sweep * t : p.a1 - sweep * t;
        const cx = Math.cos(ang), cy = Math.sin(ang);
        along.push([p.cx + p.r * cx, p.cy + p.r * cy, ccw ? -cx : cx, ccw ? -cy : cy, t]);
      }
    }
    const left = [], right = [];
    for (const [x, y, nx, ny, t] of along) {
      const h = (ws + (we - ws) * t) / 2;
      left.push(x + nx * h, y + ny * h);
      right.unshift(x - nx * h, y - ny * h);
    }
    const ring = [...left, ...right];
    ring.push(ring[0], ring[1]);
    loops.push(ring);
    // the travel direction at each end is the left normal turned a quarter clockwise
    const f = along[0], l = along[along.length - 1];
    ends.push({ i, start: { x: f[0], y: f[1], tx: f[3], ty: -f[2], h: ws / 2 }, end: { x: l[0], y: l[1], tx: l[3], ty: -l[2], h: we / 2 } });

for (let k = 0; k < ends.length; k++) {
  const A = ends[k], B = ends[k + 1] || (e.closed && ends.length > 1 ? ends[0] : null);
  if (!B || B === A || !(A.end.h > 0) || !(B.start.h > 0)) continue;
  const a = A.end, b = B.start;
  // the next wide segment starts where this one ends (repeated vertices between them are skipped above)
  if (Math.hypot(a.x - b.x, a.y - b.y) > 1e-9 * Math.max(1, Math.abs(a.x), Math.abs(a.y), a.h)) continue;
  const cross = a.tx * b.ty - a.ty * b.tx, dot = a.tx * b.tx + a.ty * b.ty;
  if (Math.abs(cross) < 1e-9 && dot > 0) continue;   // straight on
  const side = cross > 0 ? -1 : 1;   // a left turn opens the gap on the right
  const P1 = { x: a.x - side * a.ty * a.h, y: a.y + side * a.tx * a.h }, P2 = { x: b.x - side * b.ty * b.h, y: b.y + side * b.tx * b.h };
  let X = null;
  if (Math.abs(cross) > 1e-9) {   // P1 + s·ta = P2 + u·tb
    const s = ((P2.x - P1.x) * b.ty - (P2.y - P1.y) * b.tx) / cross;
    const c = { x: P1.x + s * a.tx, y: P1.y + s * a.ty };
    if (s >= 0 && Math.hypot(c.x - a.x, c.y - a.y) <= 10 * Math.max(a.h, b.h)) X = c;
  }
  const wedge = X ? [a.x, a.y, P1.x, P1.y, X.x, X.y, P2.x, P2.y] : [a.x, a.y, P1.x, P1.y, P2.x, P2.y];
  wedge.push(wedge[0], wedge[1]);
  loops.push(wedge);
}

/**
 * A text's background mask (WL.8) as a ring [x, y, …]: the text's box — its wrap width when it has one — grown by
 * (scale − 1) × the text height on every side, as the other program's "border offset factor" (1.5 = half a height).
 */
export function maskLoop(e, scale = 1.5) {
  const lay = textLayout(e), b = lay.box, m = Math.max(0, (Number.isFinite(scale) ? scale : 1.5) - 1) * e.h;
  let x0 = b.x, x1 = b.x + b.w;
  if (e.ww > 0 && e.ww > b.w) {   // the paragraph's own width, placed as its alignment places it
    if (e.ha === 'center') { const c = (x0 + x1) / 2; x0 = c - e.ww / 2; x1 = c + e.ww / 2; } else if (e.ha === 'right') x0 = x1 - e.ww; else x1 = x0 + e.ww;
  }
  const c = Math.cos(e.rot || 0), s = Math.sin(e.rot || 0), P = (x, y) => [e.x + x * c - y * s, e.y + x * s + y * c];
  const pts = [P(x0 - m, b.y - m), P(x1 + m, b.y - m), P(x1 + m, b.y + b.h + m), P(x0 - m, b.y + b.h + m)];
  return [...pts.flat(), ...pts[0]];
}

/** A ring [x, y, …] turned clockwise (negative area), so rings filled together add up instead of cancelling. */
export function clockwise(l) {
  let a = 0;
  for (let i = 0; i + 3 < l.length; i += 2) a += l[i] * l[i + 3] - l[i + 2] * l[i + 1];
  if (a <= 0) return l;
  const out = [];
  for (let i = l.length - 2; i >= 0; i -= 2) out.push(l[i], l[i + 1]);
  return out;
}

case 'ellipse': {
  const pts = ellipsePoints(e, 96);
  const ps = [];
  for (let i = 0; i + 1 < pts.length; i++) ps.push({ k: 'L', x1: pts[i].x, y1: pts[i].y, x2: pts[i + 1].x, y2: pts[i + 1].y });
  strokeOf(e, ps, color, lw, mm, ctx, o);

const strokeOf = (e, ps, color, lw, mm, ctx, o) => {
  // a plot style table's pen may name another linetype for this colour (penLt, 0.7 DC.14) and scale the dashes of non-ISO ones (ltTable)
  const ltName = (penLt && penLt(color)) || resolveLt(doc, e, ctx.lt, ctx.layer);
  const pat = pattern(ltName);
  const sc = ltscale * (e.lts > 0 ? e.lts : 1) * (pat && ltTable !== 1 && !isIsoLinetype(ltName) ? ltTable : 1);
  // a polyline without linetype generation (lgen false, PLINEGEN off in the file) starts its pattern again at each vertex
  const d = !pat ? ps : e.type === 'poly' && e.lgen === false && ps.length > 1 ? ps.flatMap((q) => dashPrims([q], pat, sc)) : dashPrims(ps, pat, sc);
  out.stroke(color, mm ? d.flatMap((q) => txPrim(q, mm)) : d, lw, o);
};