@skillpet/circuit 0.5.0

package/dist/segment.js

@@ -0,0 +1,844 @@
+import { bbox } from "./types.js";
+import { flipXY, mirrorxXY } from "./geometry/util.js";
+import { Point } from "./geometry/point.js";
+import { roundCorners } from "./geometry/roundcorners.js";
+import { textSize } from "./svg/figure.js";
+import { PT_PER_IN } from "./svg/constants.js";
+import { hasMath, isKatexAvailable, renderMathHtml, estimateMathSize } from "./math-render.js";
+export const GAP = [Number.NaN, Number.NaN];
+/** Resolve the special fill value `"bg"` to the drawing's background color (default white). */
+function resolveBgFill(fill, style) {
+    if (typeof fill === "string" && fill.toLowerCase() === "bg") {
+        return style.bgcolor ?? "white";
+    }
+    return fill;
+}
+function isGap(p) {
+    if (Array.isArray(p)) {
+        return Number.isNaN(p[0]) && Number.isNaN(p[1]);
+    }
+    return false;
+}
+function pathPointToPair(p) {
+    if (isGap(p)) {
+        return [Number.NaN, Number.NaN];
+    }
+    return p instanceof Point ? [p.x, p.y] : [p[0], p[1]];
+}
+export class Segment {
+    path;
+    color;
+    lw;
+    ls;
+    capstyle;
+    joinstyle;
+    fill;
+    arrow;
+    arrowwidth = 0.15;
+    arrowlength = 0.25;
+    zorder;
+    visible = true;
+    clip;
+    role;
+    gradientStrokeId;
+    constructor(path, opts = {}) {
+        this.path = path.map(pathPointToPair);
+        Object.assign(this, opts);
+    }
+    xform(transform, style) {
+        const pts = transform.transformArray(this.path.map(([x, y]) => [x, y]));
+        const path = pts.map((pt) => [pt.x, pt.y]);
+        return new Segment(path, {
+            color: this.color ?? style.color,
+            lw: this.lw ?? style.lw,
+            ls: this.ls ?? style.ls,
+            capstyle: this.capstyle ?? style.capstyle,
+            joinstyle: this.joinstyle ?? style.joinstyle,
+            fill: this.fill ?? style.fill,
+            arrow: this.arrow,
+            arrowwidth: this.arrowwidth,
+            arrowlength: this.arrowlength,
+            zorder: this.zorder ?? style.zorder,
+            visible: this.visible,
+            clip: this.clip,
+        });
+    }
+    getBBox() {
+        const xs = this.path.map((p) => p[0]).filter((x) => !Number.isNaN(x));
+        const ys = this.path.map((p) => p[1]).filter((y) => !Number.isNaN(y));
+        const hw = this.arrow ? this.arrowwidth ?? 0 : 0;
+        return bbox(Math.min(...xs), Math.min(...ys) - hw, Math.max(...xs), Math.max(...ys) + hw);
+    }
+    /** Python `Segment.doreverse` — mirror path after reversing point order. */
+    doreverse(centerx) {
+        const rev = [...this.path].reverse();
+        this.path = rev.map(([x, y]) => {
+            if (Number.isNaN(x) && Number.isNaN(y)) {
+                return [x, y];
+            }
+            return mirrorxXY(x, y, centerx);
+        });
+        if (this.arrow) {
+            this.arrow = this.arrow
+                .split("")
+                .map((c) => (c === "<" ? ">" : c === ">" ? "<" : c))
+                .join("");
+        }
+    }
+    /** Python `Segment.doflip` — vertical flip of path points. */
+    doflip() {
+        this.path = this.path.map(([x, y]) => {
+            if (Number.isNaN(x) && Number.isNaN(y)) {
+                return [x, y];
+            }
+            return flipXY(x, y);
+        });
+    }
+    draw(fig, transform, style) {
+        if (!this.visible) {
+            return;
+        }
+        const path = transform.transformArray(this.path.map(([x, y]) => [x, y]));
+        let linepath = path.map((p) => new Point(p.x, p.y));
+        const color = (this.color ?? style.color ?? "black");
+        const ls = (this.ls ?? style.ls ?? "-");
+        const lw = (this.lw ?? style.lw ?? 2);
+        const capstyle = (this.capstyle ?? style.capstyle ?? "round");
+        const joinstyle = (this.joinstyle ?? style.joinstyle ?? "round");
+        let fill = resolveBgFill(this.fill ?? style.fill, style);
+        const zorder = this.zorder ?? style.zorder ?? 2;
+        const gid = style._svgGradientFillId;
+        if (fill) {
+            const tlist = linepath.map((p) => `${p.x},${p.y}`);
+            const uniq = new Set(tlist);
+            const dofill = tlist.length !== uniq.size;
+            if (!dofill) {
+                fill = undefined;
+            }
+            else if (fill === true) {
+                fill = color;
+            }
+        }
+        if (gid && fill) {
+            fill = `url(#${gid})`;
+        }
+        if (this.arrow?.includes("<")) {
+            const delta = linepath[1].sub(linepath[0]);
+            const th = Math.atan2(delta.y, delta.x);
+            linepath = [...linepath];
+            linepath[0] = new Point(linepath[0].x + this.arrowlength * Math.cos(th), linepath[0].y + this.arrowlength * Math.sin(th));
+        }
+        if (this.arrow?.includes(">")) {
+            const delta = linepath[linepath.length - 1].sub(linepath[linepath.length - 2]);
+            const th = Math.atan2(delta.y, delta.x);
+            linepath = [...linepath];
+            const last = linepath.length - 1;
+            linepath[last] = new Point(linepath[last].x - this.arrowlength * Math.cos(th), linepath[last].y - this.arrowlength * Math.sin(th));
+        }
+        const strokeColor = this.gradientStrokeId ? `url(#${this.gradientStrokeId})` : color;
+        const xs = linepath.map((p) => p.x);
+        const ys = linepath.map((p) => p.y);
+        fig.plot(xs, ys, {
+            color: strokeColor,
+            ls,
+            lw,
+            capstyle,
+            joinstyle,
+            fill: fill ?? "none",
+            zorder,
+        });
+        if (this.arrow) {
+            const pathPts = path.map((p) => new Point(p.x, p.y));
+            if (this.arrow.includes("<")) {
+                const theta = (Math.atan2(pathPts[0].y - pathPts[1].y, pathPts[0].x - pathPts[1].x) * 180) / Math.PI;
+                fig.arrow([pathPts[0].x, pathPts[0].y], theta, {
+                    color,
+                    zorder,
+                    arrowlength: this.arrowlength,
+                    arrowwidth: this.arrowwidth,
+                    lw: 1,
+                });
+            }
+            if (this.arrow.includes(">")) {
+                const theta = (Math.atan2(pathPts[pathPts.length - 1].y - pathPts[pathPts.length - 2].y, pathPts[pathPts.length - 1].x - pathPts[pathPts.length - 2].x) *
+                    180) /
+                    Math.PI;
+                fig.arrow([pathPts[pathPts.length - 1].x, pathPts[pathPts.length - 1].y], theta, {
+                    color,
+                    zorder,
+                    arrowlength: this.arrowlength,
+                    arrowwidth: this.arrowwidth,
+                    lw: 1,
+                });
+            }
+        }
+    }
+}
+export class SegmentCircle {
+    center;
+    radius;
+    color;
+    lw;
+    ls;
+    fill;
+    zorder;
+    visible = true;
+    constructor(center, radius, opts = {}) {
+        this.center = center;
+        this.radius = radius;
+        Object.assign(this, opts);
+    }
+    xform(transform, style) {
+        const c = transform.transform(this.center);
+        const z = transform.zoom;
+        const uniform = z.x === z.y;
+        if (!uniform) {
+            throw new Error("SegmentCircle xform with non-uniform zoom not implemented in TS subset");
+        }
+        return new SegmentCircle([c.x, c.y], this.radius * z.x, {
+            color: this.color ?? style.color,
+            lw: this.lw ?? style.lw,
+            ls: (this.ls ?? style.ls),
+            fill: this.fill ?? style.fill,
+            zorder: this.zorder ?? style.zorder,
+        });
+    }
+    getBBox() {
+        const [cx, cy] = this.center;
+        const r = this.radius;
+        return bbox(cx - r, cy - r, cx + r, cy + r);
+    }
+    doreverse(centerx) {
+        this.center = mirrorxXY(this.center[0], this.center[1], centerx);
+    }
+    doflip() {
+        this.center = flipXY(this.center[0], this.center[1]);
+    }
+    draw(fig, transform, style) {
+        if (!this.visible) {
+            return;
+        }
+        const gid = style._svgGradientFillId;
+        const c = transform.transform(this.center);
+        const r = this.radius * transform.zoom.x;
+        const color = (this.color ?? style.color ?? "black");
+        const lw = (this.lw ?? style.lw ?? 2);
+        let fill = resolveBgFill(this.fill ?? style.fill, style);
+        if (gid) {
+            fill = `url(#${gid})`;
+        }
+        else if (fill === true) {
+            fill = color;
+        }
+        else if (fill === false) {
+            fill = "none";
+        }
+        if (fill === undefined || fill === null) {
+            fill = "none";
+        }
+        fig.circle(c.x, c.y, r, {
+            color,
+            lw,
+            ls: (this.ls ?? style.ls),
+            fill: fill,
+            zorder: this.zorder ?? style.zorder ?? 1,
+        });
+    }
+}
+/** Text label in element-local coordinates — aligned with Python `SegmentText` (subset). */
+export class SegmentText {
+    xy;
+    text;
+    color;
+    fontsize;
+    fontfamily;
+    /** Math font (Python `SegmentText.mathfont`); used when text contains `$…$` (no Ziamath — SVG font-family only). */
+    mathfont;
+    zorder;
+    visible = true;
+    halign;
+    valign;
+    /** Hyperlink on label (Python `IcPin.href`). */
+    href;
+    /** `"underline"` / `"overline"` (Python `IcPin.decoration`). */
+    decoration;
+    /**
+     * Extra rotation in degrees (local), added to the element transform (Python `IcPin` name labels).
+     * If omitted, text is not rotated with the element (legacy behavior for unlabeled segments).
+     */
+    rotation;
+    constructor(xy, text, opts = {}) {
+        const p = xy instanceof Point ? xy : Point.fromXY(xy);
+        this.xy = [p.x, p.y];
+        this.text = text;
+        const al = opts.align;
+        if (al) {
+            this.halign = al[0];
+            this.valign = al[1];
+        }
+        Object.assign(this, opts);
+    }
+    xform(transform, style) {
+        const p = transform.transform(this.xy);
+        return new SegmentText([p.x, p.y], this.text, {
+            color: this.color ?? style.color,
+            fontsize: this.fontsize ?? style.fontsize,
+            fontfamily: this.fontfamily ?? style.font,
+            mathfont: this.mathfont ?? style.mathfont,
+            zorder: this.zorder ?? style.zorder,
+            visible: this.visible,
+            halign: this.halign,
+            valign: this.valign,
+            href: this.href,
+            decoration: this.decoration,
+            rotation: this.rotation,
+        });
+    }
+    getBBox() {
+        const fs = this.fontsize ?? 14;
+        const scale = PT_PER_IN * 0.5;
+        let w;
+        let h;
+        if (hasMath(this.text)) {
+            const sz = estimateMathSize(this.text, fs);
+            w = sz.width / scale;
+            h = sz.height / scale;
+        }
+        else {
+            const { width: wPt, height: hPt } = textSize(this.text, fs, this.fontfamily);
+            w = wPt / scale;
+            h = hPt / scale;
+        }
+        const ha = this.halign ?? "center";
+        let x0;
+        let x1;
+        if (ha === "left") {
+            x0 = this.xy[0];
+            x1 = this.xy[0] + w;
+        }
+        else if (ha === "right") {
+            x0 = this.xy[0] - w;
+            x1 = this.xy[0];
+        }
+        else {
+            x0 = this.xy[0] - w / 2;
+            x1 = this.xy[0] + w / 2;
+        }
+        const va = this.valign ?? "center";
+        let y = this.xy[1];
+        if (va === "center") {
+            y -= h / 2;
+        }
+        else if (va === "top") {
+            y -= h;
+        }
+        else if (va === "bottom") {
+            // y stays — bottom of text at anchor, text extends upward
+        }
+        else {
+            // base: approximate by treating like bottom
+            const nlines = this.text.split("\n").length;
+            y += fs * (2 / PT_PER_IN) * (nlines - 1);
+        }
+        return bbox(x0, y, x1, y + h);
+    }
+    doreverse(centerx) {
+        this.xy = mirrorxXY(this.xy[0], this.xy[1], centerx);
+        if (this.halign === "left") {
+            this.halign = "right";
+        }
+        else if (this.halign === "right") {
+            this.halign = "left";
+        }
+    }
+    doflip() {
+        this.xy = flipXY(this.xy[0], this.xy[1]);
+        if (this.valign === "top") {
+            this.valign = "bottom";
+        }
+        else if (this.valign === "bottom") {
+            this.valign = "top";
+        }
+    }
+    draw(fig, transform, style) {
+        if (!this.visible) {
+            return;
+        }
+        const p = transform.transform(this.xy);
+        const color = (this.color ?? style.color ?? "black");
+        const fontsize = (this.fontsize ?? style.fontsize ?? 14);
+        const baseFont = (this.fontfamily ?? style.font ?? "sans-serif");
+        const mathf = (this.mathfont ?? style.mathfont);
+        const t = this.text;
+        const baseDeg = (transform.theta * 180) / Math.PI;
+        const rotDeg = this.rotation !== undefined ? baseDeg + this.rotation : undefined;
+        if (hasMath(t) && isKatexAvailable()) {
+            const html = renderMathHtml(t, fontsize);
+            const { width, height } = estimateMathSize(t, fontsize);
+            fig.mathText(html, p.x, p.y, {
+                width,
+                height,
+                color,
+                fontsize,
+                halign: this.halign ?? "center",
+                valign: this.valign ?? "center",
+                zorder: this.zorder ?? style.zorder ?? 3,
+                rotation: rotDeg,
+            });
+            return;
+        }
+        const font = mathf !== undefined && mathf !== "" && t.includes("$") ? mathf : baseFont;
+        const dec = this.decoration?.toLowerCase();
+        const textDecoration = dec === "underline" || dec === "overline" ? dec : undefined;
+        fig.text(this.text, p.x, p.y, {
+            color,
+            fontsize,
+            fontfamily: font,
+            halign: this.halign ?? "center",
+            valign: this.valign ?? "center",
+            zorder: this.zorder ?? style.zorder ?? 3,
+            href: this.href ?? undefined,
+            textDecoration,
+            rotation: rotDeg,
+        });
+    }
+}
+export class SegmentPoly {
+    verts;
+    closed = true;
+    cornerradius = 0;
+    color;
+    fill;
+    lw;
+    ls;
+    hatch;
+    joinstyle;
+    capstyle;
+    zorder;
+    visible = true;
+    clip;
+    constructor(verts, opts = {}) {
+        this.verts = verts;
+        Object.assign(this, opts);
+    }
+    xform(transform, style) {
+        const pts = transform.transformArray(this.verts.map(([x, y]) => [x, y]));
+        const v = pts.map((p) => [p.x, p.y]);
+        return new SegmentPoly(v, {
+            closed: this.closed,
+            cornerradius: this.cornerradius,
+            color: this.color ?? style.color,
+            fill: this.fill ?? style.fill,
+            lw: this.lw ?? style.lw,
+            ls: this.ls ?? style.ls,
+            hatch: this.hatch,
+            joinstyle: this.joinstyle ?? style.joinstyle,
+            capstyle: this.capstyle ?? style.capstyle,
+            zorder: this.zorder ?? style.zorder,
+            visible: this.visible,
+            clip: this.clip,
+        });
+    }
+    getBBox() {
+        const x = this.verts.map((p) => p[0]);
+        const y = this.verts.map((p) => p[1]);
+        return bbox(Math.min(...x), Math.min(...y), Math.max(...x), Math.max(...y));
+    }
+    doreverse(centerx) {
+        this.verts = [...this.verts].reverse().map(([x, y]) => mirrorxXY(x, y, centerx));
+    }
+    doflip() {
+        this.verts = this.verts.map(([x, y]) => flipXY(x, y));
+    }
+    draw(fig, transform, style) {
+        if (!this.visible) {
+            return;
+        }
+        const gid = style._svgGradientFillId;
+        let rawFill = this.fill !== undefined ? this.fill : style.fill;
+        rawFill = resolveBgFill(rawFill, style);
+        let fill = rawFill === true
+            ? (style.color ?? "black")
+            : typeof rawFill === "string"
+                ? rawFill
+                : undefined;
+        if (gid && this.closed) {
+            fill = `url(#${gid})`;
+        }
+        const color = (this.color ?? style.color ?? "black");
+        const verts = transform.transformArray(this.verts.map(([x, y]) => [x, y]));
+        let vlist = verts.map((p) => ({ x: p.x, y: p.y }));
+        if (this.cornerradius > 0) {
+            const rc = roundCorners(this.verts.map(([x, y]) => [x, y]), this.cornerradius);
+            vlist = transform.transformArray(rc.map((p) => [p.x, p.y])).map((p) => ({ x: p.x, y: p.y }));
+        }
+        fig.poly(vlist, {
+            closed: this.closed,
+            color,
+            fill: fill === undefined ? "none" : fill,
+            lw: (this.lw ?? style.lw ?? 2),
+            ls: (this.ls ?? style.ls ?? "-"),
+            hatch: this.hatch,
+            capstyle: (this.capstyle ?? style.capstyle ?? "round"),
+            joinstyle: (this.joinstyle ?? style.joinstyle ?? "round"),
+            zorder: this.zorder ?? style.zorder ?? 1,
+        });
+    }
+}
+export class SegmentArc {
+    center;
+    width;
+    height;
+    theta1;
+    theta2;
+    arrow;
+    arrowwidth = 0.15;
+    arrowlength = 0.25;
+    angle = 0;
+    color;
+    lw;
+    ls;
+    fill;
+    zorder;
+    visible = true;
+    clip;
+    constructor(center, width, height, opts = {}) {
+        this.center = center;
+        this.width = width;
+        this.height = height;
+        this.theta1 = opts.theta1 ?? 35;
+        this.theta2 = opts.theta2 ?? -35;
+        this.arrow = opts.arrow;
+        if (opts.arrowwidth !== undefined) {
+            this.arrowwidth = opts.arrowwidth;
+        }
+        if (opts.arrowlength !== undefined) {
+            this.arrowlength = opts.arrowlength;
+        }
+        this.angle = opts.angle ?? 0;
+        this.color = opts.color;
+        this.lw = opts.lw;
+        this.ls = opts.ls;
+        this.fill = opts.fill;
+        this.zorder = opts.zorder;
+        this.visible = opts.visible ?? true;
+        this.clip = opts.clip;
+    }
+    xform(transform, style) {
+        const c = transform.transform(this.center);
+        const ang = this.angle + transform.theta;
+        return new SegmentArc([c.x, c.y], this.width * transform.zoom.x, this.height * transform.zoom.y, {
+            theta1: this.theta1,
+            theta2: this.theta2,
+            angle: ang,
+            arrow: this.arrow,
+            arrowwidth: this.arrowwidth,
+            arrowlength: this.arrowlength,
+            color: this.color ?? style.color,
+            lw: this.lw ?? style.lw,
+            ls: this.ls ?? style.ls,
+            fill: this.fill ?? style.fill,
+            zorder: this.zorder ?? style.zorder,
+            visible: this.visible,
+            clip: this.clip,
+        });
+    }
+    getBBox() {
+        const th1 = (this.theta1 * Math.PI) / 180;
+        const th2 = (this.theta2 * Math.PI) / 180;
+        let t1a = Math.atan2(this.width * Math.sin(th1), this.height * Math.cos(th1));
+        let t2a = Math.atan2(this.width * Math.sin(th2), this.height * Math.cos(th2));
+        while (t2a < t1a) {
+            t2a += 2 * Math.PI;
+        }
+        const phi = (this.angle * Math.PI) / 180;
+        const rx = this.width / 2;
+        const ry = this.height / 2;
+        const n = 50;
+        const xx = [];
+        const yy = [];
+        for (let i = 0; i <= n; i++) {
+            const t = t1a + ((t2a - t1a) * i) / n;
+            const st = Math.sin(t);
+            const ct = Math.cos(t);
+            xx.push(this.center[0] + rx * ct * Math.cos(phi) - ry * st * Math.sin(phi));
+            yy.push(this.center[1] + rx * ct * Math.sin(phi) + ry * st * Math.cos(phi));
+        }
+        return bbox(Math.min(...xx), Math.min(...yy), Math.max(...xx), Math.max(...yy));
+    }
+    doreverse(centerx) {
+        this.center = mirrorxXY(this.center[0], this.center[1], centerx);
+        const t1 = this.theta1;
+        const t2 = this.theta2;
+        this.theta1 = 180 - t2;
+        this.theta2 = 180 - t1;
+        if (this.arrow === "cw") {
+            this.arrow = "ccw";
+        }
+        else if (this.arrow === "ccw") {
+            this.arrow = "cw";
+        }
+    }
+    doflip() {
+        this.center = flipXY(this.center[0], this.center[1]);
+        const t1 = this.theta1;
+        const t2 = this.theta2;
+        this.theta1 = -t2;
+        this.theta2 = -t1;
+        if (this.arrow === "cw") {
+            this.arrow = "ccw";
+        }
+        else if (this.arrow === "ccw") {
+            this.arrow = "cw";
+        }
+    }
+    draw(fig, transform, style) {
+        if (!this.visible) {
+            return;
+        }
+        const c = transform.transform(this.center);
+        const w = this.width * transform.zoom.x;
+        const h = this.height * transform.zoom.y;
+        fig.arc([c.x, c.y], w, h, {
+            theta1: this.theta1,
+            theta2: this.theta2,
+            angle: this.angle + transform.theta,
+            color: (this.color ?? style.color ?? "black"),
+            lw: (this.lw ?? style.lw ?? 2),
+            ls: (this.ls ?? style.ls ?? "-"),
+            fill: resolveBgFill(this.fill ?? style.fill, style),
+            zorder: this.zorder ?? style.zorder ?? 1,
+            arrow: this.arrow ?? undefined,
+            arrowwidth: this.arrowwidth,
+            arrowlength: this.arrowlength,
+        });
+    }
+}
+export class SegmentBezier {
+    p;
+    color;
+    lw;
+    ls;
+    capstyle;
+    arrow;
+    arrowlength = 0.25;
+    arrowwidth = 0.15;
+    zorder;
+    visible = true;
+    clip;
+    constructor(pts, opts = {}) {
+        this.p = pts;
+        Object.assign(this, opts);
+    }
+    xform(transform, style) {
+        const pts = transform.transformArray(this.p.map(([x, y]) => [x, y]));
+        const pp = pts.map((pt) => [pt.x, pt.y]);
+        return new SegmentBezier(pp, {
+            color: this.color ?? style.color,
+            lw: this.lw ?? style.lw,
+            ls: this.ls ?? style.ls,
+            capstyle: this.capstyle ?? style.capstyle,
+            arrow: this.arrow,
+            arrowlength: this.arrowlength,
+            arrowwidth: this.arrowwidth,
+            zorder: this.zorder ?? style.zorder,
+            visible: this.visible,
+            clip: this.clip,
+        });
+    }
+    getBBox() {
+        const t = linspaceBezier(0, 1, 50);
+        const px = this.p.map((q) => q[0]);
+        const py = this.p.map((q) => q[1]);
+        let x;
+        let y;
+        if (this.p.length === 3) {
+            x = t.map((tt) => (1 - tt) ** 2 * px[0] + 2 * (1 - tt) * tt * px[1] + tt ** 2 * px[2]);
+            y = t.map((tt) => (1 - tt) ** 2 * py[0] + 2 * (1 - tt) * tt * py[1] + tt ** 2 * py[2]);
+        }
+        else {
+            x = t.map((tt) => (1 - tt) ** 3 * px[0] +
+                3 * (1 - tt) ** 2 * tt * px[1] +
+                3 * (1 - tt) * tt ** 2 * px[2] +
+                tt ** 3 * px[3]);
+            y = t.map((tt) => (1 - tt) ** 3 * py[0] +
+                3 * (1 - tt) ** 2 * tt * py[1] +
+                3 * (1 - tt) * tt ** 2 * py[2] +
+                tt ** 3 * py[3]);
+        }
+        return bbox(Math.min(...x), Math.min(...y), Math.max(...x), Math.max(...y));
+    }
+    doreverse(centerx) {
+        /** Python `SegmentBezier` mirrors each control point (no path reversal). */
+        this.p = this.p.map(([x, y]) => mirrorxXY(x, y, centerx));
+        if (this.arrow) {
+            const rev = [...this.arrow].reverse().join("");
+            this.arrow = rev
+                .split("")
+                .map((c) => (c === "<" ? ">" : c === ">" ? "<" : c))
+                .join("");
+        }
+    }
+    doflip() {
+        this.p = this.p.map(([x, y]) => flipXY(x, y));
+    }
+    draw(fig, transform, style) {
+        if (!this.visible) {
+            return;
+        }
+        const pts = transform.transformArray(this.p.map(([x, y]) => [x, y]));
+        const pp = pts.map((p) => ({ x: p.x, y: p.y }));
+        fig.bezier(pp, {
+            color: (this.color ?? style.color ?? "black"),
+            lw: (this.lw ?? style.lw ?? 2),
+            ls: (this.ls ?? style.ls ?? "-"),
+            capstyle: (this.capstyle ?? style.capstyle ?? "round"),
+            zorder: this.zorder ?? style.zorder ?? 1,
+            arrow: this.arrow,
+            arrowlength: this.arrowlength,
+            arrowwidth: this.arrowwidth,
+        });
+    }
+}
+function linspaceBezier(a, b, n) {
+    if (n < 2) {
+        return [a];
+    }
+    const step = (b - a) / (n - 1);
+    return Array.from({ length: n }, (_, i) => a + step * i);
+}
+export class SegmentPath {
+    path;
+    color;
+    lw;
+    ls;
+    capstyle;
+    joinstyle;
+    fill;
+    zorder;
+    visible = true;
+    clip;
+    constructor(path, opts = {}) {
+        this.path = path;
+        Object.assign(this, opts);
+    }
+    xform(transform, style) {
+        const next = [];
+        for (const item of this.path) {
+            if (typeof item === "string") {
+                next.push(item);
+            }
+            else {
+                const p = transform.transform(item);
+                next.push([p.x, p.y]);
+            }
+        }
+        return new SegmentPath(next, {
+            color: this.color ?? style.color,
+            lw: this.lw ?? style.lw,
+            ls: this.ls ?? style.ls,
+            capstyle: this.capstyle ?? style.capstyle,
+            joinstyle: this.joinstyle ?? style.joinstyle,
+            fill: this.fill ?? style.fill,
+            zorder: this.zorder ?? style.zorder,
+            visible: this.visible,
+            clip: this.clip,
+        });
+    }
+    getBBox() {
+        const xs = [];
+        const ys = [];
+        for (const item of this.path) {
+            if (typeof item !== "string") {
+                xs.push(item[0]);
+                ys.push(item[1]);
+            }
+        }
+        if (xs.length === 0) {
+            return bbox(0, 0, 0, 0);
+        }
+        return bbox(Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys));
+    }
+    /** SVG path commands are not transformed; matches Python stub. */
+    doreverse(_centerx) { }
+    doflip() { }
+    draw(fig, transform, style) {
+        if (!this.visible) {
+            return;
+        }
+        const parts = [];
+        for (const item of this.path) {
+            if (typeof item === "string") {
+                parts.push(item);
+            }
+            else {
+                const p = transform.transform(item);
+                parts.push({ x: p.x, y: p.y });
+            }
+        }
+        fig.path(parts, {
+            color: (this.color ?? style.color ?? "black"),
+            lw: (this.lw ?? style.lw ?? 2),
+            ls: (this.ls ?? style.ls ?? "-"),
+            capstyle: (this.capstyle ?? style.capstyle ?? "round"),
+            joinstyle: (this.joinstyle ?? style.joinstyle ?? "round"),
+            fill: (this.fill === true ? style.color : resolveBgFill(this.fill, style)),
+            zorder: this.zorder ?? style.zorder ?? 1,
+        });
+    }
+}
+export class SegmentImage {
+    image;
+    xy;
+    width;
+    height;
+    rotate;
+    imgfmt;
+    zorder;
+    visible = true;
+    constructor(image, opts = {}) {
+        this.image = image;
+        this.xy = opts.xy ?? [0, 0];
+        this.width = opts.width ?? 3;
+        this.height = opts.height ?? 1;
+        this.rotate = opts.rotate ?? 0;
+        this.imgfmt = opts.imgfmt;
+        this.zorder = opts.zorder;
+    }
+    getBBox() {
+        if (this.rotate % 360 === 0) {
+            return bbox(this.xy[0], this.xy[1], this.xy[0] + this.width, this.xy[1] + this.height);
+        }
+        const p1 = new Point(this.xy[0], this.xy[1]).rotate(this.rotate);
+        const p2 = new Point(this.xy[0] + this.width, this.xy[1]).rotate(this.rotate);
+        const p3 = new Point(this.xy[0] + this.width, this.xy[1] + this.height).rotate(this.rotate);
+        const p4 = new Point(this.xy[0], this.xy[1] + this.height).rotate(this.rotate);
+        const pts = [p1, p2, p3, p4];
+        return bbox(Math.min(...pts.map((p) => p.x)), Math.min(...pts.map((p) => p.y)), Math.max(...pts.map((p) => p.x)), Math.max(...pts.map((p) => p.y)));
+    }
+    xform(transform, style) {
+        const p = transform.transform(this.xy);
+        return new SegmentImage(this.image, {
+            xy: [p.x, p.y],
+            width: this.width * transform.zoom.x,
+            height: this.height * transform.zoom.y,
+            rotate: this.rotate + transform.theta,
+            imgfmt: this.imgfmt,
+            zorder: this.zorder ?? style.zorder,
+        });
+    }
+    doreverse(_centerx) { }
+    doflip() { }
+    draw(fig, transform, style) {
+        if (!this.visible) {
+            return;
+        }
+        const p = transform.transform(this.xy);
+        fig.image(this.image, [p.x, p.y], this.width * transform.zoom.x, this.height * transform.zoom.y, {
+            rotate: this.rotate + transform.theta,
+            zorder: this.zorder ?? style.zorder ?? 1,
+            imgfmt: this.imgfmt,
+        });
+    }
+}
+//# sourceMappingURL=segment.js.map