@skillpet/circuit 0.5.0

package/dist/elements/transistors.js

@@ -0,0 +1,1009 @@
+/**
+ * Transistors — subset aligned with Python `elements/transistors.py`.
+ */
+import { Element } from "../element.js";
+import { Element2Term } from "../element2term.js";
+import { getParam } from "../params.js";
+import { GAP, Segment, SegmentCircle, SegmentPoly } from "../segment.js";
+import { reswidth } from "./twoterm.js";
+const u = reswidth * 0.5;
+function addVerticalMos(segments, variant, diode, circle, circleLw) {
+    segments.push(new Segment([
+        [-3 * u, -6.5 * u],
+        [-3 * u, -7.5 * u],
+    ]));
+    segments.push(new Segment([
+        [-3 * u, -9.5 * u],
+        [-3 * u, -10.5 * u],
+    ]));
+    segments.push(new Segment([
+        [-3 * u, -12.5 * u],
+        [-3 * u, -13.5 * u],
+    ]));
+    segments.push(new Segment([[0, -7 * u], [0, 0]]));
+    segments.push(new Segment([[-3 * u, -7 * u], [0, -7 * u]]));
+    segments.push(new Segment([[0, -20 * u], [0, -13 * u]]));
+    segments.push(new Segment([[-3 * u, -13 * u], [0, -13 * u]]));
+    const anchors = {};
+    if (variant === "nmos") {
+        segments.push(new Segment([[-10 * u, -14 * u], [-5 * u, -14 * u]]));
+        segments.push(new Segment([[-5 * u, -14 * u], [-5 * u, -6 * u]]));
+        segments.push(new Segment([[-3 * u, -10 * u], [0, -10 * u]], {
+            arrow: "<-",
+            arrowwidth: 2 * u,
+            arrowlength: 2 * u,
+        }));
+        segments.push(new Segment([[0, -10 * u], [0, -13 * u]]));
+        anchors.drain = [0, 0];
+        anchors.gate = [-10 * u, -14 * u];
+        anchors.center = [0, -10 * u];
+        anchors.source = [0, -20 * u];
+    }
+    else {
+        segments.push(new Segment([[-10 * u, -6 * u], [-5 * u, -6 * u]]));
+        segments.push(new Segment([[-5 * u, -6 * u], [-5 * u, -14 * u]]));
+        segments.push(new Segment([[-3 * u, -10 * u], [0, -10 * u]], {
+            arrow: "->",
+            arrowwidth: 2 * u,
+            arrowlength: 2 * u,
+        }));
+        segments.push(new Segment([[0, -10 * u], [0, -7 * u]]));
+        anchors.source = [0, 0];
+        anchors.gate = [-10 * u, -6 * u];
+        anchors.center = [0, -10 * u];
+        anchors.drain = [0, -20 * u];
+    }
+    if (diode) {
+        segments.push(new Segment([[0, -7 * u], [3 * u, -7 * u]]));
+        segments.push(new Segment([[3 * u, -7 * u], [3 * u, -9 * u]]));
+        segments.push(new Segment([[2 * u, -9 * u], [4 * u, -9 * u]]));
+        segments.push(new SegmentPoly([
+            [3 * u, -9 * u],
+            [2 * u, -11 * u],
+            [4 * u, -11 * u],
+        ], { closed: true, fill: false }));
+        segments.push(new Segment([[3 * u, -11 * u], [3 * u, -13 * u]]));
+        segments.push(new Segment([[3 * u, -13 * u], [0, -13 * u]]));
+    }
+    if (circle) {
+        segments.push(new SegmentCircle([-1 * u, -10 * u], 7 * u, { lw: circleLw }));
+    }
+    return anchors;
+}
+/** Vertical NMOS. */
+export class NMos extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { diode: false, circle: false });
+        const diode = getParam(this.params, "diode", false);
+        const circle = getParam(this.params, "circle", false);
+        const circleLw = getParam(this.params, "circle_lw", undefined);
+        const a = addVerticalMos(this.segments, "nmos", diode, circle, circleLw);
+        Object.assign(this.anchors, a);
+        this.elmParams.drop = [0, -20 * u];
+        this.elmParams.lblloc = "rgt";
+    }
+}
+/** Vertical PMOS. */
+export class PMos extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { diode: false, circle: false });
+        const diode = getParam(this.params, "diode", false);
+        const circle = getParam(this.params, "circle", false);
+        const circleLw = getParam(this.params, "circle_lw", undefined);
+        const a = addVerticalMos(this.segments, "pmos", diode, circle, circleLw);
+        Object.assign(this.anchors, a);
+        this.elmParams.drop = [0, -20 * u];
+        this.elmParams.lblloc = "rgt";
+    }
+}
+function addHorizontalMos2(segments, variant, diode, circle, circleLw) {
+    segments.push(new Segment([
+        [0, 0],
+        [7 * u, 0],
+        [7 * u, -3 * u],
+        GAP,
+        [13 * u, -3 * u],
+        [13 * u, 0],
+        [20 * u, 0],
+    ]));
+    segments.push(new Segment([[6.5 * u, -3 * u], [7.5 * u, -3 * u]]));
+    segments.push(new Segment([[9.5 * u, -3 * u], [10.5 * u, -3 * u]]));
+    segments.push(new Segment([[12.5 * u, -3 * u], [13.5 * u, -3 * u]]));
+    const anchors = {};
+    if (variant === "nmos") {
+        segments.push(new Segment([[14 * u, -10 * u], [14 * u, -5 * u]]));
+        segments.push(new Segment([[14 * u, -5 * u], [6 * u, -5 * u]]));
+        segments.push(new Segment([[10 * u, -3 * u], [10 * u, 0]], {
+            arrow: "<-",
+            arrowwidth: 2 * u,
+            arrowlength: 2 * u,
+        }));
+        segments.push(new Segment([[10 * u, 0], [13 * u, 0]]));
+        anchors.drain = [0, 0];
+        anchors.gate = [14 * u, -10 * u];
+        anchors.source = [20 * u, 0];
+    }
+    else {
+        segments.push(new Segment([[6 * u, -10 * u], [6 * u, -5 * u]]));
+        segments.push(new Segment([[6 * u, -5 * u], [14 * u, -5 * u]]));
+        segments.push(new Segment([[10 * u, -3 * u], [10 * u, 0]], {
+            arrow: "->",
+            arrowwidth: 2 * u,
+            arrowlength: 2 * u,
+        }));
+        segments.push(new Segment([[10 * u, 0], [7 * u, 0]]));
+        anchors.source = [0, 0];
+        anchors.gate = [6 * u, -10 * u];
+        anchors.drain = [20 * u, 0];
+    }
+    anchors.center = [10 * u, 0];
+    if (diode) {
+        segments.push(new Segment([[7 * u, 0], [7 * u, 3 * u]]));
+        segments.push(new Segment([[7 * u, 3 * u], [9 * u, 3 * u]]));
+        segments.push(new Segment([[9 * u, 2 * u], [9 * u, 4 * u]]));
+        segments.push(new SegmentPoly([
+            [9 * u, 3 * u],
+            [11 * u, 2 * u],
+            [11 * u, 4 * u],
+        ], { closed: true, fill: false }));
+        segments.push(new Segment([[11 * u, 3 * u], [13 * u, 3 * u]]));
+        segments.push(new Segment([[13 * u, 3 * u], [13 * u, 0]]));
+    }
+    if (circle) {
+        segments.push(new SegmentCircle([10 * u, -1 * u], 7 * u, { lw: circleLw }));
+    }
+    return anchors;
+}
+export class NMos2 extends Element2Term {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { diode: false, circle: false });
+        const diode = getParam(this.params, "diode", false);
+        const circle = getParam(this.params, "circle", false);
+        const circleLw = getParam(this.params, "circle_lw", undefined);
+        const a = addHorizontalMos2(this.segments, "nmos", diode, circle, circleLw);
+        Object.assign(this.anchors, a);
+        this.elmParams.drop = [20 * u, 0];
+        this.elmParams.lblloc = "bottom";
+    }
+}
+export class PMos2 extends Element2Term {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { diode: false, circle: false });
+        const diode = getParam(this.params, "diode", false);
+        const circle = getParam(this.params, "circle", false);
+        const circleLw = getParam(this.params, "circle_lw", undefined);
+        const a = addHorizontalMos2(this.segments, "pmos", diode, circle, circleLw);
+        Object.assign(this.anchors, a);
+        this.elmParams.drop = [20 * u, 0];
+        this.elmParams.lblloc = "bottom";
+    }
+}
+const fetw = reswidth * 4;
+const feth = reswidth * 5;
+const fetl = feth / 2;
+const fetgap = reswidth;
+const fetr = reswidth * 0.7;
+export class NFet extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { bulk: false, arrowlength: 0.25, arrowwidth: 0.2 });
+        this.segments.push(new Segment([
+            [0, 0],
+            [0, -fetl],
+            [fetw, -fetl],
+            [fetw, -fetl - fetw],
+            [0, -fetl - fetw],
+            [0, -2 * fetl - fetw],
+        ]));
+        this.segments.push(new Segment([[fetw + fetgap, -fetl], [fetw + fetgap, -fetl - fetw]]));
+        this.segments.push(new Segment([[fetw + fetgap, -fetl - fetw / 2], [fetw + fetgap + fetl + fetr, -fetl - fetw / 2]]));
+        this.anchors.source = [0, -2 * fetl - fetw];
+        this.anchors.drain = [0, 0];
+        this.anchors.gate = [fetw + fetgap + fetl + fetr, -fetl - fetw / 2];
+        this.anchors.center = [0, -fetl - fetw / 2];
+        this.elmParams.drop = [0, -2 * fetl - fetw];
+        this.elmParams.lblloc = "lft";
+        if (getParam(this.params, "bulk", false)) {
+            this.segments.push(new Segment([[0, -fetl - fetw / 2], [fetw, -fetl - fetw / 2]], {
+                arrow: "->",
+                arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+                arrowlength: getParam(this.params, "arrowlength", 0.25),
+            }));
+            this.anchors.bulk = [0, -fetl - fetw / 2];
+        }
+    }
+}
+export class PFet extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { bulk: false, arrowlength: 0.25, arrowwidth: 0.2 });
+        this.segments.push(new Segment([
+            [0, 0],
+            [0, -fetl],
+            [fetw, -fetl],
+            [fetw, -fetl - fetw],
+            [0, -fetl - fetw],
+            [0, -2 * fetl - fetw],
+        ]));
+        this.segments.push(new Segment([[fetw + fetgap, -fetl], [fetw + fetgap, -fetl - fetw]]));
+        this.segments.push(new Segment([[fetw + fetgap + fetr * 2, -fetl - fetw / 2], [fetw + fetgap + fetl + fetr, -fetl - fetw / 2]]));
+        this.segments.push(new SegmentCircle([fetw + fetgap + fetr, -fetl - fetw / 2], fetr));
+        this.anchors.source = [0, 0];
+        this.anchors.drain = [0, -2 * fetl - fetw];
+        this.anchors.gate = [fetw + fetgap + fetl + fetr, -fetl - fetw / 2];
+        this.anchors.center = [0, -fetl - fetw / 2];
+        this.elmParams.drop = [0, -2 * fetl - fetw];
+        this.elmParams.lblloc = "lft";
+        if (getParam(this.params, "bulk", false)) {
+            this.segments.push(new Segment([[0, -fetl - fetw / 2], [fetw, -fetl - fetw / 2]], {
+                arrow: "->",
+                arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+                arrowlength: getParam(this.params, "arrowlength", 0.25),
+            }));
+            this.anchors.bulk = [0, -fetl - fetw / 2];
+        }
+    }
+}
+export class NFet2 extends Element2Term {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { bulk: false, arrowlength: 0.25, arrowwidth: 0.2 });
+        this.segments.push(new Segment([
+            [0, 0],
+            [fetl, 0],
+            [fetl, fetw],
+            [fetl + fetw, fetw],
+            [fetl + fetw, 0],
+            [2 * fetl + fetw, 0],
+        ]));
+        this.segments.push(new Segment([[fetl, fetw + fetgap], [fetl + fetw, fetw + fetgap]]));
+        this.segments.push(new Segment([[fetl + fetw / 2, fetw + fetgap], [fetl + fetw / 2, fetw + fetgap + fetr + fetl]]));
+        this.anchors.isource = [2 * fetl + fetw, 0];
+        this.anchors.idrain = [0, 0];
+        this.anchors.gate = [fetl + fetw / 2, fetw + fetgap + fetr + fetl];
+        this.elmParams.lblloc = "bottom";
+        if (getParam(this.params, "bulk", false)) {
+            this.segments.push(new Segment([[fetl + fetw / 2, 0], [fetl + fetw / 2, fetw]], {
+                arrow: "->",
+                arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+                arrowlength: getParam(this.params, "arrowlength", 0.25),
+            }));
+            this.anchors.bulk = [fetl + fetw / 2, 0];
+        }
+    }
+    placeAnchors(start, end) {
+        super.placeAnchors(start, end);
+        this.anchors.source = this.anchors.end;
+        this.anchors.drain = this.anchors.start;
+        if (getParam(this.params, "reverse", false)) {
+            this.anchors.source = this.anchors.start;
+            this.anchors.drain = this.anchors.end;
+        }
+    }
+}
+export class PFet2 extends Element2Term {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { bulk: false, arrowlength: 0.25, arrowwidth: 0.2 });
+        this.segments.push(new Segment([
+            [0, 0],
+            [fetl, 0],
+            [fetl, fetw],
+            [fetl + fetw, fetw],
+            [fetl + fetw, 0],
+            [2 * fetl + fetw, 0],
+        ]));
+        this.segments.push(new Segment([[fetl, fetw + fetgap], [fetl + fetw, fetw + fetgap]]));
+        this.segments.push(new SegmentCircle([fetl + fetw / 2, fetw + fetgap + fetr], fetr));
+        this.segments.push(new Segment([[fetl + fetw / 2, fetw + fetgap + fetr * 2], [fetl + fetw / 2, fetw + fetgap + fetr + fetl]]));
+        this.anchors.isource = [2 * fetl + fetw, 0];
+        this.anchors.idrain = [0, 0];
+        this.anchors.gate = [fetl + fetw / 2, fetw + fetgap + fetr + fetl];
+        this.elmParams.lblloc = "bottom";
+        if (getParam(this.params, "bulk", false)) {
+            this.segments.push(new Segment([[fetl + fetw / 2, 0], [fetl + fetw / 2, fetw]], {
+                arrow: "->",
+                arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+                arrowlength: getParam(this.params, "arrowlength", 0.25),
+            }));
+            this.anchors.bulk = [fetl + fetw / 2, 0];
+        }
+    }
+    placeAnchors(start, end) {
+        super.placeAnchors(start, end);
+        this.anchors.source = this.anchors.end;
+        this.anchors.drain = this.anchors.start;
+        if (getParam(this.params, "reverse", false)) {
+            this.anchors.source = this.anchors.start;
+            this.anchors.drain = this.anchors.end;
+        }
+    }
+}
+// --- Analog-style FETs (Python `AnalogNFet` / `AnalogPFet` / `AnalogBiasedFet`) ---
+const afetw = reswidth * 2.5;
+const afeth = afetw * 2;
+const afetl = afeth * 0.5;
+const afetgap = afetw * 0.2;
+const afeti = afeth * 0.1;
+const afetb = afeti * 0.75;
+const afeta = 0.25;
+/** N 沟道模拟画法 FET（竖向）。 */
+export class AnalogNFet extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { bulk: false, offset_gate: true, arrow: true });
+        const bulk = getParam(this.params, "bulk", false);
+        const offsetGate = getParam(this.params, "offset_gate", true);
+        const arrowParam = getParam(this.params, "arrow", true);
+        const _arrow = arrowParam && !bulk;
+        this.segments.push(new Segment([
+            [0, 0],
+            [0, -afetl],
+            [afetw, -afetl],
+            [afetw, -afetl - afeth],
+            [0, -afetl - afeth],
+            [0, -2 * afetl - afeth],
+        ]));
+        if (_arrow) {
+            this.segments.push(new Segment([
+                [afetw, -afetl - afeth],
+                [0, -afetl - afeth],
+            ], {
+                arrow: "->",
+                arrowwidth: afeta,
+                arrowlength: afeta,
+            }));
+        }
+        this.segments.push(new Segment([
+            [afetw + afetgap, -afetl - afeti],
+            [afetw + afetgap, -afetl - afeth + afeti],
+        ]));
+        if (offsetGate) {
+            this.segments.push(new Segment([
+                [afetw + afetgap, -afetl - afeth + afeti],
+                [afetw + afetgap + afetl, -afetl - afeth + afeti],
+            ]));
+            this.anchors.gate = [afetw + afetgap + afetl, -afetl - afeth + afeti];
+        }
+        else {
+            this.segments.push(new Segment([
+                [afetw + afetgap, -afetl - afeth / 2],
+                [afetw + afetgap + afetl, -afetl - afeth / 2],
+            ]));
+            this.anchors.gate = [afetw + afetgap + afetl, -afetl - afeth / 2];
+        }
+        this.anchors.source = [0, -2 * afetl - afeth];
+        this.anchors.drain = [0, 0];
+        this.anchors.center = [0, -afetl - afeth / 2];
+        this.elmParams.drop = [0, -2 * afetl - afeth];
+        this.elmParams.lblloc = "lft";
+        if (bulk) {
+            this.segments.push(new Segment([
+                [0, -afetl - afeth / 2],
+                [afetw, -afetl - afeth / 2],
+            ], {
+                arrow: "->",
+                arrowwidth: afeta,
+                arrowlength: afeta,
+            }));
+            this.anchors.bulk = [0, -afetl - afeth / 2];
+        }
+    }
+}
+/** P 沟道模拟画法 FET（竖向）。 */
+export class AnalogPFet extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { bulk: false, offset_gate: true, arrow: true });
+        const bulk = getParam(this.params, "bulk", false);
+        const offsetGate = getParam(this.params, "offset_gate", true);
+        const arrowParam = getParam(this.params, "arrow", true);
+        const _arrow = arrowParam && !bulk;
+        this.segments.push(new Segment([
+            [0, 0],
+            [0, -afetl],
+            [afetw, -afetl],
+            [afetw, -afetl - afeth],
+            [0, -afetl - afeth],
+            [0, -2 * afetl - afeth],
+        ]));
+        if (_arrow) {
+            this.segments.push(new Segment([
+                [0, -afetl],
+                [afetw, -afetl],
+            ], {
+                arrow: "->",
+                arrowwidth: afeta,
+                arrowlength: afeta,
+            }));
+        }
+        this.segments.push(new Segment([
+            [afetw + afetgap, -afetl - afeti],
+            [afetw + afetgap, -afetl - afeth + afeti],
+        ]));
+        if (offsetGate) {
+            this.segments.push(new Segment([
+                [afetw + afetgap, -afetl - afeti],
+                [afetw + afetgap + afetl, -afetl - afeti],
+            ]));
+            this.anchors.gate = [afetw + afetgap + afetl, -afetl - afeti];
+        }
+        else {
+            this.segments.push(new Segment([
+                [afetw + afetgap, -afetl - afeth / 2],
+                [afetw + afetgap + afetl, -afetl - afeth / 2],
+            ]));
+            this.anchors.gate = [afetw + afetgap + afetl, -afetl - afeth / 2];
+        }
+        this.anchors.source = [0, 0];
+        this.anchors.drain = [0, -2 * afetl - afeth];
+        this.anchors.center = [0, -afetl - afeth / 2];
+        this.elmParams.drop = [0, -2 * afetl - afeth];
+        this.elmParams.lblloc = "lft";
+        if (bulk) {
+            this.segments.push(new Segment([
+                [afetw, -afetl - afeth / 2],
+                [0, -afetl - afeth / 2],
+            ], {
+                arrow: "->",
+                arrowwidth: afeta,
+                arrowlength: afeta,
+            }));
+            this.anchors.bulk = [0, -afetl - afeth / 2];
+        }
+    }
+}
+/** 带偏置点的小信号 FET（模拟画法）。 */
+export class AnalogBiasedFet extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { bulk: false, offset_gate: true, arrow: true });
+        const bulk = getParam(this.params, "bulk", false);
+        const offsetGate = getParam(this.params, "offset_gate", true);
+        const arrowParam = getParam(this.params, "arrow", true);
+        const _arrow = arrowParam && !bulk;
+        this.segments.push(new Segment([
+            [0, 0],
+            [0, -afetl],
+            [afetw, -afetl],
+            [afetw, -afetl - afeth],
+            [0, -afetl - afeth],
+            [0, -2 * afetl - afeth],
+        ]));
+        if (_arrow) {
+            this.segments.push(new SegmentCircle([afetb * 2, -afetl - afeth], afetb, { fill: true }));
+        }
+        this.segments.push(new Segment([
+            [afetw + afetgap, -afetl - afeti],
+            [afetw + afetgap, -afetl - afeth + afeti],
+        ]));
+        if (offsetGate) {
+            this.segments.push(new Segment([
+                [afetw + afetgap, -afetl - afeth + afeti],
+                [afetw + afetgap + afetl, -afetl - afeth + afeti],
+            ]));
+            this.anchors.gate = [afetw + afetgap + afetl, -afetl - afeth + afeti];
+        }
+        else {
+            this.segments.push(new Segment([
+                [afetw + afetgap, -afetl - afeth / 2],
+                [afetw + afetgap + afetl, -afetl - afeth / 2],
+            ]));
+            this.anchors.gate = [afetw + afetgap + afetl, -afetl - afeth / 2];
+        }
+        this.anchors.source = [0, -2 * afetl - afeth];
+        this.anchors.drain = [0, 0];
+        this.anchors.center = [0, -afetl - afeth / 2];
+        this.elmParams.drop = [0, -2 * afetl - afeth];
+        this.elmParams.lblloc = "lft";
+        if (bulk) {
+            this.segments.push(new Segment([
+                [0, -afetl - afeth / 2],
+                [afetw, -afetl - afeth / 2],
+            ]));
+            this.segments.push(new SegmentCircle([afetw - afetb * 2, -afetl - afeth / 2], afetb, { fill: true }));
+            this.anchors.bulk = [0, -afetl - afeth / 2];
+        }
+    }
+}
+// --- JFET（Python `JFet` / `JFet2` 系）---
+const fete = fetw * 0.2;
+const jfetw = reswidth * 3;
+export class JFet extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, {
+            circle: false,
+            arrowlength: 0.25,
+            arrowwidth: 0.2,
+        });
+        this.segments.push(new Segment([
+            [0, 0],
+            [0, -fetl],
+            [jfetw, -fetl],
+            [jfetw, -fetl + fete],
+            [jfetw, -fetl - jfetw - fete],
+            [jfetw, -fetl - jfetw],
+            [0, -fetl - jfetw],
+            [0, -2 * fetl - jfetw],
+        ]));
+        this.segments.push(new Segment([
+            [jfetw, -fetl - jfetw],
+            [jfetw + fetl, -fetl - jfetw],
+        ]));
+        this.elmParams.drop = [jfetw + fetl, -fetl - jfetw];
+        this.anchors.source = [0, -2 * fetl - jfetw];
+        this.anchors.drain = [0, 0];
+        this.anchors.gate = [jfetw + fetl, -fetl - jfetw];
+        this.anchors.center = [0, -fetl - jfetw / 2];
+        this.elmParams.lblloc = "lft";
+        if (getParam(this.params, "circle", false)) {
+            this.segments.push(new SegmentCircle([jfetw / 2, -fetw], fetw * 1.1, {
+                lw: getParam(this.params, "circle_lw", undefined),
+            }));
+        }
+    }
+}
+export class JFetN extends JFet {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.push(new Segment([
+            [jfetw + 0.1, -fetl - jfetw],
+            [jfetw + 0.3, -fetl - jfetw],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+    }
+}
+export class JFetP extends JFet {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.push(new Segment([
+            [jfetw + 0.25, -fetl - jfetw],
+            [jfetw, -fetl - jfetw],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+    }
+}
+export class JFet2 extends Element2Term {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, {
+            circle: false,
+            arrowlength: 0.25,
+            arrowwidth: 0.2,
+        });
+        this.segments.push(new Segment([
+            [0, 0],
+            [fetl, 0],
+            [fetl, jfetw],
+            [fetl + jfetw, jfetw],
+            [fetl + jfetw, 0],
+            [2 * fetl + jfetw, 0],
+        ]));
+        this.segments.push(new Segment([
+            [fetl - fete, jfetw],
+            [fetl + jfetw + fete, jfetw],
+        ]));
+        this.segments.push(new Segment([
+            [fetl + jfetw, jfetw],
+            [fetl + jfetw, jfetw + fetl],
+        ]));
+        this.anchors.isource = [2 * fetl + jfetw, 0];
+        this.anchors.idrain = [0, 0];
+        this.anchors.gate = [fetl + jfetw, jfetw + fetl];
+        this.elmParams.lblloc = "bottom";
+        if (getParam(this.params, "circle", false)) {
+            this.segments.push(new SegmentCircle([fetl + jfetw / 2, jfetw / 2], fetw * 1.1, {
+                lw: getParam(this.params, "circle_lw", undefined),
+            }));
+        }
+    }
+    placeAnchors(start, end) {
+        super.placeAnchors(start, end);
+        this.anchors.source = this.anchors.end;
+        this.anchors.drain = this.anchors.start;
+        if (getParam(this.params, "reverse", false)) {
+            this.anchors.source = this.anchors.start;
+            this.anchors.drain = this.anchors.end;
+        }
+    }
+}
+export class JFetN2 extends JFet2 {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.push(new Segment([
+            [fetl + jfetw, jfetw],
+            [fetl + jfetw, jfetw + 0.3],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+    }
+}
+export class JFetP2 extends JFet2 {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.push(new Segment([
+            [fetl + jfetw, jfetw + 0.3],
+            [fetl + jfetw, jfetw],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+    }
+}
+const hemtGap = (fetw + 2 * fetr) / 5;
+/** HEMT / 分裂栅 FET（竖向）。 */
+export class Hemt extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { split: true, arrow: true, arrowlength: 0.25, arrowwidth: 0.2 });
+        const split = getParam(this.params, "split", true);
+        const arrow = this.params.arrow;
+        const aw = getParam(this.params, "arrowwidth", 0.2);
+        const al = getParam(this.params, "arrowlength", 0.25);
+        if (split) {
+            this.segments.push(new Segment([
+                [0, 0],
+                [0, -fetl],
+                [fetw, -fetl],
+                GAP,
+                [fetw, -fetl + fetr],
+                [fetw, -fetl + fetr - hemtGap],
+                GAP,
+                [fetw, -fetl + fetr - 2 * hemtGap],
+                [fetw, -fetl + fetr - 3 * hemtGap],
+                GAP,
+                [fetw, -fetl + fetr - 4 * hemtGap],
+                [fetw, -fetl + fetr - 5 * hemtGap],
+                GAP,
+                [fetw, -fetl - fetw],
+                [0, -fetl - fetw],
+                [0, -2 * fetl - fetw],
+            ]));
+        }
+        else {
+            this.segments.push(new Segment([
+                [0, 0],
+                [0, -fetl],
+                [fetw, -fetl],
+                GAP,
+                [fetw, -fetl + fetr],
+                [fetw, -fetl - fetw - fetr],
+                GAP,
+                [fetw, -fetl - fetw],
+                [0, -fetl - fetw],
+                [0, -2 * fetl - fetw],
+            ]));
+        }
+        this.segments.push(new Segment([
+            [fetw, -fetl - fetw / 2],
+            [fetw + fetl + fetr, -fetl - fetw / 2],
+        ]));
+        if (arrow === ">") {
+            this.segments.push(new Segment([
+                [0, -fetl - fetw],
+                [fetw, -fetl - fetw],
+            ], {
+                arrow: "->",
+                arrowwidth: aw,
+                arrowlength: al,
+            }));
+        }
+        else if (arrow !== false) {
+            this.segments.push(new Segment([
+                [0, -fetl - fetw],
+                [fetw, -fetl - fetw],
+            ], {
+                arrow: "<-",
+                arrowwidth: aw,
+                arrowlength: al,
+            }));
+        }
+        this.anchors.drain = [0, -2 * fetl - fetw];
+        this.anchors.source = [0, 0];
+        this.anchors.gate = [fetw + fetl + fetr, -fetl - fetw / 2];
+        this.anchors.center = [0, -fetl - fetw / 2];
+        this.elmParams.drop = [0, -2 * fetl - fetw];
+        this.elmParams.lblloc = "lft";
+    }
+}
+const bjt_r0 = reswidth * 3.3;
+const bjt_v = (bjt_r0 * 2) / 3;
+const bjt_v_len = bjt_r0 * (4 / 3);
+const bjt_a = bjt_v_len / 4;
+const bjt_emx = bjt_v + bjt_r0 * 0.7;
+const bjt_emy = bjt_v_len * 0.7;
+export class Bjt extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { circle: false, arrowwidth: 0.2, arrowlength: 0.25 });
+        this.segments.push(new Segment([[0, 0], [bjt_v, 0]]));
+        this.segments.push(new Segment([[bjt_v, bjt_v_len / 2], [bjt_v, -bjt_v_len / 2]]));
+        this.segments.push(new Segment([
+            [bjt_v, bjt_a],
+            [bjt_emx, bjt_emy],
+            [bjt_emx, bjt_emy + bjt_a],
+        ]));
+        this.segments.push(new Segment([
+            [bjt_v, -bjt_a],
+            [bjt_emx, -bjt_emy],
+            [bjt_emx, -bjt_emy - bjt_a],
+        ]));
+        if (getParam(this.params, "circle", false)) {
+            this.segments.push(new SegmentCircle([bjt_r0, 0], bjt_r0, {
+                lw: getParam(this.params, "circle_lw", undefined),
+            }));
+        }
+        this.elmParams.drop = [bjt_emx, bjt_emy + bjt_a];
+        this.anchors.base = [0, 0];
+        this.anchors.collector = [bjt_emx, bjt_emy + bjt_a];
+        this.anchors.emitter = [bjt_emx, -bjt_emy - bjt_a];
+        this.anchors.center = [bjt_emx, 0];
+    }
+}
+export class BjtNpn extends Bjt {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.push(new Segment([
+            [bjt_v, -bjt_a],
+            [bjt_emx, -bjt_emy],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+    }
+}
+export class BjtPnp extends Bjt {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.push(new Segment([
+            [bjt_emx, bjt_emy],
+            [bjt_v, bjt_a],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+        this.anchors.base = [0, 0];
+        this.anchors.collector = [bjt_emx, -bjt_emy - bjt_a];
+        this.anchors.emitter = [bjt_emx, bjt_emy + bjt_a];
+    }
+}
+const bjt2_r = 0.55;
+const bjt_diag_ofst = 0.2;
+const bjt_base_w = 0.75;
+const bjt_base_h = 0.42;
+const bjt_width = 1.1;
+export class Bjt2 extends Element2Term {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, {
+            circle: false,
+            lblloc: "bottom",
+            theta: 90,
+            arrowwidth: 0.2,
+            arrowlength: 0.25,
+        });
+        this.segments.push(new Segment([
+            [0, 0],
+            [bjt_width / 2 - bjt_diag_ofst, bjt_base_h],
+            [bjt_width / 2 + bjt_diag_ofst, bjt_base_h],
+            [bjt_width, 0],
+        ]));
+        this.segments.push(new Segment([
+            [bjt_width / 2 - bjt_base_w / 2, bjt_base_h],
+            [bjt_width / 2 + bjt_base_w / 2, bjt_base_h],
+        ]));
+        this.segments.push(new Segment([
+            [bjt_width / 2, bjt_base_h],
+            [bjt_width / 2, bjt_base_h + bjt_base_w / 2],
+        ]));
+        if (getParam(this.params, "circle", false)) {
+            this.segments.push(new SegmentCircle([bjt_width / 2, bjt2_r / 2], bjt2_r, {
+                lw: getParam(this.params, "circle_lw", undefined),
+            }));
+        }
+        this.anchors.base = [bjt_width / 2, bjt_base_h + bjt_base_w / 2];
+        this.anchors.icollector = [bjt_width, 0];
+        this.anchors.iemitter = [0, 0];
+    }
+    placeAnchors(start, end) {
+        super.placeAnchors(start, end);
+        this.anchors.emitter = this.anchors.start;
+        this.anchors.collector = this.anchors.end;
+        if (getParam(this.params, "reverse", false)) {
+            this.anchors.emitter = this.anchors.end;
+            this.anchors.collector = this.anchors.start;
+        }
+    }
+}
+export class BjtNpn2 extends Bjt2 {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.push(new Segment([
+            [0, 0],
+            [bjt_width / 2 - bjt_diag_ofst, bjt_base_h],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+    }
+}
+export class BjtPnp2 extends Bjt2 {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.push(new Segment([
+            [bjt_width / 2 + bjt_diag_ofst, bjt_base_h],
+            [bjt_width, 0],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+        const ic = this.anchors.icollector;
+        const ie = this.anchors.iemitter;
+        this.anchors.icollector = ie;
+        this.anchors.iemitter = ic;
+    }
+    placeAnchors(start, end) {
+        super.placeAnchors(start, end);
+        this.anchors.emitter = this.anchors.end;
+        this.anchors.collector = this.anchors.start;
+        if (getParam(this.params, "reverse", false)) {
+            this.anchors.emitter = this.anchors.start;
+            this.anchors.collector = this.anchors.end;
+        }
+    }
+}
+/** PNP 双集电极（竖向 BJT 符号）。 */
+export class BjtPnp2c extends BjtPnp {
+    constructor(userParams = {}) {
+        super(userParams);
+        const dy = -0.25;
+        this.segments.push(new Segment([
+            [bjt_v, -bjt_a - dy],
+            [bjt_emx, -bjt_emy - dy],
+        ]));
+        this.anchors.C2 = [bjt_emx, -bjt_emy - dy];
+    }
+}
+const schottZ = 0.1;
+/** NPN + 肖特基箝位。 */
+export class NpnSchottky extends BjtNpn {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.push(new Segment([
+            [bjt_v, bjt_v_len / 2],
+            [bjt_v, bjt_v_len / 2 + schottZ],
+            [bjt_v + schottZ, bjt_v_len / 2 + schottZ],
+            [bjt_v + schottZ, bjt_v_len / 2],
+        ]));
+        this.segments.push(new Segment([
+            [bjt_v, -bjt_v_len / 2],
+            [bjt_v, -bjt_v_len / 2 - schottZ],
+            [bjt_v - schottZ, -bjt_v_len / 2 - schottZ],
+            [bjt_v - schottZ, -bjt_v_len / 2],
+        ]));
+    }
+}
+/** PNP + 肖特基箝位。 */
+export class PnpSchottky extends BjtPnp {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.push(new Segment([
+            [bjt_v, bjt_v_len / 2],
+            [bjt_v, bjt_v_len / 2 + schottZ],
+            [bjt_v - schottZ, bjt_v_len / 2 + schottZ],
+            [bjt_v - schottZ, bjt_v_len / 2],
+        ]));
+        this.segments.push(new Segment([
+            [bjt_v, -bjt_v_len / 2],
+            [bjt_v, -bjt_v_len / 2 - schottZ],
+            [bjt_v + schottZ, -bjt_v_len / 2 - schottZ],
+            [bjt_v + schottZ, -bjt_v_len / 2],
+        ]));
+    }
+}
+/** NPN 光电晶体管（无基极引线）。 */
+export class NpnPhoto extends BjtNpn {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.shift();
+        const sep = 0.25;
+        this.segments.push(new Segment([
+            [-0.1, bjt_v],
+            [bjt_v * 0.75, 0.1],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+        this.segments.push(new Segment([
+            [-0.1, bjt_v - sep],
+            [bjt_v * 0.75, 0.1 - sep],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+    }
+}
+/** PNP 光电晶体管。 */
+export class PnpPhoto extends BjtPnp {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.shift();
+        const sep = 0.25;
+        this.segments.push(new Segment([
+            [-0.1, bjt_v],
+            [bjt_v * 0.75, 0.1],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+        this.segments.push(new Segment([
+            [-0.1, bjt_v - sep],
+            [bjt_v * 0.75, 0.1 - sep],
+        ], {
+            arrow: "->",
+            arrowwidth: getParam(this.params, "arrowwidth", 0.2),
+            arrowlength: getParam(this.params, "arrowlength", 0.25),
+        }));
+    }
+}
+const igbtGap = 0.15;
+/** N 沟道 IGBT（绝缘栅）。 */
+export class IgbtN extends BjtNpn {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.shift();
+        this.segments.push(new Segment([
+            [bjt_v - igbtGap, bjt_v - igbtGap / 2],
+            [bjt_v - igbtGap, -bjt_v + igbtGap / 2],
+            [bjt_v - igbtGap * 2, -bjt_v + igbtGap / 2],
+        ]));
+        this.anchors.base = [bjt_v - igbtGap * 2, -bjt_v + igbtGap / 2];
+    }
+}
+/** P 沟道 IGBT。 */
+export class IgbtP extends BjtPnp {
+    constructor(userParams = {}) {
+        super(userParams);
+        this.segments.shift();
+        this.segments.push(new Segment([
+            [bjt_v - igbtGap * 2, bjt_v - igbtGap / 2],
+            [bjt_v - igbtGap, bjt_v - igbtGap / 2],
+            [bjt_v - igbtGap, -bjt_v + igbtGap / 2],
+        ]));
+        this.anchors.base = [bjt_v - igbtGap * 2, bjt_v - igbtGap / 2];
+    }
+}
+/** 双集电极 PNP（Bjt2 横版）。 */
+export class BjtPnp2c2 extends BjtPnp2 {
+    constructor(userParams = {}) {
+        super(userParams);
+        const dy = 0.25;
+        this.segments.push(new Segment([
+            [dy, 0],
+            [dy + bjt_width / 2 - bjt_diag_ofst, bjt_base_h],
+        ]));
+        this.anchors.C2 = [dy, 0];
+    }
+}
+//# sourceMappingURL=transistors.js.map