@skillpet/circuit 0.5.0

package/dist/elements/ic.js

@@ -0,0 +1,816 @@
+/**
+ * Integrated circuits — aligned with Python `elements/intcircuits.py` (subset + parity-oriented).
+ */
+import { Element } from "../element.js";
+import { Point } from "../geometry/point.js";
+import { linspace } from "../geometry/util.js";
+import { getParam } from "../params.js";
+import { Segment, SegmentCircle, SegmentPoly, SegmentText } from "../segment.js";
+function normSide(side) {
+    const c = side[0].toUpperCase();
+    if (c === "L" || c === "R" || c === "T" || c === "B") {
+        return c;
+    }
+    return "L";
+}
+/**
+ * Python `elements.intcircuits.IcPin` dataclass — 可与 {@link Ic} 构造函数 / {@link Ic.pin} 混用。
+ */
+export class IcPin {
+    name;
+    pin;
+    side;
+    pos;
+    slot;
+    invert = false;
+    invertradius = 0.15;
+    color;
+    rotation = 0;
+    anchorname;
+    lblsize;
+    pinlblsize;
+    href;
+    decoration;
+    constructor(opts = {}) {
+        this.side = opts.side !== undefined ? normSide(String(opts.side)) : "L";
+        if (opts.name !== undefined)
+            this.name = opts.name;
+        if (opts.pin !== undefined)
+            this.pin = opts.pin;
+        if (opts.pos !== undefined)
+            this.pos = opts.pos;
+        if (opts.slot !== undefined)
+            this.slot = opts.slot;
+        if (opts.invert !== undefined)
+            this.invert = opts.invert;
+        if (opts.invertradius !== undefined)
+            this.invertradius = opts.invertradius;
+        if (opts.color !== undefined)
+            this.color = opts.color;
+        if (opts.rotation !== undefined)
+            this.rotation = opts.rotation;
+        if (opts.anchorname !== undefined)
+            this.anchorname = opts.anchorname;
+        if (opts.lblsize !== undefined)
+            this.lblsize = opts.lblsize;
+        if (opts.pinlblsize !== undefined)
+            this.pinlblsize = opts.pinlblsize;
+        if (opts.href !== undefined)
+            this.href = opts.href;
+        if (opts.decoration !== undefined)
+            this.decoration = opts.decoration;
+    }
+}
+function textSizeApprox(label, sizePt) {
+    const w = Math.max(0.15, (label.length * sizePt) / 72);
+    const h = (sizePt / 72) * 1.2;
+    return [w * 2, h * 2];
+}
+function cloneSide(s) {
+    return { ...s };
+}
+export class Ic extends Element {
+    size;
+    slant;
+    pins;
+    usersides;
+    sides;
+    pincount = { L: 0, R: 0, T: 0, B: 0 };
+    _sizeauto;
+    _icbox;
+    _dflt;
+    constructor(opts = {}) {
+        const { size, pins, slant, label, ...rest } = opts;
+        super({ ...rest, ...(label !== undefined ? { label } : {}) });
+        Object.assign(this.defaults, {
+            pinspacing: 0,
+            edgepadH: 0.5,
+            edgepadW: 0.5,
+            leadlen: 0.5,
+            lsize: 14,
+            lofst: 0.15,
+            plblofst: 0.075,
+            plblsize: 11,
+        });
+        this.slant = slant ?? 0;
+        this.pins = { L: [], R: [], T: [], B: [] };
+        this.usersides = {};
+        this.sides = {
+            L: this.mkSide(),
+            R: this.mkSide(),
+            T: this.mkSide(),
+            B: this.mkSide(),
+        };
+        this._dflt = this.mkSide();
+        this.size = size ?? this.params.size;
+        if (pins) {
+            for (const p of pins) {
+                this.pins[p.side].push({ ...p, side: p.side });
+            }
+        }
+        this._setsize();
+    }
+    mkSide() {
+        return {
+            spacing: getParam(this.params, "pinspacing", 0),
+            pad: getParam(this.params, "edgepadH", 0.25),
+            leadlen: getParam(this.params, "leadlen", 0.5),
+            label_ofst: getParam(this.params, "lofst", 0.15),
+            label_size: getParam(this.params, "lsize", 14),
+            pinlabel_ofst: getParam(this.params, "plblofst", 0.05),
+            pinlabel_size: getParam(this.params, "plblsize", 11),
+        };
+    }
+    pin(spec) {
+        const side = normSide(spec.side ?? "L");
+        const p = {
+            side,
+            name: spec.name,
+            pin: spec.pin,
+            pos: spec.pos,
+            slot: spec.slot,
+            invert: spec.invert ?? false,
+            invertradius: spec.invertradius ?? 0.15,
+            color: spec.color,
+            rotation: spec.rotation ?? 0,
+            anchorname: spec.anchorname,
+            lblsize: spec.lblsize,
+            pinlblsize: spec.pinlblsize,
+            href: spec.href,
+            decoration: spec.decoration,
+        };
+        this.pins[side].push(p);
+        this._setsize();
+        return this;
+    }
+    side(sideStr, spacing = 0, pad = 0.5, leadlen = 0.5, label_ofst = 0.15, label_size = 14, pinlabel_ofst = 0.05, pinlabel_size = 11) {
+        const side = normSide(sideStr);
+        this.usersides[side] = {
+            spacing,
+            pad,
+            leadlen,
+            label_ofst,
+            label_size,
+            pinlabel_ofst,
+            pinlabel_size,
+        };
+        this._setsize();
+        return this;
+    }
+    /** Python `Ic.pinnames` — logical pin names (anchorname or name). */
+    get pinnames() {
+        const names = [];
+        for (const side of ["L", "R", "T", "B"]) {
+            for (const p of this.pins[side]) {
+                if (p.name) {
+                    names.push(p.anchorname ?? p.name);
+                }
+            }
+        }
+        return names;
+    }
+    /**
+     * Extends {@link Element.getAnchorNamesForGetattr} with {@link pinnames} and `pin{n}` (Python `Ic.__getattr__`).
+     */
+    getAnchorNamesForGetattr() {
+        const set = new Set(super.getAnchorNamesForGetattr());
+        for (const side of ["L", "R", "T", "B"]) {
+            for (const p of this.pins[side]) {
+                if (p.name) {
+                    set.add(p.anchorname ?? p.name);
+                }
+                if (p.pin) {
+                    set.add(`pin${p.pin}`);
+                }
+            }
+        }
+        return [...set];
+    }
+    /** Python `ic[name]`; same as {@link Element.resolveAnchor}. */
+    getPinAnchor(name) {
+        return this.resolveAnchor(name);
+    }
+    _countpins() {
+        const out = { L: 0, R: 0, T: 0, B: 0 };
+        for (const s of ["L", "R", "T", "B"]) {
+            const slotnames = this.pins[s].map((p) => p.slot).filter((x) => x != null);
+            const slots = slotnames.map((p) => Number(p.split("/")[1])).concat([0]);
+            out[s] = Math.max(this.pins[s].length, Math.max(...slots));
+        }
+        return out;
+    }
+    _autosize() {
+        const lengths = {};
+        const labelwidths = {};
+        for (const side of ["L", "R", "T", "B"]) {
+            let sideparam = cloneSide(this.usersides[side] ?? this._dflt);
+            if (sideparam.spacing === 0) {
+                sideparam = { ...sideparam, spacing: 0.6 };
+            }
+            this.sides[side] = sideparam;
+            const n = Math.max(1, this.pincount[side]);
+            lengths[side] = sideparam.pad * 2 + sideparam.spacing * (n - 1);
+            let labelw = 0;
+            for (const p of this.pins[side]) {
+                if (p.name) {
+                    const lbls = p.lblsize ?? getParam(this.params, "lsize", 14);
+                    labelw = Math.max(labelw, textSizeApprox(p.name, lbls)[0]);
+                }
+            }
+            labelwidths[side] = labelw;
+        }
+        const labelw = labelwidths["L"] + labelwidths["R"] + 4 * getParam(this.params, "lofst", 0.15);
+        const boxh = Math.max(lengths["L"] ?? 0, lengths["R"] ?? 0, 2 + getParam(this.params, "edgepadH", 0.5));
+        const boxw = Math.max(lengths["T"] ?? 0, lengths["B"] ?? 0, 2 + getParam(this.params, "edgepadW", 0.5), labelw);
+        this._sizeauto = [boxw, boxh];
+        for (const side of ["L", "R"]) {
+            const sp = this.sides[side];
+            const pc = Math.max(1, this.pincount[side]);
+            sp.pad = (boxh - sp.spacing * (pc - 1)) / 2;
+        }
+        for (const side of ["T", "B"]) {
+            const sp = this.sides[side];
+            const pc = Math.max(1, this.pincount[side]);
+            sp.pad = (boxw - sp.spacing * (pc - 1)) / 2;
+        }
+    }
+    _autopinlayout() {
+        const sz = this.size;
+        for (const side of ["L", "R", "T", "B"]) {
+            let sideparam = cloneSide(this.usersides[side] ?? this._dflt);
+            this.sides[side] = sideparam;
+            const length = ["T", "B"].includes(side) ? sz[0] : sz[1];
+            const pad = sideparam.pad;
+            if (sideparam.spacing === 0) {
+                if (this.pincount[side] > 1) {
+                    sideparam.spacing = (length - 2 * pad) / (this.pincount[side] - 1);
+                }
+                else {
+                    sideparam.pad = length / 2;
+                }
+            }
+            else {
+                sideparam.pad = (length - sideparam.spacing * (this.pincount[side] - 1)) / 2;
+            }
+        }
+    }
+    _setsize() {
+        this.pincount = this._countpins();
+        if (this.size === undefined) {
+            this._autosize();
+        }
+        else {
+            this._autopinlayout();
+        }
+    }
+    _drawBox() {
+        let w;
+        let h;
+        if (this.size) {
+            [w, h] = this.size;
+        }
+        else if (this._sizeauto) {
+            [w, h] = this._sizeauto;
+        }
+        else {
+            w = 2;
+            h = 3;
+        }
+        const tanslant = w * Math.tan((this.slant * Math.PI) / 180);
+        let y1 = 0;
+        let y2 = h;
+        let path;
+        if (this.slant > 0) {
+            y1 = 0 - tanslant;
+            y2 = h + tanslant;
+            path = [
+                new Point(0, 0),
+                new Point(w, y1),
+                new Point(w, y2),
+                new Point(0, h),
+                new Point(0, 0),
+            ];
+        }
+        else if (this.slant < 0) {
+            y1 = 0 + tanslant;
+            y2 = h - tanslant;
+            path = [new Point(0, y1), new Point(w, 0), new Point(w, h), new Point(0, y2), new Point(0, y1)];
+        }
+        else {
+            y1 = 0;
+            y2 = h;
+            path = [new Point(0, 0), new Point(w, 0), new Point(w, h), new Point(0, h), new Point(0, 0)];
+        }
+        this.segments.push(new Segment(path.map((p) => [p.x, p.y]), {}));
+        return { w, h, y1, y2 };
+    }
+    _pinpos(side, pin, num) {
+        const sidesetup = this.sides[side] ?? this._dflt;
+        let spacing = sidesetup.spacing > 0 ? sidesetup.spacing : 0.6;
+        let idx = num;
+        if (pin.slot) {
+            idx = Number(pin.slot.split("/")[0]) - 1;
+        }
+        let z = sidesetup.pad + idx * spacing;
+        if (pin.pos !== undefined && pin.pos !== null) {
+            z = sidesetup.pad + pin.pos * (this.pincount[side] - 1) * spacing;
+        }
+        let xy;
+        if (side === "L") {
+            xy = new Point(0, z);
+        }
+        else if (side === "R") {
+            xy = new Point(this._icbox.w, z);
+        }
+        else if (side === "T") {
+            xy = new Point(z, this._icbox.h);
+        }
+        else {
+            xy = new Point(z, 0);
+        }
+        if (side === "T" && this.slant > 0) {
+            xy = new Point(xy.x, xy.y - xy.x * Math.tan((-this.slant * Math.PI) / 180));
+        }
+        else if (side === "T" && this.slant < 0) {
+            xy = new Point(xy.x, xy.y + (this._icbox.y2 - this._icbox.h) - xy.x * Math.tan((-this.slant * Math.PI) / 180));
+        }
+        else if (side === "B" && this.slant < 0) {
+            xy = new Point(xy.x, xy.y - (this._icbox.y2 - this._icbox.h) - xy.x * Math.tan((this.slant * Math.PI) / 180));
+        }
+        else if (side === "B" && this.slant > 0) {
+            xy = new Point(xy.x, xy.y - xy.x * Math.tan((this.slant * Math.PI) / 180));
+        }
+        return xy;
+    }
+    _drawClkpin(xy, leadext, side) {
+        const sidesetup = this.sides[side] ?? this._dflt;
+        const clkw = 0.4 * (sidesetup.label_size / 16);
+        const clkh = 0.2 * (sidesetup.label_size / 16);
+        let clkpath;
+        if (side === "T" || side === "B") {
+            const sgn = leadext.y !== 0 ? Math.sign(leadext.y) : 1;
+            const cw = Math.abs(clkw) * sgn;
+            clkpath = [
+                new Point(xy.x - clkh, xy.y),
+                new Point(xy.x, xy.y - cw),
+                new Point(xy.x + clkh, xy.y),
+            ];
+        }
+        else {
+            const sgn = leadext.x !== 0 ? -Math.sign(leadext.x) : 1;
+            const cw = Math.abs(clkw) * sgn;
+            clkpath = [
+                new Point(xy.x, xy.y + clkh),
+                new Point(xy.x + cw, xy.y),
+                new Point(xy.x, xy.y - clkh),
+            ];
+        }
+        this.segments.push(new Segment(clkpath.map((p) => [p.x, p.y])));
+    }
+    _drawPin(side, pin, num) {
+        const sidesetup = this.sides[side] ?? this._dflt;
+        const xy = this._pinpos(side, pin, num);
+        const leadMap = {
+            L: new Point(-sidesetup.leadlen, 0),
+            R: new Point(sidesetup.leadlen, 0),
+            T: new Point(0, sidesetup.leadlen),
+            B: new Point(0, -sidesetup.leadlen),
+        };
+        const leadext = leadMap[side];
+        const anchorpos = xy.add(leadext);
+        this.anchors[`in${side}${num + 1}`] = [anchorpos.x, anchorpos.y];
+        if (pin.anchorname) {
+            this.anchors[pin.anchorname] = [anchorpos.x, anchorpos.y];
+        }
+        else if (pin.name) {
+            if (pin.name === ">") {
+                this.anchors.CLK = [anchorpos.x, anchorpos.y];
+            }
+            this.anchors[pin.name] = [anchorpos.x, anchorpos.y];
+        }
+        if (pin.pin) {
+            this.anchors[`pin${pin.pin}`] = [anchorpos.x, anchorpos.y];
+        }
+        if (sidesetup.leadlen > 0) {
+            if (pin.invert) {
+                const ir = pin.invertradius ?? 0.15;
+                const invertofst = {
+                    L: new Point(-ir, 0),
+                    R: new Point(ir, 0),
+                    T: new Point(0, ir),
+                    B: new Point(0, -ir),
+                };
+                const io = invertofst[side];
+                const c = xy.add(io);
+                this.segments.push(new SegmentCircle([c.x, c.y], ir));
+                const start = c.add(io.mul(2));
+                this.segments.push(new Segment([
+                    [start.x, start.y],
+                    [anchorpos.x, anchorpos.y],
+                ], {}));
+            }
+            else {
+                this.segments.push(new Segment([
+                    [xy.x, xy.y],
+                    [anchorpos.x, anchorpos.y],
+                ], {}));
+            }
+        }
+        if (pin.pin) {
+            const invr = (pin.invert ? pin.invertradius ?? 0.15 : 0) * (pin.invert ? 1 : 0);
+            const plbl = sidesetup.pinlabel_ofst;
+            const pofst = {
+                L: new Point(-plbl - invr * 2, plbl),
+                R: new Point(plbl + invr * 2, plbl),
+                T: new Point(plbl, plbl + invr * 2),
+                B: new Point(plbl, -plbl - invr * 2),
+            };
+            let off = pofst[side];
+            const flipU = this.userParams.flip === true;
+            const revU = this.userParams.reverse === true;
+            const align0 = { L: "right", R: "left", T: "left", B: "left" };
+            const align1 = { L: "bottom", R: "bottom", T: "bottom", B: "top" };
+            let h = align0[side];
+            let v = align1[side];
+            if (flipU && (side === "L" || side === "R")) {
+                off = off.flip();
+            }
+            if (flipU && (side === "T" || side === "B")) {
+                v = side === "T" ? "top" : "bottom";
+            }
+            if (revU && (side === "L" || side === "R")) {
+                h = side === "L" ? "left" : "right";
+            }
+            if (revU && (side === "T" || side === "B")) {
+                off = off.mirrorx(0);
+            }
+            const po = xy.add(off);
+            this.segments.push(new SegmentText([po.x, po.y], String(pin.pin), {
+                fontsize: pin.pinlblsize ?? sidesetup.pinlabel_size,
+                align: [h, v],
+            }));
+        }
+        if (pin.name === ">") {
+            this._drawClkpin(xy, leadext, side);
+            return;
+        }
+        if (pin.name && pin.name !== "") {
+            const pofst = {
+                L: new Point(sidesetup.label_ofst, 0),
+                R: new Point(-sidesetup.label_ofst, 0),
+                T: new Point(0, -sidesetup.label_ofst),
+                B: new Point(0, sidesetup.label_ofst),
+            };
+            const po = xy.add(pofst[side]);
+            const flipU = this.userParams.flip === true;
+            const revU = this.userParams.reverse === true;
+            const ah = { L: "left", R: "right", T: "center", B: "center" };
+            const av = { L: "center", R: "center", T: "top", B: "bottom" };
+            let h = ah[side];
+            let v = av[side];
+            if (flipU && (side === "T" || side === "B")) {
+                v = side === "T" ? "bottom" : "top";
+            }
+            if (revU && (side === "L" || side === "R")) {
+                h = side === "L" ? "right" : "left";
+            }
+            this.segments.push(new SegmentText([po.x, po.y], pin.name, {
+                fontsize: pin.lblsize ?? sidesetup.label_size,
+                color: pin.color ?? undefined,
+                align: [h, v],
+                href: pin.href ?? undefined,
+                decoration: pin.decoration ?? undefined,
+                rotation: pin.rotation ?? 0,
+            }));
+        }
+    }
+    _drawPins() {
+        for (const side of ["L", "R", "T", "B"]) {
+            this.pins[side].forEach((p, i) => this._drawPin(side, p, i));
+        }
+    }
+    _place(dwgxy, dwgtheta, dwgparams) {
+        this.anchors = {};
+        this._setsize();
+        this._icbox = this._drawBox();
+        this._drawPins();
+        this.elmParams.lblloc = "center";
+        this.anchors.center = [this._icbox.w / 2, this._icbox.h / 2];
+        this.elmParams.drop = [this._icbox.w, this._icbox.h / 2];
+        return super._place(dwgxy, dwgtheta, dwgparams);
+    }
+}
+export class Multiplexer extends Ic {
+    constructor(opts = {}) {
+        const { demux = false, ...rest } = opts;
+        const sl = opts.slant !== undefined ? opts.slant : 25;
+        super({ ...rest, slant: demux ? sl : -sl });
+    }
+}
+export class DFlipFlop extends Ic {
+    constructor(opts = {}) {
+        const { preclr = false, preclrinvert = true, ...rest } = opts;
+        const pins = [
+            { name: "D", side: "L", slot: "2/2" },
+            { name: ">", side: "L", slot: "1/2" },
+            { name: "Q", side: "R", slot: "2/2" },
+            { name: "Q", side: "R", slot: "1/2", anchorname: "Qbar", decoration: "overline" },
+        ];
+        if (preclr) {
+            pins.push({ name: "PRE", side: "T", invert: preclrinvert });
+            pins.push({ name: "CLR", side: "B", invert: preclrinvert });
+        }
+        super({ ...rest, pins, size: rest.size ?? [2, 3] });
+    }
+}
+export class JKFlipFlop extends Ic {
+    constructor(opts = {}) {
+        const { preclr = false, preclrinvert = true, ...rest } = opts;
+        const pins = [
+            { name: "J", side: "L", slot: "3/3" },
+            { name: ">", side: "L", slot: "2/3" },
+            { name: "K", side: "L", slot: "1/3" },
+            { name: "Q", side: "R", slot: "3/3" },
+            { name: "Q", side: "R", slot: "1/3", anchorname: "Qbar", decoration: "overline" },
+        ];
+        if (preclr) {
+            pins.push({ name: "PRE", side: "T", invert: preclrinvert });
+            pins.push({ name: "CLR", side: "B", invert: preclrinvert });
+        }
+        super({ ...rest, pins, size: rest.size ?? [2, 3] });
+    }
+}
+export class VoltageRegulator extends Ic {
+    constructor(opts = {}) {
+        const pins = [
+            { name: "in", side: "L", slot: "3/3" },
+            { name: "out", side: "R", slot: "3/3" },
+            { name: "gnd", side: "B" },
+        ];
+        super({ ...opts, pins, size: opts.size ?? [2, 1.5] });
+    }
+}
+export class Ic555 extends Ic {
+    constructor(opts = {}) {
+        const pins = [
+            { name: "TRG", side: "L", pin: "2" },
+            { name: "THR", side: "L", pin: "6" },
+            { name: "DIS", side: "L", pin: "7" },
+            { name: "CTL", side: "R", pin: "5" },
+            { name: "OUT", side: "R", pin: "3" },
+            { name: "RST", side: "T", pin: "4" },
+            { name: "Vcc", side: "T", pin: "8" },
+            { name: "GND", side: "B", pin: "1" },
+        ];
+        super({
+            ...opts,
+            edgepadW: 0.5,
+            edgepadH: 1,
+            pinspacing: 1.5,
+            leadlen: 1,
+            pins,
+            label: "555",
+        });
+    }
+}
+/** 生成七段数码管几何片段（与 Python `sevensegdigit` 对齐）。 */
+export function sevensegdigit(opts) {
+    const bottom = opts.bottom ?? 0;
+    const left = opts.left ?? 0;
+    const seglen = opts.seglen ?? 1.5;
+    const segw = opts.segw ?? 0.3;
+    const spacing = opts.spacing ?? 0.12;
+    const digit = opts.digit ?? 8;
+    const segcolor = opts.segcolor ?? "red";
+    const tilt = opts.tilt ?? 10;
+    const labelsegments = opts.labelsegments ?? true;
+    const halfw = segw / 2;
+    const marginy = segw / 5;
+    const halfspace = spacing / 2;
+    const tiltRad = (tilt * Math.PI) / 180;
+    const lam = Math.sin(tiltRad);
+    let segDx = [halfspace, halfspace + halfw, seglen - halfspace - halfw, seglen - halfspace, seglen - halfspace - halfw, halfspace + halfw];
+    let segDy = [0, halfw, halfw, 0, -halfw, -halfw];
+    let segAx = [...segDx];
+    let segGx = [...segDx];
+    let segAy = segDy.map((k) => k + seglen * 2);
+    let segGy = segDy.map((k) => k + seglen);
+    let segEx = [0, halfw, halfw, 0, -halfw, -halfw];
+    let segEy = [halfspace, halfspace + halfw, seglen - halfspace - halfw, seglen - halfspace, seglen - halfspace - halfw, halfspace + halfw];
+    let segFx = [...segEx];
+    let segFy = segEy.map((k) => k + seglen);
+    let segBx = segEx.map((k) => k + seglen);
+    let segBy = [...segFy];
+    let segCx = [...segBx];
+    let segCy = [...segEy];
+    let segAlabel = [seglen / 2 + halfspace, seglen * 2 + halfw + marginy];
+    let segGlabel = [seglen / 2 + halfspace, seglen + halfw + marginy];
+    let segDlabel = [seglen / 2 + halfspace, halfw + marginy];
+    let segBlabel = [seglen + halfw + halfspace, seglen * 1.5];
+    let segClabel = [seglen + halfw + halfspace, seglen * 0.5];
+    let segElabel = [-halfw - halfspace, seglen * 0.5];
+    let segFlabel = [-halfw - halfspace, seglen * 1.5];
+    const shift = (lab) => [lab[0] + lab[1] * lam, lab[1]];
+    let leftAdj = left;
+    if (tilt !== 0) {
+        segAx = segAx.map((k, i) => k + lam * segAy[i]);
+        segBx = segBx.map((k, i) => k + lam * segBy[i]);
+        segCx = segCx.map((k, i) => k + lam * segCy[i]);
+        segDx = segDx.map((k, i) => k + lam * segDy[i]);
+        segEx = segEx.map((k, i) => k + lam * segEy[i]);
+        segFx = segFx.map((k, i) => k + lam * segFy[i]);
+        segGx = segGx.map((k, i) => k + lam * segGy[i]);
+        segAlabel = shift(segAlabel);
+        segGlabel = shift(segGlabel);
+        segDlabel = shift(segDlabel);
+        segBlabel = shift(segBlabel);
+        segClabel = shift(segClabel);
+        segElabel = shift(segElabel);
+        segFlabel = shift(segFlabel);
+        leftAdj -= lam * seglen;
+    }
+    const tx = (xs) => xs.map((k) => k + leftAdj);
+    const ty = (ys) => ys.map((k) => k + bottom);
+    segDx = tx(segDx);
+    segDy = ty(segDy);
+    segGx = tx(segGx);
+    segGy = ty(segGy);
+    segAx = tx(segAx);
+    segAy = ty(segAy);
+    segEx = tx(segEx);
+    segEy = ty(segEy);
+    segFx = tx(segFx);
+    segFy = ty(segFy);
+    segBx = tx(segBx);
+    segBy = ty(segBy);
+    segCx = tx(segCx);
+    segCy = ty(segCy);
+    segAlabel = [segAlabel[0] + leftAdj, segAlabel[1] + bottom];
+    segGlabel = [segGlabel[0] + leftAdj, segGlabel[1] + bottom];
+    segDlabel = [segDlabel[0] + leftAdj, segDlabel[1] + bottom];
+    segBlabel = [segBlabel[0] + leftAdj, segBlabel[1] + bottom];
+    segClabel = [segClabel[0] + leftAdj, segClabel[1] + bottom];
+    segElabel = [segElabel[0] + leftAdj, segElabel[1] + bottom];
+    segFlabel = [segFlabel[0] + leftAdj, segFlabel[1] + bottom];
+    const ds = String(digit).toLowerCase();
+    const fillA = ["2", "3", "5", "6", "7", "8", "9", "0", "a", "c", "e", "f"].includes(ds) ? segcolor : undefined;
+    const fillB = ["1", "2", "3", "4", "7", "8", "9", "0", "a", "d"].includes(ds) ? segcolor : undefined;
+    const fillC = ["1", "3", "4", "5", "6", "7", "8", "9", "0", "a", "b", "d"].includes(ds) ? segcolor : undefined;
+    const fillD = ["2", "3", "5", "6", "8", "9", "0", "b", "c", "d", "e"].includes(ds) ? segcolor : undefined;
+    const fillE = ["2", "6", "8", "0", "a", "b", "c", "d", "e", "f"].includes(ds) ? segcolor : undefined;
+    const fillF = ["4", "5", "6", "8", "9", "0", "a", "b", "c", "e", "f"].includes(ds) ? segcolor : undefined;
+    const fillG = ["2", "3", "4", "5", "6", "8", "9", "a", "b", "d", "e", "f"].includes(ds) ? segcolor : undefined;
+    const segs = [];
+    const poly = (xs, ys, fill) => segs.push(new SegmentPoly(xs.map((x, i) => [x, ys[i]]), { closed: true, fill: fill ?? false, color: "gray", lw: 0.5 }));
+    poly(segAx, segAy, fillA);
+    poly(segBx, segBy, fillB);
+    poly(segCx, segCy, fillC);
+    poly(segDx, segDy, fillD);
+    poly(segEx, segEy, fillE);
+    poly(segFx, segFy, fillF);
+    poly(segGx, segGy, fillG);
+    if (labelsegments) {
+        segs.push(new SegmentText(segAlabel, "a", { align: ["center", "bottom"], fontsize: 10 }));
+        segs.push(new SegmentText(segGlabel, "g", { align: ["center", "bottom"], fontsize: 10 }));
+        segs.push(new SegmentText(segDlabel, "d", { align: ["center", "bottom"], fontsize: 10 }));
+        segs.push(new SegmentText(segBlabel, "b", { align: ["left", "center"], fontsize: 10 }));
+        segs.push(new SegmentText(segClabel, "c", { align: ["left", "center"], fontsize: 10 }));
+        segs.push(new SegmentText(segElabel, "e", { align: ["right", "center"], fontsize: 10 }));
+        segs.push(new SegmentText(segFlabel, "f", { align: ["right", "center"], fontsize: 10 }));
+    }
+    if (opts.decimal) {
+        const dotrad = 0.15;
+        segs.push(new SegmentCircle([leftAdj + seglen + segw + dotrad / 2, bottom], dotrad, {
+            color: "gray",
+            fill: segcolor,
+            lw: 0.5,
+        }));
+    }
+    return segs;
+}
+export class SevenSegment extends Ic {
+    constructor(opts = {}) {
+        const dec = getParam(opts, "decimal", false);
+        const slots = dec ? "8" : "7";
+        const boxheight = dec ? 5.9 : 5.3;
+        const boxwidth = 3;
+        const size = opts.size ?? [boxwidth, boxheight];
+        const pins = [
+            { pin: "a", side: "L", slot: `${7 + (dec ? 1 : 0)}/${slots}`, anchorname: "a" },
+            { pin: "b", side: "L", slot: `${6 + (dec ? 1 : 0)}/${slots}`, anchorname: "b" },
+            { pin: "c", side: "L", slot: `${5 + (dec ? 1 : 0)}/${slots}`, anchorname: "c" },
+            { pin: "d", side: "L", slot: `${4 + (dec ? 1 : 0)}/${slots}`, anchorname: "d" },
+            { pin: "e", side: "L", slot: `${3 + (dec ? 1 : 0)}/${slots}`, anchorname: "e" },
+            { pin: "f", side: "L", slot: `${2 + (dec ? 1 : 0)}/${slots}`, anchorname: "f" },
+            { pin: "g", side: "L", slot: `${1 + (dec ? 1 : 0)}/${slots}`, anchorname: "g" },
+        ];
+        if (dec) {
+            pins.push({ pin: "dp", side: "L", slot: `1/${slots}`, anchorname: "dp" });
+        }
+        if (getParam(opts, "anode", false)) {
+            pins.push({ pin: "ca", side: "T", anchorname: "anode" });
+        }
+        if (getParam(opts, "cathode", false)) {
+            pins.push({ pin: "cc", side: "B", anchorname: "cathode" });
+        }
+        super({ ...opts, pins, size, pinspacing: 0.6 });
+        const left = 0.8;
+        const seglen = 1.5;
+        const bot = (boxheight - seglen * 2) / 2;
+        this.segments.push(...sevensegdigit({
+            left,
+            bottom: bot,
+            decimal: dec,
+            digit: getParam(opts, "digit", 8),
+            segcolor: getParam(opts, "segcolor", "red"),
+            tilt: getParam(opts, "tilt", 10),
+            labelsegments: getParam(opts, "labelsegments", true),
+        }));
+    }
+}
+/** DIP 封装（双列直插）。 */
+export class IcDIP extends Element {
+    constructor(opts = {}) {
+        super(opts);
+        Object.assign(this.defaults, {
+            pins: 8,
+            notch: true,
+            width: 3,
+            pinw: 0.6,
+            spacing: 0.5,
+            number: true,
+            fontsize: 12,
+            pfontsize: 10,
+        });
+        const w = getParam(this.params, "width", 3);
+        const pw = getParam(this.params, "pinw", 0.6);
+        const space = getParam(this.params, "spacing", 0.5);
+        const np = getParam(this.params, "pins", 8);
+        const names = getParam(this.params, "names", undefined);
+        if (np % 2 === 1) {
+            throw new Error("pins must be even");
+        }
+        const height = (np / 2) * pw + space * (np / 2 + 1);
+        this.segments.push(new SegmentPoly([
+            [0, 0],
+            [w, 0],
+            [w, height],
+            [0, height],
+        ], { closed: true }));
+        if (getParam(this.params, "notch", true)) {
+            const c = w / 2;
+            const theta = linspace(-Math.PI, 0, 50);
+            const notchr = pw / 2;
+            const notchx = theta.map((t) => c + notchr * Math.cos(t));
+            const notchy = theta.map((t) => height + notchr * Math.sin(t));
+            this.segments.push(new Segment(notchx.map((x, i) => [x, notchy[i]])));
+        }
+        const half = np / 2;
+        for (let i = 0; i < half; i++) {
+            const y1 = space + space * i + i * pw;
+            const y2 = space + space * i + (i + 1) * pw;
+            const ymid = (y1 + y2) / 2;
+            this.segments.push(new SegmentPoly([
+                [0, y1],
+                [0, y2],
+                [-pw, y2],
+                [-pw, y1],
+            ], { closed: true }));
+            let pnum = half - i;
+            this.anchors[`p${pnum}`] = [-pw, ymid];
+            this.anchors[`p${pnum}_in`] = [0, ymid];
+            if (getParam(this.params, "number", true)) {
+                this.segments.push(new SegmentText([-pw / 2, ymid], String(pnum), { fontsize: getParam(this.params, "pfontsize", 10) }));
+            }
+            if (names && names[pnum - 1]) {
+                this.segments.push(new SegmentText([0.1, ymid], names[pnum - 1], {
+                    align: ["left", "center"],
+                    fontsize: getParam(this.params, "fontsize", 12),
+                }));
+                this.anchors[names[pnum - 1]] = [-pw, ymid];
+                this.anchors[`${names[pnum - 1]}_in`] = [0, ymid];
+            }
+            this.segments.push(new SegmentPoly([
+                [w, y1],
+                [w, y2],
+                [w + pw, y2],
+                [w + pw, y1],
+            ], { closed: true }));
+            pnum = half + i + 1;
+            this.anchors[`p${pnum}`] = [w + pw, ymid];
+            this.anchors[`p${pnum}_in`] = [w, ymid];
+            if (getParam(this.params, "number", true)) {
+                this.segments.push(new SegmentText([w + pw / 2, ymid], String(pnum), { fontsize: getParam(this.params, "pfontsize", 10) }));
+            }
+            if (names && names[pnum - 1]) {
+                this.segments.push(new SegmentText([w - 0.1, ymid], names[pnum - 1], {
+                    align: ["right", "center"],
+                    fontsize: getParam(this.params, "fontsize", 12),
+                }));
+                this.anchors[names[pnum - 1]] = [w + pw, ymid];
+                this.anchors[`${names[pnum - 1]}_in`] = [w, ymid];
+            }
+        }
+    }
+}
+//# sourceMappingURL=ic.js.map