@skillpet/circuit 0.5.0 → 0.5.2

package/dist/elements/ic.js

@@ -1,816 +0,0 @@
-/**
- * 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